clang-tools  15.0.0git
SourceCodeTests.cpp
Go to the documentation of this file.
1 //===-- SourceCodeTests.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 #include "Annotations.h"
9 #include "Protocol.h"
10 #include "SourceCode.h"
11 #include "TestTU.h"
12 #include "support/Context.h"
13 #include "clang/Basic/LangOptions.h"
14 #include "clang/Basic/SourceLocation.h"
15 #include "clang/Basic/TokenKinds.h"
16 #include "clang/Format/Format.h"
17 #include "llvm/Support/Error.h"
18 #include "llvm/Testing/Support/Annotations.h"
19 #include "llvm/Testing/Support/Error.h"
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22 #include <tuple>
23 
24 namespace clang {
25 namespace clangd {
26 namespace {
27 
28 using llvm::Failed;
29 using llvm::FailedWithMessage;
30 using llvm::HasValue;
31 
32 MATCHER_P2(Pos, Line, Col, "") {
33  return arg.line == int(Line) && arg.character == int(Col);
34 }
35 
36 MATCHER_P(macroName, Name, "") { return arg.Name == Name; }
37 
38 /// A helper to make tests easier to read.
39 Position position(int Line, int Character) {
40  Position Pos;
41  Pos.line = Line;
42  Pos.character = Character;
43  return Pos;
44 }
45 
46 TEST(SourceCodeTests, lspLength) {
47  EXPECT_EQ(lspLength(""), 0UL);
48  EXPECT_EQ(lspLength("ascii"), 5UL);
49  // BMP
50  EXPECT_EQ(lspLength("↓"), 1UL);
51  EXPECT_EQ(lspLength("¥"), 1UL);
52  // astral
53  EXPECT_EQ(lspLength("😂"), 2UL);
54 
56  EXPECT_EQ(lspLength(""), 0UL);
57  EXPECT_EQ(lspLength("ascii"), 5UL);
58  // BMP
59  EXPECT_EQ(lspLength("↓"), 3UL);
60  EXPECT_EQ(lspLength("¥"), 2UL);
61  // astral
62  EXPECT_EQ(lspLength("😂"), 4UL);
63 
65  EXPECT_EQ(lspLength(""), 0UL);
66  EXPECT_EQ(lspLength("ascii"), 5UL);
67  // BMP
68  EXPECT_EQ(lspLength("↓"), 1UL);
69  EXPECT_EQ(lspLength("¥"), 1UL);
70  // astral
71  EXPECT_EQ(lspLength("😂"), 1UL);
72 }
73 
74 TEST(SourceCodeTests, lspLengthBadUTF8) {
75  // Results are not well-defined if source file isn't valid UTF-8.
76  // However we shouldn't crash or return something totally wild.
77  const char *BadUTF8[] = {"\xa0", "\xff\xff\xff\xff\xff"};
78 
79  for (OffsetEncoding Encoding :
81  WithContextValue UTF32(kCurrentOffsetEncoding, Encoding);
82  for (const char *Bad : BadUTF8) {
83  EXPECT_GE(lspLength(Bad), 0u);
84  EXPECT_LE(lspLength(Bad), strlen(Bad));
85  }
86  }
87 }
88 
89 // The = → 🡆 below are ASCII (1 byte), BMP (3 bytes), and astral (4 bytes).
90 const char File[] = R"(0:0 = 0
91 1:0 → 8
92 2:0 🡆 18)";
93 struct Line {
94  unsigned Number;
95  unsigned Offset;
96  unsigned Length;
97 };
98 Line FileLines[] = {Line{0, 0, 7}, Line{1, 8, 9}, Line{2, 18, 11}};
99 
100 TEST(SourceCodeTests, PositionToOffset) {
101  // line out of bounds
102  EXPECT_THAT_EXPECTED(positionToOffset(File, position(-1, 2)), llvm::Failed());
103  // first line
104  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, -1)),
105  llvm::Failed()); // out of range
106  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 0)),
107  llvm::HasValue(0)); // first character
108  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 3)),
109  llvm::HasValue(3)); // middle character
110  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 6)),
111  llvm::HasValue(6)); // last character
112  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7)),
113  llvm::HasValue(7)); // the newline itself
114  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7), false),
115  llvm::HasValue(7));
116  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8)),
117  llvm::HasValue(7)); // out of range
118  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8), false),
119  llvm::Failed()); // out of range
120  // middle line
121  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, -1)),
122  llvm::Failed()); // out of range
123  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 0)),
124  llvm::HasValue(8)); // first character
125  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3)),
126  llvm::HasValue(11)); // middle character
127  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3), false),
128  llvm::HasValue(11));
129  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 6)),
130  llvm::HasValue(16)); // last character
131  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 7)),
132  llvm::HasValue(17)); // the newline itself
133  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8)),
134  llvm::HasValue(17)); // out of range
135  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8), false),
136  llvm::Failed()); // out of range
137  // last line
138  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, -1)),
139  llvm::Failed()); // out of range
140  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 0)),
141  llvm::HasValue(18)); // first character
142  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 3)),
143  llvm::HasValue(21)); // middle character
144  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 5), false),
145  llvm::Failed()); // middle of surrogate pair
146  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 5)),
147  llvm::HasValue(26)); // middle of surrogate pair
148  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 6), false),
149  llvm::HasValue(26)); // end of surrogate pair
150  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 8)),
151  llvm::HasValue(28)); // last character
152  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 9)),
153  llvm::HasValue(29)); // EOF
154  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 10), false),
155  llvm::Failed()); // out of range
156  // line out of bounds
157  EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 0)), llvm::Failed());
158  EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 1)), llvm::Failed());
159 
160  // Codepoints are similar, except near astral characters.
162  // line out of bounds
163  EXPECT_THAT_EXPECTED(positionToOffset(File, position(-1, 2)), llvm::Failed());
164  // first line
165  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, -1)),
166  llvm::Failed()); // out of range
167  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 0)),
168  llvm::HasValue(0)); // first character
169  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 3)),
170  llvm::HasValue(3)); // middle character
171  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 6)),
172  llvm::HasValue(6)); // last character
173  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7)),
174  llvm::HasValue(7)); // the newline itself
175  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7), false),
176  llvm::HasValue(7));
177  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8)),
178  llvm::HasValue(7)); // out of range
179  EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8), false),
180  llvm::Failed()); // out of range
181  // middle line
182  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, -1)),
183  llvm::Failed()); // out of range
184  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 0)),
185  llvm::HasValue(8)); // first character
186  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3)),
187  llvm::HasValue(11)); // middle character
188  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3), false),
189  llvm::HasValue(11));
190  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 6)),
191  llvm::HasValue(16)); // last character
192  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 7)),
193  llvm::HasValue(17)); // the newline itself
194  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8)),
195  llvm::HasValue(17)); // out of range
196  EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8), false),
197  llvm::Failed()); // out of range
198  // last line
199  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, -1)),
200  llvm::Failed()); // out of range
201  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 0)),
202  llvm::HasValue(18)); // first character
203  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 4)),
204  llvm::HasValue(22)); // Before astral character.
205  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 5), false),
206  llvm::HasValue(26)); // after astral character
207  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 7)),
208  llvm::HasValue(28)); // last character
209  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 8)),
210  llvm::HasValue(29)); // EOF
211  EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 9), false),
212  llvm::Failed()); // out of range
213  // line out of bounds
214  EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 0)), llvm::Failed());
215  EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 1)), llvm::Failed());
216 
217  // Test UTF-8, where transformations are trivial.
219  EXPECT_THAT_EXPECTED(positionToOffset(File, position(-1, 2)), llvm::Failed());
220  EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 0)), llvm::Failed());
221  for (Line L : FileLines) {
222  EXPECT_THAT_EXPECTED(positionToOffset(File, position(L.Number, -1)),
223  llvm::Failed()); // out of range
224  for (unsigned I = 0; I <= L.Length; ++I)
225  EXPECT_THAT_EXPECTED(positionToOffset(File, position(L.Number, I)),
226  llvm::HasValue(L.Offset + I));
227  EXPECT_THAT_EXPECTED(
228  positionToOffset(File, position(L.Number, L.Length + 1)),
229  llvm::HasValue(L.Offset + L.Length));
230  EXPECT_THAT_EXPECTED(
231  positionToOffset(File, position(L.Number, L.Length + 1), false),
232  llvm::Failed()); // out of range
233  }
234 }
235 
236 TEST(SourceCodeTests, OffsetToPosition) {
237  EXPECT_THAT(offsetToPosition(File, 0), Pos(0, 0)) << "start of file";
238  EXPECT_THAT(offsetToPosition(File, 3), Pos(0, 3)) << "in first line";
239  EXPECT_THAT(offsetToPosition(File, 6), Pos(0, 6)) << "end of first line";
240  EXPECT_THAT(offsetToPosition(File, 7), Pos(0, 7)) << "first newline";
241  EXPECT_THAT(offsetToPosition(File, 8), Pos(1, 0)) << "start of second line";
242  EXPECT_THAT(offsetToPosition(File, 12), Pos(1, 4)) << "before BMP char";
243  EXPECT_THAT(offsetToPosition(File, 13), Pos(1, 5)) << "in BMP char";
244  EXPECT_THAT(offsetToPosition(File, 15), Pos(1, 5)) << "after BMP char";
245  EXPECT_THAT(offsetToPosition(File, 16), Pos(1, 6)) << "end of second line";
246  EXPECT_THAT(offsetToPosition(File, 17), Pos(1, 7)) << "second newline";
247  EXPECT_THAT(offsetToPosition(File, 18), Pos(2, 0)) << "start of last line";
248  EXPECT_THAT(offsetToPosition(File, 21), Pos(2, 3)) << "in last line";
249  EXPECT_THAT(offsetToPosition(File, 22), Pos(2, 4)) << "before astral char";
250  EXPECT_THAT(offsetToPosition(File, 24), Pos(2, 6)) << "in astral char";
251  EXPECT_THAT(offsetToPosition(File, 26), Pos(2, 6)) << "after astral char";
252  EXPECT_THAT(offsetToPosition(File, 28), Pos(2, 8)) << "end of last line";
253  EXPECT_THAT(offsetToPosition(File, 29), Pos(2, 9)) << "EOF";
254  EXPECT_THAT(offsetToPosition(File, 30), Pos(2, 9)) << "out of bounds";
255 
256  // Codepoints are similar, except near astral characters.
258  EXPECT_THAT(offsetToPosition(File, 0), Pos(0, 0)) << "start of file";
259  EXPECT_THAT(offsetToPosition(File, 3), Pos(0, 3)) << "in first line";
260  EXPECT_THAT(offsetToPosition(File, 6), Pos(0, 6)) << "end of first line";
261  EXPECT_THAT(offsetToPosition(File, 7), Pos(0, 7)) << "first newline";
262  EXPECT_THAT(offsetToPosition(File, 8), Pos(1, 0)) << "start of second line";
263  EXPECT_THAT(offsetToPosition(File, 12), Pos(1, 4)) << "before BMP char";
264  EXPECT_THAT(offsetToPosition(File, 13), Pos(1, 5)) << "in BMP char";
265  EXPECT_THAT(offsetToPosition(File, 15), Pos(1, 5)) << "after BMP char";
266  EXPECT_THAT(offsetToPosition(File, 16), Pos(1, 6)) << "end of second line";
267  EXPECT_THAT(offsetToPosition(File, 17), Pos(1, 7)) << "second newline";
268  EXPECT_THAT(offsetToPosition(File, 18), Pos(2, 0)) << "start of last line";
269  EXPECT_THAT(offsetToPosition(File, 21), Pos(2, 3)) << "in last line";
270  EXPECT_THAT(offsetToPosition(File, 22), Pos(2, 4)) << "before astral char";
271  EXPECT_THAT(offsetToPosition(File, 24), Pos(2, 5)) << "in astral char";
272  EXPECT_THAT(offsetToPosition(File, 26), Pos(2, 5)) << "after astral char";
273  EXPECT_THAT(offsetToPosition(File, 28), Pos(2, 7)) << "end of last line";
274  EXPECT_THAT(offsetToPosition(File, 29), Pos(2, 8)) << "EOF";
275  EXPECT_THAT(offsetToPosition(File, 30), Pos(2, 8)) << "out of bounds";
276 
278  for (Line L : FileLines) {
279  for (unsigned I = 0; I <= L.Length; ++I)
280  EXPECT_THAT(offsetToPosition(File, L.Offset + I), Pos(L.Number, I));
281  }
282  EXPECT_THAT(offsetToPosition(File, 30), Pos(2, 11)) << "out of bounds";
283 }
284 
285 TEST(SourceCodeTests, SourceLocationInMainFile) {
286  Annotations Source(R"cpp(
287  ^in^t ^foo
288  ^bar
289  ^baz ^() {} {} {} {} { }^
290 )cpp");
291 
292  SourceManagerForFile Owner("foo.cpp", Source.code());
293  SourceManager &SM = Owner.get();
294 
295  SourceLocation StartOfFile = SM.getLocForStartOfFile(SM.getMainFileID());
296  EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 0)),
297  HasValue(StartOfFile));
298  // End of file.
299  EXPECT_THAT_EXPECTED(
300  sourceLocationInMainFile(SM, position(4, 0)),
301  HasValue(StartOfFile.getLocWithOffset(Source.code().size())));
302  // Column number is too large.
303  EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 1)), Failed());
304  EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 100)),
305  Failed());
306  EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(4, 1)), Failed());
307  // Line number is too large.
308  EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(5, 0)), Failed());
309  // Check all positions mentioned in the test return valid results.
310  for (auto P : Source.points()) {
311  size_t Offset = llvm::cantFail(positionToOffset(Source.code(), P));
312  EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, P),
313  HasValue(StartOfFile.getLocWithOffset(Offset)));
314  }
315 }
316 
317 TEST(SourceCodeTests, isReservedName) {
318  EXPECT_FALSE(isReservedName(""));
319  EXPECT_FALSE(isReservedName("_"));
320  EXPECT_FALSE(isReservedName("foo"));
321  EXPECT_FALSE(isReservedName("_foo"));
322  EXPECT_TRUE(isReservedName("__foo"));
323  EXPECT_TRUE(isReservedName("_Foo"));
324  EXPECT_FALSE(isReservedName("foo__bar")) << "FIXME";
325 }
326 
327 TEST(SourceCodeTests, CollectIdentifiers) {
328  auto Style = format::getLLVMStyle();
329  auto IDs = collectIdentifiers(R"cpp(
330  #include "a.h"
331  void foo() { int xyz; int abc = xyz; return foo(); }
332  )cpp",
333  Style);
334  EXPECT_EQ(IDs.size(), 7u);
335  EXPECT_EQ(IDs["include"], 1u);
336  EXPECT_EQ(IDs["void"], 1u);
337  EXPECT_EQ(IDs["int"], 2u);
338  EXPECT_EQ(IDs["xyz"], 2u);
339  EXPECT_EQ(IDs["abc"], 1u);
340  EXPECT_EQ(IDs["return"], 1u);
341  EXPECT_EQ(IDs["foo"], 2u);
342 }
343 
344 TEST(SourceCodeTests, CollectWords) {
345  auto Words = collectWords(R"cpp(
346  #define FIZZ_BUZZ
347  // this is a comment
348  std::string getSomeText() { return "magic word"; }
349  )cpp");
350  std::set<StringRef> ActualWords(Words.keys().begin(), Words.keys().end());
351  std::set<StringRef> ExpectedWords = {"define", "fizz", "buzz", "this",
352  "comment", "string", "some", "text",
353  "return", "magic", "word"};
354  EXPECT_EQ(ActualWords, ExpectedWords);
355 }
356 
357 class SpelledWordsTest : public ::testing::Test {
358  llvm::Optional<ParsedAST> AST;
359 
360  llvm::Optional<SpelledWord> tryWord(const char *Text) {
361  llvm::Annotations A(Text);
362  auto TU = TestTU::withCode(A.code());
363  AST = TU.build();
364  auto SW = SpelledWord::touching(
365  AST->getSourceManager().getComposedLoc(
366  AST->getSourceManager().getMainFileID(), A.point()),
367  AST->getTokens(), AST->getLangOpts());
368  if (A.ranges().size()) {
369  llvm::StringRef Want = A.code().slice(A.range().Begin, A.range().End);
370  EXPECT_EQ(Want, SW->Text) << Text;
371  }
372  return SW;
373  }
374 
375 protected:
376  SpelledWord word(const char *Text) {
377  auto Result = tryWord(Text);
378  EXPECT_TRUE(Result) << Text;
379  return Result.value_or(SpelledWord());
380  }
381 
382  void noWord(const char *Text) { EXPECT_FALSE(tryWord(Text)) << Text; }
383 };
384 
385 TEST_F(SpelledWordsTest, HeuristicBoundaries) {
386  word("// [[^foo]] ");
387  word("// [[f^oo]] ");
388  word("// [[foo^]] ");
389  word("// [[foo^]]+bar ");
390  noWord("//^ foo ");
391  noWord("// foo ^");
392 }
393 
394 TEST_F(SpelledWordsTest, LikelyIdentifier) {
395  EXPECT_FALSE(word("// ^foo ").LikelyIdentifier);
396  EXPECT_TRUE(word("// [[^foo_bar]] ").LikelyIdentifier);
397  EXPECT_TRUE(word("// [[^fooBar]] ").LikelyIdentifier);
398  EXPECT_FALSE(word("// H^TTP ").LikelyIdentifier);
399  EXPECT_TRUE(word("// \\p [[^foo]] ").LikelyIdentifier);
400  EXPECT_TRUE(word("// @param[in] [[^foo]] ").LikelyIdentifier);
401  EXPECT_TRUE(word("// `[[f^oo]]` ").LikelyIdentifier);
402  EXPECT_TRUE(word("// bar::[[f^oo]] ").LikelyIdentifier);
403  EXPECT_TRUE(word("// [[f^oo]]::bar ").LikelyIdentifier);
404 }
405 
406 TEST_F(SpelledWordsTest, Comment) {
407  auto W = word("// [[^foo]]");
408  EXPECT_FALSE(W.PartOfSpelledToken);
409  EXPECT_FALSE(W.SpelledToken);
410  EXPECT_FALSE(W.ExpandedToken);
411 }
412 
413 TEST_F(SpelledWordsTest, PartOfString) {
414  auto W = word(R"( auto str = "foo [[^bar]] baz"; )");
415  ASSERT_TRUE(W.PartOfSpelledToken);
416  EXPECT_EQ(W.PartOfSpelledToken->kind(), tok::string_literal);
417  EXPECT_FALSE(W.SpelledToken);
418  EXPECT_FALSE(W.ExpandedToken);
419 }
420 
421 TEST_F(SpelledWordsTest, DisabledSection) {
422  auto W = word(R"cpp(
423  #if 0
424  foo [[^bar]] baz
425  #endif
426  )cpp");
427  ASSERT_TRUE(W.SpelledToken);
428  EXPECT_EQ(W.SpelledToken->kind(), tok::identifier);
429  EXPECT_EQ(W.SpelledToken, W.PartOfSpelledToken);
430  EXPECT_FALSE(W.ExpandedToken);
431 }
432 
433 TEST_F(SpelledWordsTest, Macros) {
434  auto W = word(R"cpp(
435  #define ID(X) X
436  ID(int [[^i]]);
437  )cpp");
438  ASSERT_TRUE(W.SpelledToken);
439  EXPECT_EQ(W.SpelledToken->kind(), tok::identifier);
440  EXPECT_EQ(W.SpelledToken, W.PartOfSpelledToken);
441  ASSERT_TRUE(W.ExpandedToken);
442  EXPECT_EQ(W.ExpandedToken->kind(), tok::identifier);
443 
444  W = word(R"cpp(
445  #define OBJECT Expansion;
446  int [[^OBJECT]];
447  )cpp");
448  EXPECT_TRUE(W.SpelledToken);
449  EXPECT_FALSE(W.ExpandedToken) << "Expanded token is spelled differently";
450 }
451 
452 TEST(SourceCodeTests, VisibleNamespaces) {
453  std::vector<std::pair<const char *, std::vector<std::string>>> Cases = {
454  {
455  R"cpp(
456  // Using directive resolved against enclosing namespaces.
457  using namespace foo;
458  namespace ns {
459  using namespace bar;
460  )cpp",
461  {"ns", "", "bar", "foo", "ns::bar"},
462  },
463  {
464  R"cpp(
465  // Don't include namespaces we've closed, ignore namespace aliases.
466  using namespace clang;
467  using std::swap;
468  namespace clang {
469  namespace clangd {}
470  namespace ll = ::llvm;
471  }
472  namespace clang {
473  )cpp",
474  {"clang", ""},
475  },
476  {
477  R"cpp(
478  // Using directives visible even if a namespace is reopened.
479  // Ignore anonymous namespaces.
480  namespace foo{ using namespace bar; }
481  namespace foo{ namespace {
482  )cpp",
483  {"foo", "", "bar", "foo::bar"},
484  },
485  {
486  R"cpp(
487  // Mismatched braces
488  namespace foo{}
489  }}}
490  namespace bar{
491  )cpp",
492  {"bar", ""},
493  },
494  {
495  R"cpp(
496  // Namespaces with multiple chunks.
497  namespace a::b {
498  using namespace c::d;
499  namespace e::f {
500  )cpp",
501  {
502  "a::b::e::f",
503  "",
504  "a",
505  "a::b",
506  "a::b::c::d",
507  "a::b::e",
508  "a::c::d",
509  "c::d",
510  },
511  },
512  {
513  "",
514  {""},
515  },
516  {
517  R"cpp(
518  // Parse until EOF
519  namespace bar{})cpp",
520  {""},
521  },
522  };
523  for (const auto &Case : Cases) {
524  EXPECT_EQ(Case.second,
525  visibleNamespaces(Case.first, format::getFormattingLangOpts(
526  format::getLLVMStyle())))
527  << Case.first;
528  }
529 }
530 
531 TEST(SourceCodeTests, GetMacros) {
532  Annotations Code(R"cpp(
533  #define MACRO 123
534  int abc = MA^CRO;
535  )cpp");
536  TestTU TU = TestTU::withCode(Code.code());
537  auto AST = TU.build();
538  auto CurLoc = sourceLocationInMainFile(AST.getSourceManager(), Code.point());
539  ASSERT_TRUE(bool(CurLoc));
540  const auto *Id = syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
541  ASSERT_TRUE(Id);
542  auto Result = locateMacroAt(*Id, AST.getPreprocessor());
543  ASSERT_TRUE(Result);
544  EXPECT_THAT(*Result, macroName("MACRO"));
545 }
546 
547 TEST(SourceCodeTests, WorksAtBeginOfFile) {
548  Annotations Code("^MACRO");
549  TestTU TU = TestTU::withCode(Code.code());
550  TU.HeaderCode = "#define MACRO int x;";
551  auto AST = TU.build();
552  auto CurLoc = sourceLocationInMainFile(AST.getSourceManager(), Code.point());
553  ASSERT_TRUE(bool(CurLoc));
554  const auto *Id = syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
555  ASSERT_TRUE(Id);
556  auto Result = locateMacroAt(*Id, AST.getPreprocessor());
557  ASSERT_TRUE(Result);
558  EXPECT_THAT(*Result, macroName("MACRO"));
559 }
560 
561 TEST(SourceCodeTests, IsInsideMainFile) {
562  TestTU TU;
563  TU.HeaderCode = R"cpp(
564  #define DEFINE_CLASS(X) class X {};
565  #define DEFINE_YY DEFINE_CLASS(YY)
566 
567  class Header1 {};
568  DEFINE_CLASS(Header2)
569  class Header {};
570  )cpp";
571  TU.Code = R"cpp(
572  #define DEFINE_MAIN4 class Main4{};
573  class Main1 {};
574  DEFINE_CLASS(Main2)
575  DEFINE_YY
576  class Main {};
577  DEFINE_MAIN4
578  )cpp";
579  TU.ExtraArgs.push_back("-DHeader=Header3");
580  TU.ExtraArgs.push_back("-DMain=Main3");
581  auto AST = TU.build();
582  const auto &SM = AST.getSourceManager();
583  auto DeclLoc = [&AST](llvm::StringRef Name) {
584  return findDecl(AST, Name).getLocation();
585  };
586  for (const auto *HeaderDecl : {"Header1", "Header2", "Header3"})
587  EXPECT_FALSE(isInsideMainFile(DeclLoc(HeaderDecl), SM)) << HeaderDecl;
588 
589  for (const auto *MainDecl : {"Main1", "Main2", "Main3", "Main4", "YY"})
590  EXPECT_TRUE(isInsideMainFile(DeclLoc(MainDecl), SM)) << MainDecl;
591 
592  // Main4 is *spelled* in the preamble, but in the main-file part of it.
593  EXPECT_TRUE(isInsideMainFile(SM.getSpellingLoc(DeclLoc("Main4")), SM));
594 }
595 
596 // Test for functions toHalfOpenFileRange and getHalfOpenFileRange
597 TEST(SourceCodeTests, HalfOpenFileRange) {
598  // Each marked range should be the file range of the decl with the same name
599  // and each name should be unique.
600  Annotations Test(R"cpp(
601  #define FOO(X, Y) int Y = ++X
602  #define BAR(X) X + 1
603  #define ECHO(X) X
604 
605  #define BUZZ BAZZ(ADD)
606  #define BAZZ(m) m(1)
607  #define ADD(a) int f = a + 1;
608  template<typename T>
609  class P {};
610 
611  int main() {
612  $a[[P<P<P<P<P<int>>>>> a]];
613  $b[[int b = 1]];
614  $c[[FOO(b, c)]];
615  $d[[FOO(BAR(BAR(b)), d)]];
616  // FIXME: We might want to select everything inside the outer ECHO.
617  ECHO(ECHO($e[[int) ECHO(e]]));
618  // Shouldn't crash.
619  $f[[BUZZ]];
620  }
621  )cpp");
622 
623  ParsedAST AST = TestTU::withCode(Test.code()).build();
624  llvm::errs() << Test.code();
625  const SourceManager &SM = AST.getSourceManager();
626  const LangOptions &LangOpts = AST.getLangOpts();
627  // Turn a SourceLocation into a pair of positions
628  auto SourceRangeToRange = [&SM](SourceRange SrcRange) {
629  return Range{sourceLocToPosition(SM, SrcRange.getBegin()),
630  sourceLocToPosition(SM, SrcRange.getEnd())};
631  };
632  auto CheckRange = [&](llvm::StringRef Name) {
633  const NamedDecl &Decl = findUnqualifiedDecl(AST, Name);
634  auto FileRange = toHalfOpenFileRange(SM, LangOpts, Decl.getSourceRange());
635  SCOPED_TRACE("Checking range: " + Name);
636  ASSERT_NE(FileRange, llvm::None);
637  Range HalfOpenRange = SourceRangeToRange(*FileRange);
638  EXPECT_EQ(HalfOpenRange, Test.ranges(Name)[0]);
639  };
640 
641  CheckRange("a");
642  CheckRange("b");
643  CheckRange("c");
644  CheckRange("d");
645  CheckRange("e");
646  CheckRange("f");
647 }
648 
649 TEST(SourceCodeTests, HalfOpenFileRangePathologicalPreprocessor) {
650  const char *Case = R"cpp(
651 #define MACRO while(1)
652  void test() {
653 [[#include "Expand.inc"
654  br^eak]];
655  }
656  )cpp";
657  Annotations Test(Case);
658  auto TU = TestTU::withCode(Test.code());
659  TU.AdditionalFiles["Expand.inc"] = "MACRO\n";
660  auto AST = TU.build();
661 
662  const auto &Func = cast<FunctionDecl>(findDecl(AST, "test"));
663  const auto &Body = cast<CompoundStmt>(Func.getBody());
664  const auto &Loop = cast<WhileStmt>(*Body->child_begin());
665  llvm::Optional<SourceRange> Range = toHalfOpenFileRange(
666  AST.getSourceManager(), AST.getLangOpts(), Loop->getSourceRange());
667  ASSERT_TRUE(Range) << "Failed to get file range";
668  EXPECT_EQ(AST.getSourceManager().getFileOffset(Range->getBegin()),
669  Test.llvm::Annotations::range().Begin);
670  EXPECT_EQ(AST.getSourceManager().getFileOffset(Range->getEnd()),
671  Test.llvm::Annotations::range().End);
672 }
673 
674 TEST(SourceCodeTests, IncludeHashLoc) {
675  const char *Case = R"cpp(
676 $foo^#include "foo.inc"
677 #define HEADER "bar.inc"
678  $bar^# include HEADER
679  )cpp";
680  Annotations Test(Case);
681  auto TU = TestTU::withCode(Test.code());
682  TU.AdditionalFiles["foo.inc"] = "int foo;\n";
683  TU.AdditionalFiles["bar.inc"] = "int bar;\n";
684  auto AST = TU.build();
685  const auto &SM = AST.getSourceManager();
686 
687  FileID Foo = SM.getFileID(findDecl(AST, "foo").getLocation());
688  EXPECT_EQ(SM.getFileOffset(includeHashLoc(Foo, SM)),
689  Test.llvm::Annotations::point("foo"));
690  FileID Bar = SM.getFileID(findDecl(AST, "bar").getLocation());
691  EXPECT_EQ(SM.getFileOffset(includeHashLoc(Bar, SM)),
692  Test.llvm::Annotations::point("bar"));
693 }
694 
695 TEST(SourceCodeTests, GetEligiblePoints) {
696  constexpr struct {
697  const char *Code;
698  const char *FullyQualifiedName;
699  const char *EnclosingNamespace;
700  } Cases[] = {
701  {R"cpp(// FIXME: We should also mark positions before and after
702  //declarations/definitions as eligible.
703  namespace ns1 {
704  namespace a { namespace ns2 {} }
705  namespace ns2 {^
706  void foo();
707  namespace {}
708  void bar() {}
709  namespace ns3 {}
710  class T {};
711  ^}
712  using namespace ns2;
713  })cpp",
714  "ns1::ns2::symbol", "ns1::ns2::"},
715  {R"cpp(
716  namespace ns1 {^
717  namespace a { namespace ns2 {} }
718  namespace b {}
719  namespace ns {}
720  ^})cpp",
721  "ns1::ns2::symbol", "ns1::"},
722  {R"cpp(
723  namespace x {
724  namespace a { namespace ns2 {} }
725  namespace b {}
726  namespace ns {}
727  }^)cpp",
728  "ns1::ns2::symbol", ""},
729  {R"cpp(
730  namespace ns1 {
731  namespace ns2 {^^}
732  namespace b {}
733  namespace ns2 {^^}
734  }
735  namespace ns1 {namespace ns2 {^^}})cpp",
736  "ns1::ns2::symbol", "ns1::ns2::"},
737  {R"cpp(
738  namespace ns1 {^
739  namespace ns {}
740  namespace b {}
741  namespace ns {}
742  ^}
743  namespace ns1 {^namespace ns {}^})cpp",
744  "ns1::ns2::symbol", "ns1::"},
745  };
746  for (auto Case : Cases) {
747  Annotations Test(Case.Code);
748 
749  auto Res = getEligiblePoints(
750  Test.code(), Case.FullyQualifiedName,
751  format::getFormattingLangOpts(format::getLLVMStyle()));
752  EXPECT_THAT(Res.EligiblePoints, testing::ElementsAreArray(Test.points()))
753  << Test.code();
754  EXPECT_EQ(Res.EnclosingNamespace, Case.EnclosingNamespace) << Test.code();
755  }
756 }
757 
758 TEST(SourceCodeTests, IdentifierRanges) {
759  Annotations Code(R"cpp(
760  class [[Foo]] {};
761  // Foo
762  /* Foo */
763  void f([[Foo]]* foo1) {
764  [[Foo]] foo2;
765  auto S = [[Foo]]();
766 // cross-line identifier is not supported.
767 F\
768 o\
769 o foo2;
770  }
771  )cpp");
772  LangOptions LangOpts;
773  LangOpts.CPlusPlus = true;
774  EXPECT_EQ(Code.ranges(),
775  collectIdentifierRanges("Foo", Code.code(), LangOpts));
776 }
777 
778 TEST(SourceCodeTests, isHeaderFile) {
779  // Without lang options.
780  EXPECT_TRUE(isHeaderFile("foo.h"));
781  EXPECT_TRUE(isHeaderFile("foo.hh"));
782  EXPECT_TRUE(isHeaderFile("foo.hpp"));
783 
784  EXPECT_FALSE(isHeaderFile("foo.cpp"));
785  EXPECT_FALSE(isHeaderFile("foo.c++"));
786  EXPECT_FALSE(isHeaderFile("foo.cxx"));
787  EXPECT_FALSE(isHeaderFile("foo.cc"));
788  EXPECT_FALSE(isHeaderFile("foo.c"));
789  EXPECT_FALSE(isHeaderFile("foo.mm"));
790  EXPECT_FALSE(isHeaderFile("foo.m"));
791 
792  // With lang options
793  LangOptions LangOpts;
794  LangOpts.IsHeaderFile = true;
795  EXPECT_TRUE(isHeaderFile("string", LangOpts));
796  // Emulate cases where there is no "-x header" flag for a .h file, we still
797  // want to treat it as a header.
798  LangOpts.IsHeaderFile = false;
799  EXPECT_TRUE(isHeaderFile("header.h", LangOpts));
800 }
801 
802 TEST(SourceCodeTests, isKeywords) {
803  LangOptions LangOpts;
804  LangOpts.CPlusPlus20 = true;
805  EXPECT_TRUE(isKeyword("int", LangOpts));
806  EXPECT_TRUE(isKeyword("return", LangOpts));
807  EXPECT_TRUE(isKeyword("co_await", LangOpts));
808 
809  // these are identifiers (not keywords!) with special meaning in some
810  // contexts.
811  EXPECT_FALSE(isKeyword("final", LangOpts));
812  EXPECT_FALSE(isKeyword("override", LangOpts));
813 }
814 
815 struct IncrementalTestStep {
816  llvm::StringRef Src;
817  llvm::StringRef Contents;
818 };
819 
820 int rangeLength(llvm::StringRef Code, const Range &Rng) {
821  llvm::Expected<size_t> Start = positionToOffset(Code, Rng.start);
822  llvm::Expected<size_t> End = positionToOffset(Code, Rng.end);
823  assert(Start);
824  assert(End);
825  return *End - *Start;
826 }
827 
828 /// Send the changes one by one to updateDraft, verify the intermediate results.
829 void stepByStep(llvm::ArrayRef<IncrementalTestStep> Steps) {
830  std::string Code = Annotations(Steps.front().Src).code().str();
831 
832  for (size_t I = 1; I < Steps.size(); I++) {
833  Annotations SrcBefore(Steps[I - 1].Src);
834  Annotations SrcAfter(Steps[I].Src);
835  llvm::StringRef Contents = Steps[I - 1].Contents;
836  TextDocumentContentChangeEvent Event{
837  SrcBefore.range(),
838  rangeLength(SrcBefore.code(), SrcBefore.range()),
839  Contents.str(),
840  };
841 
842  EXPECT_THAT_ERROR(applyChange(Code, Event), llvm::Succeeded());
843  EXPECT_EQ(Code, SrcAfter.code());
844  }
845 }
846 
847 TEST(ApplyEditsTest, Simple) {
848  // clang-format off
849  IncrementalTestStep Steps[] =
850  {
851  // Replace a range
852  {
853 R"cpp(static int
854 hello[[World]]()
855 {})cpp",
856  "Universe"
857  },
858  // Delete a range
859  {
860 R"cpp(static int
861 hello[[Universe]]()
862 {})cpp",
863  ""
864  },
865  // Add a range
866  {
867 R"cpp(static int
868 hello[[]]()
869 {})cpp",
870  "Monde"
871  },
872  {
873 R"cpp(static int
874 helloMonde()
875 {})cpp",
876  ""
877  }
878  };
879  // clang-format on
880 
881  stepByStep(Steps);
882 }
883 
884 TEST(ApplyEditsTest, MultiLine) {
885  // clang-format off
886  IncrementalTestStep Steps[] =
887  {
888  // Replace a range
889  {
890 R"cpp(static [[int
891 helloWorld]]()
892 {})cpp", R"cpp(char
893 welcome)cpp"
894  },
895  // Delete a range
896  {
897 R"cpp(static char[[
898 welcome]]()
899 {})cpp",
900  ""
901  },
902  // Add a range
903  {
904 R"cpp(static char[[]]()
905 {})cpp",
906  R"cpp(
907 cookies)cpp"
908  },
909  // Replace the whole file
910  {
911 R"cpp([[static char
912 cookies()
913 {}]])cpp",
914  R"cpp(#include <stdio.h>
915 )cpp"
916  },
917  // Delete the whole file
918  {
919  R"cpp([[#include <stdio.h>
920 ]])cpp",
921  "",
922  },
923  // Add something to an empty file
924  {
925  "[[]]",
926  R"cpp(int main() {
927 )cpp",
928  },
929  {
930  R"cpp(int main() {
931 )cpp",
932  ""
933  }
934  };
935  // clang-format on
936 
937  stepByStep(Steps);
938 }
939 
940 TEST(ApplyEditsTest, WrongRangeLength) {
941  std::string Code = "int main() {}\n";
942 
943  TextDocumentContentChangeEvent Change;
944  Change.range.emplace();
945  Change.range->start.line = 0;
946  Change.range->start.character = 0;
947  Change.range->end.line = 0;
948  Change.range->end.character = 2;
949  Change.rangeLength = 10;
950 
951  EXPECT_THAT_ERROR(applyChange(Code, Change),
952  FailedWithMessage("Change's rangeLength (10) doesn't match "
953  "the computed range length (2)."));
954 }
955 
956 TEST(ApplyEditsTest, EndBeforeStart) {
957  std::string Code = "int main() {}\n";
958 
959  TextDocumentContentChangeEvent Change;
960  Change.range.emplace();
961  Change.range->start.line = 0;
962  Change.range->start.character = 5;
963  Change.range->end.line = 0;
964  Change.range->end.character = 3;
965 
966  EXPECT_THAT_ERROR(
967  applyChange(Code, Change),
968  FailedWithMessage(
969  "Range's end position (0:3) is before start position (0:5)"));
970 }
971 
972 TEST(ApplyEditsTest, StartCharOutOfRange) {
973  std::string Code = "int main() {}\n";
974 
975  TextDocumentContentChangeEvent Change;
976  Change.range.emplace();
977  Change.range->start.line = 0;
978  Change.range->start.character = 100;
979  Change.range->end.line = 0;
980  Change.range->end.character = 100;
981  Change.text = "foo";
982 
983  EXPECT_THAT_ERROR(
984  applyChange(Code, Change),
985  FailedWithMessage("utf-16 offset 100 is invalid for line 0"));
986 }
987 
988 TEST(ApplyEditsTest, EndCharOutOfRange) {
989  std::string Code = "int main() {}\n";
990 
991  TextDocumentContentChangeEvent Change;
992  Change.range.emplace();
993  Change.range->start.line = 0;
994  Change.range->start.character = 0;
995  Change.range->end.line = 0;
996  Change.range->end.character = 100;
997  Change.text = "foo";
998 
999  EXPECT_THAT_ERROR(
1000  applyChange(Code, Change),
1001  FailedWithMessage("utf-16 offset 100 is invalid for line 0"));
1002 }
1003 
1004 TEST(ApplyEditsTest, StartLineOutOfRange) {
1005  std::string Code = "int main() {}\n";
1006 
1007  TextDocumentContentChangeEvent Change;
1008  Change.range.emplace();
1009  Change.range->start.line = 100;
1010  Change.range->start.character = 0;
1011  Change.range->end.line = 100;
1012  Change.range->end.character = 0;
1013  Change.text = "foo";
1014 
1015  EXPECT_THAT_ERROR(applyChange(Code, Change),
1016  FailedWithMessage("Line value is out of range (100)"));
1017 }
1018 
1019 TEST(ApplyEditsTest, EndLineOutOfRange) {
1020  std::string Code = "int main() {}\n";
1021 
1022  TextDocumentContentChangeEvent Change;
1023  Change.range.emplace();
1024  Change.range->start.line = 0;
1025  Change.range->start.character = 0;
1026  Change.range->end.line = 100;
1027  Change.range->end.character = 0;
1028  Change.text = "foo";
1029 
1030  EXPECT_THAT_ERROR(applyChange(Code, Change),
1031  FailedWithMessage("Line value is out of range (100)"));
1032 }
1033 
1034 } // namespace
1035 } // namespace clangd
1036 } // namespace clang
1037 
Range
CharSourceRange Range
SourceRange for the file name.
Definition: IncludeOrderCheck.cpp:38
clang::clangd::findDecl
const NamedDecl & findDecl(ParsedAST &AST, llvm::StringRef QName)
Definition: TestTU.cpp:216
clang::clangd::isKeyword
bool isKeyword(llvm::StringRef NewName, const LangOptions &LangOpts)
Return true if the TokenName is in the list of reversed keywords of the language.
Definition: SourceCode.cpp:639
clang::clangd::TEST
TEST(BackgroundQueueTest, Priority)
Definition: BackgroundIndexTests.cpp:750
clang::clangd::collectIdentifiers
llvm::StringMap< unsigned > collectIdentifiers(llvm::StringRef Content, const format::FormatStyle &Style)
Collects identifiers with counts in the source code.
Definition: SourceCode.cpp:612
clang::clangd::MATCHER_P2
MATCHER_P2(hasFlag, Flag, Path, "")
Definition: GlobalCompilationDatabaseTests.cpp:446
clang::clangd::locateMacroAt
llvm::Optional< DefinedMacro > locateMacroAt(const syntax::Token &SpelledTok, Preprocessor &PP)
Gets the macro referenced by SpelledTok.
Definition: SourceCode.cpp:973
clang::clangd::toHalfOpenFileRange
llvm::Optional< SourceRange > toHalfOpenFileRange(const SourceManager &SM, const LangOptions &LangOpts, SourceRange R)
Turns a token range into a half-open range and checks its correctness.
Definition: SourceCode.cpp:421
Macros
llvm::DenseSet< FileID > Macros
Definition: IncludeCleaner.cpp:195
clang::clangd::MATCHER_P
MATCHER_P(named, N, "")
Definition: BackgroundIndexTests.cpp:30
clang::clangd::TestTU::build
ParsedAST build() const
Definition: TestTU.cpp:109
clang::clangd::visibleNamespaces
std::vector< std::string > visibleNamespaces(llvm::StringRef Code, const LangOptions &LangOpts)
Heuristically determine namespaces visible at a point, without parsing Code.
Definition: SourceCode.cpp:797
clang::clangd::lspLength
size_t lspLength(llvm::StringRef Code)
Definition: SourceCode.cpp:148
clang::clangd::collectWords
llvm::StringSet collectWords(llvm::StringRef Content)
Collects words from the source code.
Definition: SourceCode.cpp:845
clang::clangd::OffsetEncoding::UTF32
@ UTF32
TestTU.h
Text
std::string Text
Definition: HTMLGenerator.cpp:80
clang::clangd::TEST_F
TEST_F(BackgroundIndexTest, NoCrashOnErrorFile)
Definition: BackgroundIndexTests.cpp:94
clang::clangd::sourceLocToPosition
Position sourceLocToPosition(const SourceManager &SM, SourceLocation Loc)
Turn a SourceLocation into a [line, column] pair.
Definition: SourceCode.cpp:213
Length
unsigned Length
Definition: SourceCodeTests.cpp:96
clang::clangd::remote::Character
char Character
Definition: Header.h:5
clang::clangd::ParsedAST::getLangOpts
const LangOptions & getLangOpts() const
Definition: ParsedAST.h:80
clang::clangd::findUnqualifiedDecl
const NamedDecl & findUnqualifiedDecl(ParsedAST &AST, llvm::StringRef Name)
Definition: TestTU.cpp:257
Pos
size_t Pos
Definition: NoLintDirectiveHandler.cpp:97
clang::clangd::OffsetEncoding::UTF8
@ UTF8
Offset
unsigned Offset
Definition: SourceCodeTests.cpp:95
Protocol.h
clang::clangd::ParsedAST::build
static llvm::Optional< ParsedAST > build(llvm::StringRef Filename, const ParseInputs &Inputs, std::unique_ptr< clang::CompilerInvocation > CI, llvm::ArrayRef< Diag > CompilerInvocationDiags, std::shared_ptr< const PreambleData > Preamble)
Attempts to run Clang and store the parsed AST.
Definition: ParsedAST.cpp:342
ns1::ns2::A
@ A
Definition: CategoricalFeature.h:3
clang::clangd::isReservedName
bool isReservedName(llvm::StringRef Name)
Returns true if Name is reserved, like _Foo or __Vector_base.
Definition: SourceCode.h:334
Code
std::string Code
Definition: FindTargetTests.cpp:67
Foo
Definition: sample.h:4
Number
unsigned Number
Definition: SourceCodeTests.cpp:94
Decl
const FunctionDecl * Decl
Definition: AvoidBindCheck.cpp:100
Line
int Line
Definition: PreprocessorTracker.cpp:514
clang::clangd::OffsetEncoding::UTF16
@ UTF16
clang::clangd::positionToOffset
llvm::Expected< size_t > positionToOffset(llvm::StringRef Code, Position P, bool AllowColumnsBeyondLineLength)
Turn a [line, column] pair into an offset in Code.
Definition: SourceCode.cpp:172
clang::clangd::SpelledWord::touching
static llvm::Optional< SpelledWord > touching(SourceLocation SpelledLoc, const syntax::TokenBuffer &TB, const LangOptions &LangOpts)
Definition: SourceCode.cpp:923
clang::clangd::collectIdentifierRanges
std::vector< Range > collectIdentifierRanges(llvm::StringRef Identifier, llvm::StringRef Content, const LangOptions &LangOpts)
Collects all ranges of the given identifier in the source code.
Definition: SourceCode.cpp:626
clang::clangd::getEligiblePoints
EligibleRegion getEligiblePoints(llvm::StringRef Code, llvm::StringRef FullyQualifiedName, const LangOptions &LangOpts)
Returns most eligible region to insert a definition for FullyQualifiedName in the Code.
Definition: SourceCode.cpp:1105
Name
Token Name
Definition: MacroToEnumCheck.cpp:89
clang::clangd::offsetToPosition
Position offsetToPosition(llvm::StringRef Code, size_t Offset)
Turn an offset in Code into a [line, column] pair.
Definition: SourceCode.cpp:201
EnclosingNamespace
std::string EnclosingNamespace
Definition: DefineOutline.cpp:286
clang::clangd::TestTU::withCode
static TestTU withCode(llvm::StringRef Code)
Definition: TestTU.h:36
Annotations.h
Bar
Definition: sample.cpp:5
clang::clangd::ParsedAST::getPreprocessor
Preprocessor & getPreprocessor()
Definition: ParsedAST.cpp:705
SourceCode.h
clang::clangd::isHeaderFile
bool isHeaderFile(llvm::StringRef FileName, llvm::Optional< LangOptions > LangOpts)
Infers whether this is a header from the FileName and LangOpts (if presents).
Definition: SourceCode.cpp:1158
clang::clangd::applyChange
llvm::Error applyChange(std::string &Contents, const TextDocumentContentChangeEvent &Change)
Apply an incremental update to a text document.
Definition: SourceCode.cpp:1062
clang::clangd::kCurrentOffsetEncoding
Key< OffsetEncoding > kCurrentOffsetEncoding
Definition: SourceCode.cpp:141
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
clang::clangd::ParsedAST::getTokens
const syntax::TokenBuffer & getTokens() const
Tokens recorded while parsing the main file.
Definition: ParsedAST.h:106
clang::clangd::isInsideMainFile
bool isInsideMainFile(SourceLocation Loc, const SourceManager &SM)
Returns true iff Loc is inside the main file.
Definition: SourceCode.cpp:414
clang::clangd::OffsetEncoding
OffsetEncoding
Definition: Protocol.h:376
LangOpts
const LangOptions * LangOpts
Definition: ExtractFunction.cpp:366
clang::clangd::CompletionItemKind::Event
@ Event
clang::clangd::includeHashLoc
SourceLocation includeHashLoc(FileID IncludedFile, const SourceManager &SM)
Returns the #include location through which IncludedFIle was loaded.
Definition: SourceCode.cpp:255
clang::clangd::ParsedAST::getSourceManager
SourceManager & getSourceManager()
Definition: ParsedAST.h:73
clang::clangd::HasValue
OptionalMatcher< InnerMatcher > HasValue(const InnerMatcher &inner_matcher)
Definition: clangd/unittests/Matchers.h:194
clang::clangd::sourceLocationInMainFile
llvm::Expected< SourceLocation > sourceLocationInMainFile(const SourceManager &SM, Position P)
Return the file location, corresponding to P.
Definition: SourceCode.cpp:453
Context.h