xref: /llvm-project/clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp (revision 4169c520f6d7029d87098997e9f256a0170aa8cf) 
1 //===--- MarshallingTests.cpp ------------------------------------*- C++-*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "../TestTU.h"
10 #include "Index.pb.h"
11 #include "TestFS.h"
12 #include "index/Index.h"
13 #include "index/Ref.h"
14 #include "index/Relation.h"
15 #include "index/Serialization.h"
16 #include "index/Symbol.h"
17 #include "index/SymbolID.h"
18 #include "index/SymbolLocation.h"
19 #include "index/SymbolOrigin.h"
20 #include "index/remote/marshalling/Marshalling.h"
21 #include "clang/Index/IndexSymbol.h"
22 #include "llvm/ADT/SmallString.h"
23 #include "llvm/ADT/StringRef.h"
24 #include "llvm/ADT/Twine.h"
25 #include "llvm/Support/Error.h"
26 #include "llvm/Support/Path.h"
27 #include "llvm/Support/StringSaver.h"
28 #include "gmock/gmock.h"
29 #include "gtest/gtest.h"
30 #include <cstring>
31 
32 namespace clang {
33 namespace clangd {
34 namespace remote {
35 namespace {
36 
37 using llvm::sys::path::convert_to_slash;
38 
39 const char *testPathURI(llvm::StringRef Path,
40                         llvm::UniqueStringSaver &Strings) {
41   auto URI = URI::createFile(testPath(Path));
42   return Strings.save(URI.toString()).begin();
43 }
44 
45 clangd::Symbol createSymbol(llvm::StringRef PathPrefix,
46                             llvm::UniqueStringSaver &Strings) {
47   clangd::Symbol Sym;
48   Sym.ID = llvm::cantFail(SymbolID::fromStr("057557CEBF6E6B2D"));
49 
50   index::SymbolInfo Info;
51   Info.Kind = index::SymbolKind::Function;
52   Info.SubKind = index::SymbolSubKind::AccessorGetter;
53   Info.Lang = index::SymbolLanguage::CXX;
54   Info.Properties = static_cast<index::SymbolPropertySet>(
55       index::SymbolProperty::TemplateSpecialization);
56   Sym.SymInfo = Info;
57 
58   Sym.Name = Strings.save("Foo");
59   Sym.Scope = Strings.save("llvm::foo::bar::");
60 
61   clangd::SymbolLocation Location;
62   Location.Start.setLine(1);
63   Location.Start.setColumn(15);
64   Location.End.setLine(3);
65   Location.End.setColumn(121);
66   Location.FileURI = testPathURI(PathPrefix.str() + "Definition.cpp", Strings);
67   Sym.Definition = Location;
68 
69   Location.Start.setLine(42);
70   Location.Start.setColumn(31);
71   Location.End.setLine(20);
72   Location.End.setColumn(400);
73   Location.FileURI = testPathURI(PathPrefix.str() + "Declaration.h", Strings);
74   Sym.CanonicalDeclaration = Location;
75 
76   Sym.References = 9000;
77   Sym.Origin = clangd::SymbolOrigin::Static;
78   Sym.Signature = Strings.save("(int X, char Y, Type T)");
79   Sym.TemplateSpecializationArgs = Strings.save("<int, char, bool, Type>");
80   Sym.CompletionSnippetSuffix =
81       Strings.save("({1: int X}, {2: char Y}, {3: Type T})");
82   Sym.Documentation = Strings.save("This is my amazing Foo constructor!");
83   Sym.ReturnType = Strings.save("Foo");
84 
85   Sym.Flags = clangd::Symbol::SymbolFlag::IndexedForCodeCompletion;
86 
87   return Sym;
88 }
89 
90 TEST(RemoteMarshallingTest, URITranslation) {
91   llvm::BumpPtrAllocator Arena;
92   llvm::UniqueStringSaver Strings(Arena);
93   Marshaller ProtobufMarshaller(
94       testPath("remote/machine/projects/llvm-project/"),
95       testPath("home/my-projects/llvm-project/"));
96   clangd::Ref Original;
97   Original.Location.FileURI =
98       testPathURI("remote/machine/projects/llvm-project/clang-tools-extra/"
99                   "clangd/unittests/remote/MarshallingTests.cpp",
100                   Strings);
101   auto Serialized = ProtobufMarshaller.toProtobuf(Original);
102   ASSERT_TRUE(bool(Serialized));
103   EXPECT_EQ(Serialized->location().file_path(),
104             "clang-tools-extra/clangd/unittests/remote/MarshallingTests.cpp");
105   auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
106   ASSERT_TRUE(bool(Deserialized));
107   EXPECT_STREQ(Deserialized->Location.FileURI,
108                testPathURI("home/my-projects/llvm-project/clang-tools-extra/"
109                            "clangd/unittests/remote/MarshallingTests.cpp",
110                            Strings));
111 
112   // Can't have empty paths.
113   *Serialized->mutable_location()->mutable_file_path() = std::string();
114   Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
115   EXPECT_FALSE(bool(Deserialized));
116   llvm::consumeError(Deserialized.takeError());
117 
118   clangd::Ref WithInvalidURI;
119   // Invalid URI results in serialization failure.
120   WithInvalidURI.Location.FileURI = "This is not a URI";
121   auto DeserializedRef = ProtobufMarshaller.toProtobuf(WithInvalidURI);
122   EXPECT_FALSE(bool(DeserializedRef));
123   llvm::consumeError(DeserializedRef.takeError());
124 
125   // Can not use URIs with scheme different from "file".
126   auto UnittestURI =
127       URI::create(testPath("project/lib/HelloWorld.cpp"), "unittest");
128   ASSERT_TRUE(bool(UnittestURI));
129   WithInvalidURI.Location.FileURI =
130       Strings.save(UnittestURI->toString()).begin();
131   auto DeserializedSymbol = ProtobufMarshaller.toProtobuf(WithInvalidURI);
132   EXPECT_FALSE(bool(DeserializedSymbol));
133   llvm::consumeError(DeserializedSymbol.takeError());
134 
135   // Paths transmitted over the wire can not be absolute, they have to be
136   // relative.
137   Ref WithAbsolutePath;
138   *WithAbsolutePath.mutable_location()->mutable_file_path() =
139       "/usr/local/user/home/HelloWorld.cpp";
140   Deserialized = ProtobufMarshaller.fromProtobuf(WithAbsolutePath);
141   EXPECT_FALSE(bool(Deserialized));
142   llvm::consumeError(Deserialized.takeError());
143 }
144 
145 TEST(RemoteMarshallingTest, SymbolSerialization) {
146   llvm::BumpPtrAllocator Arena;
147   llvm::UniqueStringSaver Strings(Arena);
148 
149   clangd::Symbol Sym = createSymbol("home/", Strings);
150   Marshaller ProtobufMarshaller(testPath("home/"), testPath("home/"));
151 
152   // Check that symbols are exactly the same if the path to indexed project is
153   // the same on indexing machine and the client.
154   auto Serialized = ProtobufMarshaller.toProtobuf(Sym);
155   ASSERT_TRUE(bool(Serialized));
156   auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
157   ASSERT_TRUE(bool(Deserialized));
158   // Origin is overwritten when deserializing.
159   Sym.Origin = SymbolOrigin::Remote;
160   EXPECT_EQ(toYAML(Sym), toYAML(*Deserialized));
161   // Serialized paths are relative and have UNIX slashes.
162   EXPECT_EQ(convert_to_slash(Serialized->definition().file_path(),
163                              llvm::sys::path::Style::posix),
164             Serialized->definition().file_path());
165   EXPECT_TRUE(
166       llvm::sys::path::is_relative(Serialized->definition().file_path()));
167 
168   // Missing definition is OK.
169   Sym.Definition = clangd::SymbolLocation();
170   Serialized = ProtobufMarshaller.toProtobuf(Sym);
171   ASSERT_TRUE(bool(Serialized));
172   ASSERT_TRUE(bool(ProtobufMarshaller.fromProtobuf(*Serialized)));
173 
174   // Relative path is absolute.
175   *Serialized->mutable_canonical_declaration()->mutable_file_path() =
176       convert_to_slash("/path/to/Declaration.h");
177   Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
178   EXPECT_FALSE(bool(Deserialized));
179   llvm::consumeError(Deserialized.takeError());
180 
181   // Fail with an invalid URI.
182   Sym.Definition.FileURI = "Not A URI";
183   Serialized = ProtobufMarshaller.toProtobuf(Sym);
184   EXPECT_FALSE(bool(Serialized));
185   llvm::consumeError(Serialized.takeError());
186 
187   // Schemes other than "file" can not be used.
188   auto UnittestURI = URI::create(testPath("home/SomePath.h"), "unittest");
189   ASSERT_TRUE(bool(UnittestURI));
190   Sym.Definition.FileURI = Strings.save(UnittestURI->toString()).begin();
191   Serialized = ProtobufMarshaller.toProtobuf(Sym);
192   EXPECT_FALSE(bool(Serialized));
193   llvm::consumeError(Serialized.takeError());
194 
195   // Passing root that is not prefix of the original file path.
196   Sym.Definition.FileURI = testPathURI("home/File.h", Strings);
197   // Check that the symbol is valid and passing the correct path works.
198   Serialized = ProtobufMarshaller.toProtobuf(Sym);
199   ASSERT_TRUE(bool(Serialized));
200   Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
201   ASSERT_TRUE(bool(Deserialized));
202   EXPECT_STREQ(Deserialized->Definition.FileURI,
203                testPathURI("home/File.h", Strings));
204   // Fail with a wrong root.
205   Marshaller WrongMarshaller(testPath("nothome/"), testPath("home/"));
206   Serialized = WrongMarshaller.toProtobuf(Sym);
207   EXPECT_FALSE(Serialized);
208   llvm::consumeError(Serialized.takeError());
209 }
210 
211 TEST(RemoteMarshallingTest, RefSerialization) {
212   clangd::Ref Ref;
213   Ref.Kind = clangd::RefKind::Spelled | clangd::RefKind::Declaration;
214 
215   llvm::BumpPtrAllocator Arena;
216   llvm::UniqueStringSaver Strings(Arena);
217 
218   clangd::SymbolLocation Location;
219   Location.Start.setLine(124);
220   Location.Start.setColumn(21);
221   Location.End.setLine(3213);
222   Location.End.setColumn(541);
223   Location.FileURI = testPathURI(
224       "llvm-project/llvm/clang-tools-extra/clangd/Protocol.h", Strings);
225   Ref.Location = Location;
226 
227   Marshaller ProtobufMarshaller(testPath("llvm-project/"),
228                                 testPath("llvm-project/"));
229 
230   auto Serialized = ProtobufMarshaller.toProtobuf(Ref);
231   ASSERT_TRUE(bool(Serialized));
232   auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
233   ASSERT_TRUE(bool(Deserialized));
234   EXPECT_EQ(toYAML(Ref), toYAML(*Deserialized));
235 }
236 
237 TEST(RemoteMarshallingTest, IncludeHeaderURIs) {
238   llvm::BumpPtrAllocator Arena;
239   llvm::UniqueStringSaver Strings(Arena);
240 
241   clangd::Symbol Sym = createSymbol("remote/", Strings);
242 
243   clangd::Symbol::IncludeHeaderWithReferences Header;
244   // Add only valid headers.
245   Header.IncludeHeader =
246       Strings.save(URI::createFile(testPath("project/Header.h")).toString());
247   Header.References = 21;
248   Sym.IncludeHeaders.push_back(Header);
249   Header.IncludeHeader = Strings.save("<iostream>");
250   Header.References = 100;
251   Sym.IncludeHeaders.push_back(Header);
252   Header.IncludeHeader = Strings.save("\"cstdio\"");
253   Header.References = 200;
254   Sym.IncludeHeaders.push_back(Header);
255 
256   Marshaller ProtobufMarshaller(testPath(""), testPath(""));
257 
258   auto Serialized = ProtobufMarshaller.toProtobuf(Sym);
259   ASSERT_TRUE(bool(Serialized));
260   EXPECT_EQ(static_cast<size_t>(Serialized->headers_size()),
261             Sym.IncludeHeaders.size());
262   auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
263   ASSERT_TRUE(bool(Deserialized));
264   Sym.Origin = SymbolOrigin::Remote;
265   EXPECT_EQ(toYAML(Sym), toYAML(*Deserialized));
266 
267   // This is an absolute path to a header: can not be transmitted over the wire.
268   Header.IncludeHeader = Strings.save(testPath("project/include/Common.h"));
269   Header.References = 42;
270   Sym.IncludeHeaders.push_back(Header);
271   Serialized = ProtobufMarshaller.toProtobuf(Sym);
272   EXPECT_FALSE(bool(Serialized));
273   llvm::consumeError(Serialized.takeError());
274 
275   // Remove last invalid header.
276   Sym.IncludeHeaders.pop_back();
277   // This is not a valid header: can not be transmitted over the wire;
278   Header.IncludeHeader = Strings.save("NotAHeader");
279   Header.References = 5;
280   Sym.IncludeHeaders.push_back(Header);
281   Serialized = ProtobufMarshaller.toProtobuf(Sym);
282   EXPECT_FALSE(bool(Serialized));
283   llvm::consumeError(Serialized.takeError());
284 
285   // Try putting an invalid header into already serialized symbol.
286   Sym.IncludeHeaders.pop_back();
287   Serialized = ProtobufMarshaller.toProtobuf(Sym);
288   ASSERT_TRUE(bool(Serialized));
289   HeaderWithReferences InvalidHeader;
290   InvalidHeader.set_header(convert_to_slash("/absolute/path/Header.h"));
291   InvalidHeader.set_references(9000);
292   *Serialized->add_headers() = InvalidHeader;
293   Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
294   EXPECT_FALSE(bool(Deserialized));
295   llvm::consumeError(Deserialized.takeError());
296 }
297 
298 TEST(RemoteMarshallingTest, LookupRequestSerialization) {
299   clangd::LookupRequest Request;
300   Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000001")));
301   Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000002")));
302 
303   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
304 
305   auto Serialized = ProtobufMarshaller.toProtobuf(Request);
306   EXPECT_EQ(static_cast<unsigned>(Serialized.ids_size()), Request.IDs.size());
307   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
308   ASSERT_TRUE(bool(Deserialized));
309   EXPECT_EQ(Deserialized->IDs, Request.IDs);
310 }
311 
312 TEST(RemoteMarshallingTest, LookupRequestFailingSerialization) {
313   clangd::LookupRequest Request;
314   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
315   auto Serialized = ProtobufMarshaller.toProtobuf(Request);
316   Serialized.add_ids("Invalid Symbol ID");
317   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
318   EXPECT_FALSE(bool(Deserialized));
319   llvm::consumeError(Deserialized.takeError());
320 }
321 
322 TEST(RemoteMarshallingTest, FuzzyFindRequestSerialization) {
323   clangd::FuzzyFindRequest Request;
324   Request.ProximityPaths = {testPath("local/Header.h"),
325                             testPath("local/subdir/OtherHeader.h"),
326                             testPath("remote/File.h"), "Not a Path."};
327   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
328   auto Serialized = ProtobufMarshaller.toProtobuf(Request);
329   EXPECT_EQ(Serialized.proximity_paths_size(), 2);
330   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
331   ASSERT_TRUE(bool(Deserialized));
332   EXPECT_THAT(Deserialized->ProximityPaths,
333               testing::ElementsAre(testPath("remote/Header.h"),
334                                    testPath("remote/subdir/OtherHeader.h")));
335 }
336 
337 TEST(RemoteMarshallingTest, RefsRequestSerialization) {
338   clangd::RefsRequest Request;
339   Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000001")));
340   Request.IDs.insert(llvm::cantFail(SymbolID::fromStr("0000000000000002")));
341 
342   Request.Limit = 9000;
343   Request.Filter = RefKind::Spelled | RefKind::Declaration;
344 
345   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
346 
347   auto Serialized = ProtobufMarshaller.toProtobuf(Request);
348   EXPECT_EQ(static_cast<unsigned>(Serialized.ids_size()), Request.IDs.size());
349   EXPECT_EQ(Serialized.limit(), Request.Limit);
350   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
351   ASSERT_TRUE(bool(Deserialized));
352   EXPECT_EQ(Deserialized->IDs, Request.IDs);
353   ASSERT_TRUE(Deserialized->Limit);
354   EXPECT_EQ(*Deserialized->Limit, Request.Limit);
355   EXPECT_EQ(Deserialized->Filter, Request.Filter);
356 }
357 
358 TEST(RemoteMarshallingTest, RefsRequestFailingSerialization) {
359   clangd::RefsRequest Request;
360   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
361   auto Serialized = ProtobufMarshaller.toProtobuf(Request);
362   Serialized.add_ids("Invalid Symbol ID");
363   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
364   EXPECT_FALSE(bool(Deserialized));
365   llvm::consumeError(Deserialized.takeError());
366 }
367 
368 TEST(RemoteMarshallingTest, RelationsRequestSerialization) {
369   clangd::RelationsRequest Request;
370   Request.Subjects.insert(
371       llvm::cantFail(SymbolID::fromStr("0000000000000001")));
372   Request.Subjects.insert(
373       llvm::cantFail(SymbolID::fromStr("0000000000000002")));
374 
375   Request.Limit = 9000;
376   Request.Predicate = RelationKind::BaseOf;
377 
378   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
379 
380   auto Serialized = ProtobufMarshaller.toProtobuf(Request);
381   EXPECT_EQ(static_cast<unsigned>(Serialized.subjects_size()),
382             Request.Subjects.size());
383   EXPECT_EQ(Serialized.limit(), Request.Limit);
384   EXPECT_EQ(static_cast<RelationKind>(Serialized.predicate()),
385             Request.Predicate);
386   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
387   ASSERT_TRUE(bool(Deserialized));
388   EXPECT_EQ(Deserialized->Subjects, Request.Subjects);
389   ASSERT_TRUE(Deserialized->Limit);
390   EXPECT_EQ(*Deserialized->Limit, Request.Limit);
391   EXPECT_EQ(Deserialized->Predicate, Request.Predicate);
392 }
393 
394 TEST(RemoteMarshallingTest, RelationsRequestFailingSerialization) {
395   RelationsRequest Serialized;
396   Serialized.add_subjects("ZZZZZZZZZZZZZZZZ");
397   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
398   auto Deserialized = ProtobufMarshaller.fromProtobuf(&Serialized);
399   EXPECT_FALSE(bool(Deserialized));
400   llvm::consumeError(Deserialized.takeError());
401 }
402 
403 TEST(RemoteMarshallingTest, RelationsSerializion) {
404   llvm::BumpPtrAllocator Arena;
405   llvm::UniqueStringSaver Strings(Arena);
406 
407   clangd::Symbol Sym = createSymbol("remote/", Strings);
408   SymbolID ID = llvm::cantFail(SymbolID::fromStr("0000000000000002"));
409   Marshaller ProtobufMarshaller(testPath("remote/"), testPath("local/"));
410   auto Serialized = ProtobufMarshaller.toProtobuf(ID, Sym);
411   ASSERT_TRUE(bool(Serialized));
412   auto Deserialized = ProtobufMarshaller.fromProtobuf(*Serialized);
413   ASSERT_TRUE(bool(Deserialized));
414   EXPECT_THAT(Deserialized->first, ID);
415   EXPECT_THAT(Deserialized->second.ID, Sym.ID);
416 }
417 
418 TEST(RemoteMarshallingTest, RelativePathToURITranslation) {
419   Marshaller ProtobufMarshaller(/*RemoteIndexRoot=*/"",
420                                 /*LocalIndexRoot=*/testPath("home/project/"));
421   auto URIString = ProtobufMarshaller.relativePathToURI("lib/File.cpp");
422   ASSERT_TRUE(bool(URIString));
423   // RelativePath can not be absolute.
424   URIString = ProtobufMarshaller.relativePathToURI("/lib/File.cpp");
425   EXPECT_FALSE(bool(URIString));
426   llvm::consumeError(URIString.takeError());
427   // RelativePath can not be empty.
428   URIString = ProtobufMarshaller.relativePathToURI(std::string());
429   EXPECT_FALSE(bool(URIString));
430   llvm::consumeError(URIString.takeError());
431 }
432 
433 TEST(RemoteMarshallingTest, URIToRelativePathTranslation) {
434   llvm::BumpPtrAllocator Arena;
435   llvm::UniqueStringSaver Strings(Arena);
436   Marshaller ProtobufMarshaller(/*RemoteIndexRoot=*/testPath("remote/project/"),
437                                 /*LocalIndexRoot=*/"");
438   auto RelativePath = ProtobufMarshaller.uriToRelativePath(
439       testPathURI("remote/project/lib/File.cpp", Strings));
440   ASSERT_TRUE(bool(RelativePath));
441   // RemoteIndexRoot has to be be a prefix of the file path.
442   Marshaller WrongMarshaller(
443       /*RemoteIndexRoot=*/testPath("remote/other/project/"),
444       /*LocalIndexRoot=*/"");
445   RelativePath = WrongMarshaller.uriToRelativePath(
446       testPathURI("remote/project/lib/File.cpp", Strings));
447   EXPECT_FALSE(bool(RelativePath));
448   llvm::consumeError(RelativePath.takeError());
449 }
450 
451 } // namespace
452 } // namespace remote
453 } // namespace clangd
454 } // namespace clang
455