clang-tools  15.0.0git
SymbolInfoTests.cpp
Go to the documentation of this file.
1 //===-- SymbolInfoTests.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 "ParsedAST.h"
10 #include "TestTU.h"
11 #include "XRefs.h"
12 #include "gmock/gmock.h"
13 #include "gtest/gtest.h"
14 
15 namespace clang {
16 namespace clangd {
17 namespace {
18 
19 using ::testing::UnorderedElementsAreArray;
20 
21 auto CreateExpectedSymbolDetails = [](const std::string &Name,
22  const std::string &Container,
23  const std::string &USR) {
24  return SymbolDetails{Name, Container, USR, SymbolID(USR)};
25 };
26 
27 TEST(SymbolInfoTests, All) {
28  std::pair<const char *, std::vector<SymbolDetails>>
29  TestInputExpectedOutput[] = {
30  {
31  R"cpp( // Simple function reference - declaration
32  void foo();
33  int bar() {
34  fo^o();
35  }
36  )cpp",
37  {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#")}},
38  {
39  R"cpp( // Simple function reference - definition
40  void foo() {}
41  int bar() {
42  fo^o();
43  }
44  )cpp",
45  {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#")}},
46  {
47  R"cpp( // Function in namespace reference
48  namespace bar {
49  void foo();
50  int baz() {
51  fo^o();
52  }
53  }
54  )cpp",
55  {CreateExpectedSymbolDetails("foo", "bar::", "c:@N@bar@F@foo#")}},
56  {
57  R"cpp( // Function in different namespace reference
58  namespace bar {
59  void foo();
60  }
61  namespace barbar {
62  int baz() {
63  bar::fo^o();
64  }
65  }
66  )cpp",
67  {CreateExpectedSymbolDetails("foo", "bar::", "c:@N@bar@F@foo#")}},
68  {
69  R"cpp( // Function in global namespace reference
70  void foo();
71  namespace Nbar {
72  namespace Nbaz {
73  int baz() {
74  ::fo^o();
75  }
76  }
77  }
78  )cpp",
79  {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#")}},
80  {
81  R"cpp( // Function in anonymous namespace reference
82  namespace {
83  void foo();
84  }
85  namespace barbar {
86  int baz() {
87  fo^o();
88  }
89  }
90  )cpp",
91  {CreateExpectedSymbolDetails("foo", "(anonymous)",
92  "c:TestTU.cpp@aN@F@foo#")}},
93  {
94  R"cpp( // Function reference - ADL
95  namespace bar {
96  struct BarType {};
97  void foo(const BarType&);
98  }
99  namespace barbar {
100  int baz() {
101  bar::BarType b;
102  fo^o(b);
103  }
104  }
105  )cpp",
106  {CreateExpectedSymbolDetails(
107  "foo", "bar::", "c:@N@bar@F@foo#&1$@N@bar@S@BarType#")}},
108  {
109  R"cpp( // Global value reference
110  int value;
111  void foo(int) { }
112  void bar() {
113  foo(val^ue);
114  }
115  )cpp",
116  {CreateExpectedSymbolDetails("value", "", "c:@value")}},
117  {
118  R"cpp( // Local value reference
119  void foo() { int aaa; int bbb = aa^a; }
120  )cpp",
121  {CreateExpectedSymbolDetails("aaa", "foo",
122  "c:TestTU.cpp@49@F@foo#@aaa")}},
123  {
124  R"cpp( // Function param
125  void bar(int aaa) {
126  int bbb = a^aa;
127  }
128  )cpp",
129  {CreateExpectedSymbolDetails("aaa", "bar",
130  "c:TestTU.cpp@38@F@bar#I#@aaa")}},
131  {
132  R"cpp( // Lambda capture
133  void foo() {
134  int ii;
135  auto lam = [ii]() {
136  return i^i;
137  };
138  }
139  )cpp",
140  {CreateExpectedSymbolDetails("ii", "foo",
141  "c:TestTU.cpp@54@F@foo#@ii")}},
142  {
143  R"cpp( // Macro reference
144  #define MACRO 5\nint i = MAC^RO;
145  )cpp",
146  {CreateExpectedSymbolDetails("MACRO", "",
147  "c:TestTU.cpp@38@macro@MACRO")}},
148  {
149  R"cpp( // Macro reference
150  #define MACRO 5\nint i = MACRO^;
151  )cpp",
152  {CreateExpectedSymbolDetails("MACRO", "",
153  "c:TestTU.cpp@38@macro@MACRO")}},
154  {
155  R"cpp( // Multiple symbols returned - using overloaded function name
156  void foo() {}
157  void foo(bool) {}
158  void foo(int) {}
159  namespace bar {
160  using ::fo^o;
161  }
162  )cpp",
163  {CreateExpectedSymbolDetails("foo", "", "c:@F@foo#"),
164  CreateExpectedSymbolDetails("foo", "", "c:@F@foo#b#"),
165  CreateExpectedSymbolDetails("foo", "", "c:@F@foo#I#"),
166  CreateExpectedSymbolDetails("foo", "bar::", "c:@N@bar@UD@foo")}},
167  {
168  R"cpp( // Multiple symbols returned - implicit conversion
169  struct foo {};
170  struct bar {
171  bar(const foo&) {}
172  };
173  void func_baz1(bar) {}
174  void func_baz2() {
175  foo ff;
176  func_baz1(f^f);
177  }
178  )cpp",
179  {CreateExpectedSymbolDetails(
180  "ff", "func_baz2", "c:TestTU.cpp@218@F@func_baz2#@ff")}},
181  {
182  R"cpp( // Type reference - declaration
183  struct foo;
184  void bar(fo^o*);
185  )cpp",
186  {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
187  {
188  R"cpp( // Type reference - definition
189  struct foo {};
190  void bar(fo^o*);
191  )cpp",
192  {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
193  {
194  R"cpp( // Type Reference - template argument
195  struct foo {};
196  template<class T> struct bar {};
197  void baz() {
198  bar<fo^o> b;
199  }
200  )cpp",
201  {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
202  {
203  R"cpp( // Template parameter reference - type param
204  template<class TT> struct bar {
205  T^T t;
206  };
207  )cpp",
208  {CreateExpectedSymbolDetails("TT", "bar::", "c:TestTU.cpp@65")}},
209  {
210  R"cpp( // Template parameter reference - type param
211  template<int NN> struct bar {
212  int a = N^N;
213  };
214  )cpp",
215  {CreateExpectedSymbolDetails("NN", "bar::", "c:TestTU.cpp@65")}},
216  {
217  R"cpp( // Class member reference - objec
218  struct foo {
219  int aa;
220  };
221  void bar() {
222  foo f;
223  f.a^a;
224  }
225  )cpp",
226  {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@FI@aa")}},
227  {
228  R"cpp( // Class member reference - pointer
229  struct foo {
230  int aa;
231  };
232  void bar() {
233  &foo::a^a;
234  }
235  )cpp",
236  {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@FI@aa")}},
237  {
238  R"cpp( // Class method reference - objec
239  struct foo {
240  void aa() {}
241  };
242  void bar() {
243  foo f;
244  f.a^a();
245  }
246  )cpp",
247  {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@F@aa#")}},
248  {
249  R"cpp( // Class method reference - pointer
250  struct foo {
251  void aa() {}
252  };
253  void bar() {
254  &foo::a^a;
255  }
256  )cpp",
257  {CreateExpectedSymbolDetails("aa", "foo::", "c:@S@foo@F@aa#")}},
258  {
259  R"cpp( // Typedef
260  typedef int foo;
261  void bar() {
262  fo^o a;
263  }
264  )cpp",
265  {CreateExpectedSymbolDetails("foo", "", "c:TestTU.cpp@T@foo")}},
266  {
267  R"cpp( // Type alias
268  using foo = int;
269  void bar() {
270  fo^o a;
271  }
272  )cpp",
273  {CreateExpectedSymbolDetails("foo", "", "c:@foo")}},
274  {
275  R"cpp( // Namespace reference
276  namespace foo {}
277  using namespace fo^o;
278  )cpp",
279  {CreateExpectedSymbolDetails("foo", "", "c:@N@foo")}},
280  {
281  R"cpp( // Enum value reference
282  enum foo { bar, baz };
283  void f() {
284  foo fff = ba^r;
285  }
286  )cpp",
287  {CreateExpectedSymbolDetails("bar", "foo", "c:@E@foo@bar")}},
288  {
289  R"cpp( // Enum class value reference
290  enum class foo { bar, baz };
291  void f() {
292  foo fff = foo::ba^r;
293  }
294  )cpp",
295  {CreateExpectedSymbolDetails("bar", "foo::", "c:@E@foo@bar")}},
296  {
297  R"cpp( // Parameters in declarations
298  void foo(int ba^r);
299  )cpp",
300  {CreateExpectedSymbolDetails("bar", "foo",
301  "c:TestTU.cpp@50@F@foo#I#@bar")}},
302  {
303  R"cpp( // Type inference with auto keyword
304  struct foo {};
305  foo getfoo() { return foo{}; }
306  void f() {
307  au^to a = getfoo();
308  }
309  )cpp",
310  {/* not implemented */}},
311  {
312  R"cpp( // decltype
313  struct foo {};
314  void f() {
315  foo f;
316  declt^ype(f);
317  }
318  )cpp",
319  {/* not implemented */}},
320  };
321 
322  for (const auto &T : TestInputExpectedOutput) {
323  Annotations TestInput(T.first);
324  auto AST = TestTU::withCode(TestInput.code()).build();
325 
326  EXPECT_THAT(getSymbolInfo(AST, TestInput.point()),
327  UnorderedElementsAreArray(T.second))
328  << T.first;
329  }
330 }
331 
332 } // namespace
333 } // namespace clangd
334 } // namespace clang
XRefs.h
clang::clangd::TEST
TEST(BackgroundQueueTest, Priority)
Definition: BackgroundIndexTests.cpp:750
clang::clangd::TestTU::build
ParsedAST build() const
Definition: TestTU.cpp:109
TestTU.h
clang::clangd::getSymbolInfo
std::vector< SymbolDetails > getSymbolInfo(ParsedAST &AST, Position Pos)
Get info about symbols at Pos.
Definition: XRefs.cpp:1515
clang::doc::SymbolID
std::array< uint8_t, 20 > SymbolID
Definition: Representation.h:30
Name
Token Name
Definition: MacroToEnumCheck.cpp:89
clang::clangd::TestTU::withCode
static TestTU withCode(llvm::StringRef Code)
Definition: TestTU.h:36
Annotations.h
clang
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
Definition: ApplyReplacements.h:27
ParsedAST.h