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 "Context.h"
10 #include "Protocol.h"
11 #include "SourceCode.h"
12 #include "TestTU.h"
13 #include "clang/Format/Format.h"
14 #include "llvm/Support/Error.h"
15 #include "llvm/Support/raw_os_ostream.h"
16 #include "llvm/Testing/Support/Error.h"
17 #include "gmock/gmock.h"
18 #include "gtest/gtest.h"
19 
20 namespace clang {
21 namespace clangd {
22 namespace {
23 
24 using llvm::Failed;
25 using llvm::HasValue;
26 using ::testing::UnorderedElementsAreArray;
27 
28 MATCHER_P2(Pos, Line, Col, "") {
29   return arg.line == int(Line) && arg.character == int(Col);
30 }
31 
32 MATCHER_P(MacroName, Name, "") { return arg.Name == Name; }
33 
34 /// A helper to make tests easier to read.
35 Position position(int line, int character) {
36   Position Pos;
37   Pos.line = line;
38   Pos.character = character;
39   return Pos;
40 }
41 
42 Range range(const std::pair<int, int> p1, const std::pair<int, int> p2) {
43   Range range;
44   range.start = position(p1.first, p1.second);
45   range.end = position(p2.first, p2.second);
46   return range;
47 }
48 
49 TEST(SourceCodeTests, lspLength) {
50   EXPECT_EQ(lspLength(""), 0UL);
51   EXPECT_EQ(lspLength("ascii"), 5UL);
52   // BMP
53   EXPECT_EQ(lspLength("↓"), 1UL);
54   EXPECT_EQ(lspLength("¥"), 1UL);
55   // astral
56   EXPECT_EQ(lspLength("��"), 2UL);
57 
58   WithContextValue UTF8(kCurrentOffsetEncoding, OffsetEncoding::UTF8);
59   EXPECT_EQ(lspLength(""), 0UL);
60   EXPECT_EQ(lspLength("ascii"), 5UL);
61   // BMP
62   EXPECT_EQ(lspLength("↓"), 3UL);
63   EXPECT_EQ(lspLength("¥"), 2UL);
64   // astral
65   EXPECT_EQ(lspLength("��"), 4UL);
66 
67   WithContextValue UTF32(kCurrentOffsetEncoding, OffsetEncoding::UTF32);
68   EXPECT_EQ(lspLength(""), 0UL);
69   EXPECT_EQ(lspLength("ascii"), 5UL);
70   // BMP
71   EXPECT_EQ(lspLength("↓"), 1UL);
72   EXPECT_EQ(lspLength("¥"), 1UL);
73   // astral
74   EXPECT_EQ(lspLength("��"), 1UL);
75 }
76 
77 // The = → �� below are ASCII (1 byte), BMP (3 bytes), and astral (4 bytes).
78 const char File[] = R"(0:0 = 0
79 1:0 → 8
80 2:0 �� 18)";
81 struct Line {
82   unsigned Number;
83   unsigned Offset;
84   unsigned Length;
85 };
86 Line FileLines[] = {Line{0, 0, 7}, Line{1, 8, 9}, Line{2, 18, 11}};
87 
88 TEST(SourceCodeTests, PositionToOffset) {
89   // line out of bounds
90   EXPECT_THAT_EXPECTED(positionToOffset(File, position(-1, 2)), llvm::Failed());
91   // first line
92   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, -1)),
93                        llvm::Failed()); // out of range
94   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 0)),
95                        llvm::HasValue(0)); // first character
96   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 3)),
97                        llvm::HasValue(3)); // middle character
98   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 6)),
99                        llvm::HasValue(6)); // last character
100   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7)),
101                        llvm::HasValue(7)); // the newline itself
102   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7), false),
103                        llvm::HasValue(7));
104   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8)),
105                        llvm::HasValue(7)); // out of range
106   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8), false),
107                        llvm::Failed()); // out of range
108   // middle line
109   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, -1)),
110                        llvm::Failed()); // out of range
111   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 0)),
112                        llvm::HasValue(8)); // first character
113   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3)),
114                        llvm::HasValue(11)); // middle character
115   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3), false),
116                        llvm::HasValue(11));
117   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 6)),
118                        llvm::HasValue(16)); // last character
119   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 7)),
120                        llvm::HasValue(17)); // the newline itself
121   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8)),
122                        llvm::HasValue(17)); // out of range
123   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8), false),
124                        llvm::Failed()); // out of range
125   // last line
126   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, -1)),
127                        llvm::Failed()); // out of range
128   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 0)),
129                        llvm::HasValue(18)); // first character
130   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 3)),
131                        llvm::HasValue(21)); // middle character
132   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 5), false),
133                        llvm::Failed()); // middle of surrogate pair
134   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 5)),
135                        llvm::HasValue(26)); // middle of surrogate pair
136   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 6), false),
137                        llvm::HasValue(26)); // end of surrogate pair
138   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 8)),
139                        llvm::HasValue(28)); // last character
140   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 9)),
141                        llvm::HasValue(29)); // EOF
142   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 10), false),
143                        llvm::Failed()); // out of range
144   // line out of bounds
145   EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 0)), llvm::Failed());
146   EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 1)), llvm::Failed());
147 
148   // Codepoints are similar, except near astral characters.
149   WithContextValue UTF32(kCurrentOffsetEncoding, OffsetEncoding::UTF32);
150   // line out of bounds
151   EXPECT_THAT_EXPECTED(positionToOffset(File, position(-1, 2)), llvm::Failed());
152   // first line
153   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, -1)),
154                        llvm::Failed()); // out of range
155   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 0)),
156                        llvm::HasValue(0)); // first character
157   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 3)),
158                        llvm::HasValue(3)); // middle character
159   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 6)),
160                        llvm::HasValue(6)); // last character
161   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7)),
162                        llvm::HasValue(7)); // the newline itself
163   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 7), false),
164                        llvm::HasValue(7));
165   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8)),
166                        llvm::HasValue(7)); // out of range
167   EXPECT_THAT_EXPECTED(positionToOffset(File, position(0, 8), false),
168                        llvm::Failed()); // out of range
169   // middle line
170   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, -1)),
171                        llvm::Failed()); // out of range
172   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 0)),
173                        llvm::HasValue(8)); // first character
174   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3)),
175                        llvm::HasValue(11)); // middle character
176   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 3), false),
177                        llvm::HasValue(11));
178   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 6)),
179                        llvm::HasValue(16)); // last character
180   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 7)),
181                        llvm::HasValue(17)); // the newline itself
182   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8)),
183                        llvm::HasValue(17)); // out of range
184   EXPECT_THAT_EXPECTED(positionToOffset(File, position(1, 8), false),
185                        llvm::Failed()); // out of range
186   // last line
187   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, -1)),
188                        llvm::Failed()); // out of range
189   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 0)),
190                        llvm::HasValue(18)); // first character
191   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 4)),
192                        llvm::HasValue(22)); // Before astral character.
193   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 5), false),
194                        llvm::HasValue(26)); // after astral character
195   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 7)),
196                        llvm::HasValue(28)); // last character
197   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 8)),
198                        llvm::HasValue(29)); // EOF
199   EXPECT_THAT_EXPECTED(positionToOffset(File, position(2, 9), false),
200                        llvm::Failed()); // out of range
201   // line out of bounds
202   EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 0)), llvm::Failed());
203   EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 1)), llvm::Failed());
204 
205   // Test UTF-8, where transformations are trivial.
206   WithContextValue UTF8(kCurrentOffsetEncoding, OffsetEncoding::UTF8);
207   EXPECT_THAT_EXPECTED(positionToOffset(File, position(-1, 2)), llvm::Failed());
208   EXPECT_THAT_EXPECTED(positionToOffset(File, position(3, 0)), llvm::Failed());
209   for (Line L : FileLines) {
210     EXPECT_THAT_EXPECTED(positionToOffset(File, position(L.Number, -1)),
211                          llvm::Failed()); // out of range
212     for (unsigned I = 0; I <= L.Length; ++I)
213       EXPECT_THAT_EXPECTED(positionToOffset(File, position(L.Number, I)),
214                            llvm::HasValue(L.Offset + I));
215     EXPECT_THAT_EXPECTED(positionToOffset(File, position(L.Number, L.Length+1)),
216                          llvm::HasValue(L.Offset + L.Length));
217     EXPECT_THAT_EXPECTED(
218         positionToOffset(File, position(L.Number, L.Length + 1), false),
219         llvm::Failed()); // out of range
220   }
221 }
222 
223 TEST(SourceCodeTests, OffsetToPosition) {
224   EXPECT_THAT(offsetToPosition(File, 0), Pos(0, 0)) << "start of file";
225   EXPECT_THAT(offsetToPosition(File, 3), Pos(0, 3)) << "in first line";
226   EXPECT_THAT(offsetToPosition(File, 6), Pos(0, 6)) << "end of first line";
227   EXPECT_THAT(offsetToPosition(File, 7), Pos(0, 7)) << "first newline";
228   EXPECT_THAT(offsetToPosition(File, 8), Pos(1, 0)) << "start of second line";
229   EXPECT_THAT(offsetToPosition(File, 12), Pos(1, 4)) << "before BMP char";
230   EXPECT_THAT(offsetToPosition(File, 13), Pos(1, 5)) << "in BMP char";
231   EXPECT_THAT(offsetToPosition(File, 15), Pos(1, 5)) << "after BMP char";
232   EXPECT_THAT(offsetToPosition(File, 16), Pos(1, 6)) << "end of second line";
233   EXPECT_THAT(offsetToPosition(File, 17), Pos(1, 7)) << "second newline";
234   EXPECT_THAT(offsetToPosition(File, 18), Pos(2, 0)) << "start of last line";
235   EXPECT_THAT(offsetToPosition(File, 21), Pos(2, 3)) << "in last line";
236   EXPECT_THAT(offsetToPosition(File, 22), Pos(2, 4)) << "before astral char";
237   EXPECT_THAT(offsetToPosition(File, 24), Pos(2, 6)) << "in astral char";
238   EXPECT_THAT(offsetToPosition(File, 26), Pos(2, 6)) << "after astral char";
239   EXPECT_THAT(offsetToPosition(File, 28), Pos(2, 8)) << "end of last line";
240   EXPECT_THAT(offsetToPosition(File, 29), Pos(2, 9)) << "EOF";
241   EXPECT_THAT(offsetToPosition(File, 30), Pos(2, 9)) << "out of bounds";
242 
243   // Codepoints are similar, except near astral characters.
244   WithContextValue UTF32(kCurrentOffsetEncoding, OffsetEncoding::UTF32);
245   EXPECT_THAT(offsetToPosition(File, 0), Pos(0, 0)) << "start of file";
246   EXPECT_THAT(offsetToPosition(File, 3), Pos(0, 3)) << "in first line";
247   EXPECT_THAT(offsetToPosition(File, 6), Pos(0, 6)) << "end of first line";
248   EXPECT_THAT(offsetToPosition(File, 7), Pos(0, 7)) << "first newline";
249   EXPECT_THAT(offsetToPosition(File, 8), Pos(1, 0)) << "start of second line";
250   EXPECT_THAT(offsetToPosition(File, 12), Pos(1, 4)) << "before BMP char";
251   EXPECT_THAT(offsetToPosition(File, 13), Pos(1, 5)) << "in BMP char";
252   EXPECT_THAT(offsetToPosition(File, 15), Pos(1, 5)) << "after BMP char";
253   EXPECT_THAT(offsetToPosition(File, 16), Pos(1, 6)) << "end of second line";
254   EXPECT_THAT(offsetToPosition(File, 17), Pos(1, 7)) << "second newline";
255   EXPECT_THAT(offsetToPosition(File, 18), Pos(2, 0)) << "start of last line";
256   EXPECT_THAT(offsetToPosition(File, 21), Pos(2, 3)) << "in last line";
257   EXPECT_THAT(offsetToPosition(File, 22), Pos(2, 4)) << "before astral char";
258   EXPECT_THAT(offsetToPosition(File, 24), Pos(2, 5)) << "in astral char";
259   EXPECT_THAT(offsetToPosition(File, 26), Pos(2, 5)) << "after astral char";
260   EXPECT_THAT(offsetToPosition(File, 28), Pos(2, 7)) << "end of last line";
261   EXPECT_THAT(offsetToPosition(File, 29), Pos(2, 8)) << "EOF";
262   EXPECT_THAT(offsetToPosition(File, 30), Pos(2, 8)) << "out of bounds";
263 
264   WithContextValue UTF8(kCurrentOffsetEncoding, OffsetEncoding::UTF8);
265   for (Line L : FileLines) {
266     for (unsigned I = 0; I <= L.Length; ++I)
267       EXPECT_THAT(offsetToPosition(File, L.Offset + I), Pos(L.Number, I));
268   }
269   EXPECT_THAT(offsetToPosition(File, 30), Pos(2, 11)) << "out of bounds";
270 }
271 
272 TEST(SourceCodeTests, IsRangeConsecutive) {
273   EXPECT_TRUE(isRangeConsecutive(range({2, 2}, {2, 3}), range({2, 3}, {2, 4})));
274   EXPECT_FALSE(
275       isRangeConsecutive(range({0, 2}, {0, 3}), range({2, 3}, {2, 4})));
276   EXPECT_FALSE(
277       isRangeConsecutive(range({2, 2}, {2, 3}), range({2, 4}, {2, 5})));
278 }
279 
280 TEST(SourceCodeTests, SourceLocationInMainFile) {
281   Annotations Source(R"cpp(
282     ^in^t ^foo
283     ^bar
284     ^baz ^() {}  {} {} {} { }^
285 )cpp");
286 
287   SourceManagerForFile Owner("foo.cpp", Source.code());
288   SourceManager &SM = Owner.get();
289 
290   SourceLocation StartOfFile = SM.getLocForStartOfFile(SM.getMainFileID());
291   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 0)),
292                        HasValue(StartOfFile));
293   // End of file.
294   EXPECT_THAT_EXPECTED(
295       sourceLocationInMainFile(SM, position(4, 0)),
296       HasValue(StartOfFile.getLocWithOffset(Source.code().size())));
297   // Column number is too large.
298   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 1)), Failed());
299   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(0, 100)),
300                        Failed());
301   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(4, 1)), Failed());
302   // Line number is too large.
303   EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, position(5, 0)), Failed());
304   // Check all positions mentioned in the test return valid results.
305   for (auto P : Source.points()) {
306     size_t Offset = llvm::cantFail(positionToOffset(Source.code(), P));
307     EXPECT_THAT_EXPECTED(sourceLocationInMainFile(SM, P),
308                          HasValue(StartOfFile.getLocWithOffset(Offset)));
309   }
310 }
311 
312 TEST(SourceCodeTests, CollectIdentifiers) {
313   auto Style = format::getLLVMStyle();
314   auto IDs = collectIdentifiers(R"cpp(
315   #include "a.h"
316   void foo() { int xyz; int abc = xyz; return foo(); }
317   )cpp",
318                                 Style);
319   EXPECT_EQ(IDs.size(), 7u);
320   EXPECT_EQ(IDs["include"], 1u);
321   EXPECT_EQ(IDs["void"], 1u);
322   EXPECT_EQ(IDs["int"], 2u);
323   EXPECT_EQ(IDs["xyz"], 2u);
324   EXPECT_EQ(IDs["abc"], 1u);
325   EXPECT_EQ(IDs["return"], 1u);
326   EXPECT_EQ(IDs["foo"], 2u);
327 }
328 
329 TEST(SourceCodeTests, CollectWords) {
330   auto Words = collectWords(R"cpp(
331   #define FIZZ_BUZZ
332   // this is a comment
333   std::string getSomeText() { return "magic word"; }
334   )cpp");
335   std::set<std::string> ActualWords(Words.keys().begin(), Words.keys().end());
336   std::set<std::string> ExpectedWords = {"define",  "fizz",    "buzz",  "this",
337                                          "comment", "string", "some", "text",
338                                          "return",  "magic",  "word"};
339   EXPECT_EQ(ActualWords, ExpectedWords);
340 }
341 
342 TEST(SourceCodeTests, VisibleNamespaces) {
343   std::vector<std::pair<const char *, std::vector<std::string>>> Cases = {
344       {
345           R"cpp(
346             // Using directive resolved against enclosing namespaces.
347             using namespace foo;
348             namespace ns {
349             using namespace bar;
350           )cpp",
351           {"ns", "", "bar", "foo", "ns::bar"},
352       },
353       {
354           R"cpp(
355             // Don't include namespaces we've closed, ignore namespace aliases.
356             using namespace clang;
357             using std::swap;
358             namespace clang {
359             namespace clangd {}
360             namespace ll = ::llvm;
361             }
362             namespace clang {
363           )cpp",
364           {"clang", ""},
365       },
366       {
367           R"cpp(
368             // Using directives visible even if a namespace is reopened.
369             // Ignore anonymous namespaces.
370             namespace foo{ using namespace bar; }
371             namespace foo{ namespace {
372           )cpp",
373           {"foo", "", "bar", "foo::bar"},
374       },
375       {
376           R"cpp(
377             // Mismatched braces
378             namespace foo{}
379             }}}
380             namespace bar{
381           )cpp",
382           {"bar", ""},
383       },
384       {
385           R"cpp(
386             // Namespaces with multiple chunks.
387             namespace a::b {
388               using namespace c::d;
389               namespace e::f {
390           )cpp",
391           {
392               "a::b::e::f",
393               "",
394               "a",
395               "a::b",
396               "a::b::c::d",
397               "a::b::e",
398               "a::c::d",
399               "c::d",
400           },
401       },
402   };
403   for (const auto& Case : Cases) {
404     EXPECT_EQ(Case.second,
405               visibleNamespaces(Case.first, format::getLLVMStyle()))
406         << Case.first;
407   }
408 }
409 
410 TEST(SourceCodeTests, GetMacros) {
411   Annotations Code(R"cpp(
412      #define MACRO 123
413      int abc = MA^CRO;
414    )cpp");
415   TestTU TU = TestTU::withCode(Code.code());
416   auto AST = TU.build();
417   auto Loc = getBeginningOfIdentifier(AST, Code.point(),
418                                       AST.getSourceManager().getMainFileID());
419   auto Result = locateMacroAt(Loc, AST.getPreprocessor());
420   ASSERT_TRUE(Result);
421   EXPECT_THAT(*Result, MacroName("MACRO"));
422 }
423 
424 } // namespace
425 } // namespace clangd
426 } // namespace clang
427