clang-tools  15.0.0git
MarshallingTests.cpp
Go to the documentation of this file.
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"
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 
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;
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
SymbolID.h
clang::clangd::TEST
TEST(BackgroundQueueTest, Priority)
Definition: BackgroundIndexTests.cpp:750
clang::clangd::RelationKind::BaseOf
@ BaseOf
SymbolOrigin.h
clang::clangd::testPath
std::string testPath(PathRef File, llvm::sys::path::Style Style)
Definition: TestFS.cpp:94
clang::clangd::RefKind::Declaration
@ Declaration
clang::clangd::Path
std::string Path
A typedef to represent a file path.
Definition: Path.h:26
SymbolLocation.h
Location
Definition: Modularize.cpp:381
Index.h
clang::clangd::URI::create
static llvm::Expected< URI > create(llvm::StringRef AbsolutePath, llvm::StringRef Scheme)
Creates a URI for a file in the given scheme.
Definition: URI.cpp:209
Marshalling.h
Relation.h
clang::clangd::SymbolOrigin::Remote
@ Remote
clang::clangd::toYAML
std::string toYAML(const Symbol &)
Definition: YAMLSerialization.cpp:472
TestFS.h
clang::clangd::toString
static const char * toString(OffsetEncoding OE)
Definition: Protocol.cpp:1374
Serialization.h
clang::doc::SymbolID
std::array< uint8_t, 20 > SymbolID
Definition: Representation.h:30
Symbol.h
clang::clangd::SymbolOrigin::Static
@ Static
clang::clangd::RefKind::Spelled
@ Spelled
Info
FunctionInfo Info
Definition: FunctionSizeCheck.cpp:121
Strings
std::vector< llvm::StringRef > Strings
Definition: Serialization.cpp:214
ID
static char ID
Definition: Logger.cpp:74
Ref.h
clang::clangd::SymbolID::fromStr
static llvm::Expected< SymbolID > fromStr(llvm::StringRef)
Definition: SymbolID.cpp:36
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
Arena
llvm::BumpPtrAllocator Arena
Definition: Serialization.cpp:213
SymbolInfo
clang::find_all_symbols::SymbolInfo SymbolInfo
Definition: FindAllSymbolsMain.cpp:38
clang::clangd::URI::createFile
static URI createFile(llvm::StringRef AbsolutePath)
This creates a file:// URI for AbsolutePath. The path must be absolute.
Definition: URI.cpp:238
clang::clangd::RelationKind
RelationKind
Definition: Relation.h:20