xref: /llvm-project/clang-tools-extra/clangd/unittests/FindTargetTests.cpp (revision 73adf26d504ba945251b87d78267e2bbfd34928f)
1 //===-- FindTargetTests.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 "FindTarget.h"
9 
10 #include "Selection.h"
11 #include "TestTU.h"
12 #include "clang/AST/Decl.h"
13 #include "clang/AST/DeclTemplate.h"
14 #include "clang/Basic/SourceLocation.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Support/Casting.h"
17 #include "llvm/Support/raw_ostream.h"
18 #include "llvm/Testing/Annotations/Annotations.h"
19 #include "gmock/gmock.h"
20 #include "gtest/gtest.h"
21 #include <initializer_list>
22 
23 namespace clang {
24 namespace clangd {
25 namespace {
26 
27 // A referenced Decl together with its DeclRelationSet, for assertions.
28 //
29 // There's no great way to assert on the "content" of a Decl in the general case
30 // that's both expressive and unambiguous (e.g. clearly distinguishes between
31 // templated decls and their specializations).
32 //
33 // We use the result of pretty-printing the decl, with the {body} truncated.
34 struct PrintedDecl {
35   PrintedDecl(const char *Name, DeclRelationSet Relations = {})
36       : Name(Name), Relations(Relations) {}
37   PrintedDecl(const NamedDecl *D, DeclRelationSet Relations = {})
38       : Relations(Relations) {
39     std::string S;
40     llvm::raw_string_ostream OS(S);
41     D->print(OS);
42     llvm::StringRef FirstLine =
43         llvm::StringRef(OS.str()).take_until([](char C) { return C == '\n'; });
44     FirstLine = FirstLine.rtrim(" {");
45     Name = std::string(FirstLine.rtrim(" {"));
46   }
47 
48   std::string Name;
49   DeclRelationSet Relations;
50 };
51 bool operator==(const PrintedDecl &L, const PrintedDecl &R) {
52   return std::tie(L.Name, L.Relations) == std::tie(R.Name, R.Relations);
53 }
54 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const PrintedDecl &D) {
55   return OS << D.Name << " Rel=" << D.Relations;
56 }
57 
58 // The test cases in for targetDecl() take the form
59 //  - a piece of code (Code = "...")
60 //  - Code should have a single AST node marked as a [[range]]
61 //  - an EXPECT_DECLS() assertion that verify the type of node selected, and
62 //    all the decls that targetDecl() considers it to reference
63 // Despite the name, these cases actually test allTargetDecls() for brevity.
64 class TargetDeclTest : public ::testing::Test {
65 protected:
66   using Rel = DeclRelation;
67   std::string Code;
68   std::vector<std::string> Flags;
69 
70   // Asserts that `Code` has a marked selection of a node `NodeType`,
71   // and returns allTargetDecls() as PrintedDecl structs.
72   // Use via EXPECT_DECLS().
73   std::vector<PrintedDecl> assertNodeAndPrintDecls(const char *NodeType) {
74     llvm::Annotations A(Code);
75     auto TU = TestTU::withCode(A.code());
76     TU.ExtraArgs = Flags;
77     auto AST = TU.build();
78     llvm::Annotations::Range R = A.range();
79     auto Selection = SelectionTree::createRight(
80         AST.getASTContext(), AST.getTokens(), R.Begin, R.End);
81     const SelectionTree::Node *N = Selection.commonAncestor();
82     if (!N) {
83       ADD_FAILURE() << "No node selected!\n" << Code;
84       return {};
85     }
86     EXPECT_EQ(N->kind(), NodeType) << Selection;
87 
88     std::vector<PrintedDecl> ActualDecls;
89     for (const auto &Entry :
90          allTargetDecls(N->ASTNode, AST.getHeuristicResolver()))
91       ActualDecls.emplace_back(Entry.first, Entry.second);
92     return ActualDecls;
93   }
94 };
95 
96 // This is a macro to preserve line numbers in assertion failures.
97 // It takes the expected decls as varargs to work around comma-in-macro issues.
98 #define EXPECT_DECLS(NodeType, ...)                                            \
99   EXPECT_THAT(assertNodeAndPrintDecls(NodeType),                               \
100               ::testing::UnorderedElementsAreArray(                            \
101                   std::vector<PrintedDecl>({__VA_ARGS__})))                    \
102       << Code
103 using ExpectedDecls = std::vector<PrintedDecl>;
104 
105 TEST_F(TargetDeclTest, Exprs) {
106   Code = R"cpp(
107     int f();
108     int x = [[f]]();
109   )cpp";
110   EXPECT_DECLS("DeclRefExpr", "int f()");
111 
112   Code = R"cpp(
113     struct S { S operator+(S) const; };
114     auto X = S() [[+]] S();
115   )cpp";
116   EXPECT_DECLS("DeclRefExpr", "S operator+(S) const");
117 
118   Code = R"cpp(
119     int foo();
120     int s = foo[[()]];
121   )cpp";
122   EXPECT_DECLS("CallExpr", "int foo()");
123 
124   Code = R"cpp(
125     struct X {
126     void operator()(int n);
127     };
128     void test() {
129       X x;
130       x[[(123)]];
131     }
132   )cpp";
133   EXPECT_DECLS("CXXOperatorCallExpr", "void operator()(int n)");
134 
135   Code = R"cpp(
136     void test() {
137       goto [[label]];
138     label:
139       return;
140     }
141   )cpp";
142   EXPECT_DECLS("GotoStmt", "label:");
143   Code = R"cpp(
144     void test() {
145     [[label]]:
146       return;
147     }
148   )cpp";
149   EXPECT_DECLS("LabelStmt", "label:");
150 }
151 
152 TEST_F(TargetDeclTest, RecoveryForC) {
153   Flags = {"-xc", "-Xclang", "-frecovery-ast"};
154   Code = R"cpp(
155     // error-ok: testing behavior on broken code
156     // int f();
157     int f(int);
158     int x = [[f]]();
159   )cpp";
160   EXPECT_DECLS("DeclRefExpr", "int f(int)");
161 }
162 
163 TEST_F(TargetDeclTest, Recovery) {
164   Code = R"cpp(
165     // error-ok: testing behavior on broken code
166     int f();
167     int f(int, int);
168     int x = [[f]](42);
169   )cpp";
170   EXPECT_DECLS("UnresolvedLookupExpr", "int f()", "int f(int, int)");
171 }
172 
173 TEST_F(TargetDeclTest, RecoveryType) {
174   Code = R"cpp(
175     // error-ok: testing behavior on broken code
176     struct S { int member; };
177     S overloaded(int);
178     void foo() {
179       // No overload matches, but we have recovery-expr with the correct type.
180       overloaded().[[member]];
181     }
182   )cpp";
183   EXPECT_DECLS("MemberExpr", "int member");
184 }
185 
186 TEST_F(TargetDeclTest, UsingDecl) {
187   Code = R"cpp(
188     namespace foo {
189       int f(int);
190       int f(char);
191     }
192     using foo::f;
193     int x = [[f]](42);
194   )cpp";
195   // f(char) is not referenced!
196   EXPECT_DECLS("DeclRefExpr", {"using foo::f", Rel::Alias}, {"int f(int)"});
197 
198   Code = R"cpp(
199     namespace foo {
200       int f(int);
201       int f(char);
202     }
203     [[using foo::f]];
204   )cpp";
205   // All overloads are referenced.
206   EXPECT_DECLS("UsingDecl", {"using foo::f", Rel::Alias}, {"int f(int)"},
207                {"int f(char)"});
208 
209   Code = R"cpp(
210     struct X {
211       int foo();
212     };
213     struct Y : X {
214       using X::foo;
215     };
216     int x = Y().[[foo]]();
217   )cpp";
218   EXPECT_DECLS("MemberExpr", {"using X::foo", Rel::Alias}, {"int foo()"});
219 
220   Code = R"cpp(
221       template <typename T>
222       struct Base {
223         void waldo() {}
224       };
225       template <typename T>
226       struct Derived : Base<T> {
227         using Base<T>::[[waldo]];
228       };
229     )cpp";
230   EXPECT_DECLS("UnresolvedUsingValueDecl", {"using Base<T>::waldo", Rel::Alias},
231                {"void waldo()"});
232 
233   Code = R"cpp(
234     namespace ns {
235     template<typename T> class S {};
236     }
237 
238     using ns::S;
239 
240     template<typename T>
241     using A = [[S]]<T>;
242   )cpp";
243   EXPECT_DECLS("TemplateSpecializationTypeLoc", {"using ns::S", Rel::Alias},
244                {"template <typename T> class S"},
245                {"class S", Rel::TemplatePattern});
246 
247   Code = R"cpp(
248     namespace ns {
249     template<typename T> class S {};
250     }
251 
252     using ns::S;
253     template <template <typename> class T> class X {};
254     using B = X<[[S]]>;
255   )cpp";
256   EXPECT_DECLS("TemplateArgumentLoc", {"using ns::S", Rel::Alias},
257                {"template <typename T> class S"});
258 
259   Code = R"cpp(
260     namespace ns {
261     template<typename T> class S { public: S(T); };
262     }
263 
264     using ns::S;
265     [[S]] s(123);
266   )cpp";
267   Flags.push_back("-std=c++17"); // For CTAD feature.
268   EXPECT_DECLS("DeducedTemplateSpecializationTypeLoc",
269                {"using ns::S", Rel::Alias}, {"template <typename T> class S"},
270                {"class S", Rel::TemplatePattern});
271 
272   Code = R"cpp(
273     template<typename T>
274     class Foo { public: class foo {}; };
275     template <class T> class A : public Foo<T> {
276       using typename Foo<T>::foo;
277       [[foo]] abc;
278     };
279   )cpp";
280   EXPECT_DECLS("UnresolvedUsingTypeLoc",
281                {"using typename Foo<T>::foo", Rel::Alias});
282 
283   // Using enum.
284   Flags.push_back("-std=c++20");
285   Code = R"cpp(
286     namespace ns { enum class A { X }; }
287     [[using enum ns::A]];
288   )cpp";
289   EXPECT_DECLS("UsingEnumDecl", "enum class A : int");
290 
291   Code = R"cpp(
292     namespace ns { enum class A { X }; }
293     using enum ns::A;
294     auto m = [[X]];
295   )cpp";
296   EXPECT_DECLS("DeclRefExpr", "X");
297 }
298 
299 TEST_F(TargetDeclTest, BaseSpecifier) {
300   Code = R"cpp(
301     struct X {};
302     struct Y : [[private]] X {};
303   )cpp";
304   EXPECT_DECLS("CXXBaseSpecifier", "struct X");
305   Code = R"cpp(
306     struct X {};
307     struct Y : [[private X]] {};
308   )cpp";
309   EXPECT_DECLS("CXXBaseSpecifier", "struct X");
310   Code = R"cpp(
311     struct X {};
312     struct Y : private [[X]] {};
313   )cpp";
314   EXPECT_DECLS("RecordTypeLoc", "struct X");
315 }
316 
317 TEST_F(TargetDeclTest, ConstructorInitList) {
318   Code = R"cpp(
319     struct X {
320       int a;
321       X() : [[a]](42) {}
322     };
323   )cpp";
324   EXPECT_DECLS("CXXCtorInitializer", "int a");
325 
326   Code = R"cpp(
327     struct X {
328       X() : [[X]](1) {}
329       X(int);
330     };
331   )cpp";
332   EXPECT_DECLS("RecordTypeLoc", "struct X");
333 }
334 
335 TEST_F(TargetDeclTest, DesignatedInit) {
336   Flags = {"-xc"}; // array designators are a C99 extension.
337   Code = R"c(
338     struct X { int a; };
339     struct Y { int b; struct X c[2]; };
340     struct Y y = { .c[0].[[a]] = 1 };
341   )c";
342   EXPECT_DECLS("DesignatedInitExpr", "int a");
343 }
344 
345 TEST_F(TargetDeclTest, NestedNameSpecifier) {
346   Code = R"cpp(
347     namespace a { namespace b { int c; } }
348     int x = a::[[b::]]c;
349   )cpp";
350   EXPECT_DECLS("NestedNameSpecifierLoc", "namespace b");
351 
352   Code = R"cpp(
353     namespace a { struct X { enum { y }; }; }
354     int x = a::[[X::]]y;
355   )cpp";
356   EXPECT_DECLS("NestedNameSpecifierLoc", "struct X");
357 
358   Code = R"cpp(
359     template <typename T>
360     int x = [[T::]]y;
361   )cpp";
362   EXPECT_DECLS("NestedNameSpecifierLoc", "typename T");
363 
364   Code = R"cpp(
365     namespace a { int x; }
366     namespace b = a;
367     int y = [[b]]::x;
368   )cpp";
369   EXPECT_DECLS("NestedNameSpecifierLoc", {"namespace b = a", Rel::Alias},
370                {"namespace a", Rel::Underlying});
371 }
372 
373 TEST_F(TargetDeclTest, Types) {
374   Code = R"cpp(
375     struct X{};
376     [[X]] x;
377   )cpp";
378   EXPECT_DECLS("RecordTypeLoc", "struct X");
379 
380   Code = R"cpp(
381     struct S{};
382     typedef S X;
383     [[X]] x;
384   )cpp";
385   EXPECT_DECLS("TypedefTypeLoc", {"typedef S X", Rel::Alias},
386                {"struct S", Rel::Underlying});
387   Code = R"cpp(
388     namespace ns { struct S{}; }
389     typedef ns::S X;
390     [[X]] x;
391   )cpp";
392   EXPECT_DECLS("TypedefTypeLoc", {"typedef ns::S X", Rel::Alias},
393                {"struct S", Rel::Underlying});
394 
395   Code = R"cpp(
396     template<class T>
397     void foo() { [[T]] x; }
398   )cpp";
399   EXPECT_DECLS("TemplateTypeParmTypeLoc", "class T");
400   Flags.clear();
401 
402   Code = R"cpp(
403     template<template<typename> class T>
404     void foo() { [[T<int>]] x; }
405   )cpp";
406   EXPECT_DECLS("TemplateSpecializationTypeLoc", "template <typename> class T");
407   Flags.clear();
408 
409   Code = R"cpp(
410   template<template<typename> class ...T>
411   class C {
412     C<[[T...]]> foo;
413     };
414   )cpp";
415   EXPECT_DECLS("TemplateArgumentLoc", {"template <typename> class ...T"});
416   Flags.clear();
417 
418   Code = R"cpp(
419     struct S{};
420     S X;
421     [[decltype]](X) Y;
422   )cpp";
423   EXPECT_DECLS("DecltypeTypeLoc", {"struct S", Rel::Underlying});
424 
425   Code = R"cpp(
426     struct S{};
427     [[auto]] X = S{};
428   )cpp";
429   // FIXME: deduced type missing in AST. https://llvm.org/PR42914
430   EXPECT_DECLS("AutoTypeLoc", );
431 
432   Code = R"cpp(
433     template <typename... E>
434     struct S {
435       static const int size = sizeof...([[E]]);
436     };
437   )cpp";
438   EXPECT_DECLS("SizeOfPackExpr", "typename ...E");
439 
440   Code = R"cpp(
441     template <typename T>
442     class Foo {
443       void f([[Foo]] x);
444     };
445   )cpp";
446   EXPECT_DECLS("InjectedClassNameTypeLoc", "class Foo");
447 }
448 
449 TEST_F(TargetDeclTest, ClassTemplate) {
450   Code = R"cpp(
451     // Implicit specialization.
452     template<int x> class Foo{};
453     [[Foo<42>]] B;
454   )cpp";
455   EXPECT_DECLS("TemplateSpecializationTypeLoc",
456                {"template<> class Foo<42>", Rel::TemplateInstantiation},
457                {"class Foo", Rel::TemplatePattern});
458 
459   Code = R"cpp(
460     template<typename T> class Foo {};
461     // The "Foo<int>" SpecializationDecl is incomplete, there is no
462     // instantiation happening.
463     void func([[Foo<int>]] *);
464   )cpp";
465   EXPECT_DECLS("TemplateSpecializationTypeLoc",
466                {"class Foo", Rel::TemplatePattern},
467                {"template<> class Foo<int>", Rel::TemplateInstantiation});
468 
469   Code = R"cpp(
470     // Explicit specialization.
471     template<int x> class Foo{};
472     template<> class Foo<42>{};
473     [[Foo<42>]] B;
474   )cpp";
475   EXPECT_DECLS("TemplateSpecializationTypeLoc", "template<> class Foo<42>");
476 
477   Code = R"cpp(
478     // Partial specialization.
479     template<typename T> class Foo{};
480     template<typename T> class Foo<T*>{};
481     [[Foo<int*>]] B;
482   )cpp";
483   EXPECT_DECLS("TemplateSpecializationTypeLoc",
484                {"template<> class Foo<int *>", Rel::TemplateInstantiation},
485                {"template <typename T> class Foo<T *>", Rel::TemplatePattern});
486 
487   Code = R"cpp(
488     // Template template argument.
489     template<typename T> struct Vector {};
490     template <template <typename> class Container>
491     struct A {};
492     A<[[Vector]]> a;
493   )cpp";
494   EXPECT_DECLS("TemplateArgumentLoc", {"template <typename T> struct Vector"});
495 
496   Flags.push_back("-std=c++17"); // for CTAD tests
497 
498   Code = R"cpp(
499     // Class template argument deduction
500     template <typename T>
501     struct Test {
502       Test(T);
503     };
504     void foo() {
505       [[Test]] a(5);
506     }
507   )cpp";
508   EXPECT_DECLS("DeducedTemplateSpecializationTypeLoc",
509                {"struct Test", Rel::TemplatePattern});
510 
511   Code = R"cpp(
512     // Deduction guide
513     template <typename T>
514     struct Test {
515       template <typename I>
516       Test(I, I);
517     };
518     template <typename I>
519     [[Test]](I, I) -> Test<typename I::type>;
520   )cpp";
521   EXPECT_DECLS("CXXDeductionGuideDecl", {"template <typename T> struct Test"});
522 }
523 
524 TEST_F(TargetDeclTest, Concept) {
525   Flags.push_back("-std=c++20");
526 
527   // FIXME: Should we truncate the pretty-printed form of a concept decl
528   // somewhere?
529 
530   Code = R"cpp(
531     template <typename T>
532     concept Fooable = requires (T t) { t.foo(); };
533 
534     template <typename T> requires [[Fooable]]<T>
535     void bar(T t) {
536       t.foo();
537     }
538   )cpp";
539   EXPECT_DECLS(
540       "ConceptReference",
541       {"template <typename T> concept Fooable = requires (T t) { t.foo(); }"});
542 
543   // trailing requires clause
544   Code = R"cpp(
545       template <typename T>
546       concept Fooable = true;
547 
548       template <typename T>
549       void foo() requires [[Fooable]]<T>;
550   )cpp";
551   EXPECT_DECLS("ConceptReference",
552                {"template <typename T> concept Fooable = true"});
553 
554   // constrained-parameter
555   Code = R"cpp(
556     template <typename T>
557     concept Fooable = true;
558 
559     template <[[Fooable]] T>
560     void bar(T t);
561   )cpp";
562   EXPECT_DECLS("ConceptReference",
563                {"template <typename T> concept Fooable = true"});
564 
565   // partial-concept-id
566   Code = R"cpp(
567     template <typename T, typename U>
568     concept Fooable = true;
569 
570     template <[[Fooable]]<int> T>
571     void bar(T t);
572   )cpp";
573   EXPECT_DECLS("ConceptReference",
574                {"template <typename T, typename U> concept Fooable = true"});
575 }
576 
577 TEST_F(TargetDeclTest, Coroutine) {
578   Flags.push_back("-std=c++20");
579 
580   Code = R"cpp(
581     namespace std {
582     template <typename, typename...> struct coroutine_traits;
583     template <typename> struct coroutine_handle {
584       template <typename U>
585       coroutine_handle(coroutine_handle<U>&&) noexcept;
586       static coroutine_handle from_address(void* __addr) noexcept;
587     };
588     } // namespace std
589 
590     struct executor {};
591     struct awaitable {};
592     struct awaitable_frame {
593       awaitable get_return_object();
594       void return_void();
595       void unhandled_exception();
596       struct result_t {
597         ~result_t();
598         bool await_ready() const noexcept;
599         void await_suspend(std::coroutine_handle<void>) noexcept;
600         void await_resume() const noexcept;
601       };
602       result_t initial_suspend() noexcept;
603       result_t final_suspend() noexcept;
604       result_t await_transform(executor) noexcept;
605     };
606 
607     namespace std {
608     template <>
609     struct coroutine_traits<awaitable> {
610       typedef awaitable_frame promise_type;
611     };
612     } // namespace std
613 
614     awaitable foo() {
615       co_await [[executor]]();
616     }
617   )cpp";
618   EXPECT_DECLS("RecordTypeLoc", "struct executor");
619 }
620 
621 TEST_F(TargetDeclTest, RewrittenBinaryOperator) {
622   Flags.push_back("-std=c++20");
623 
624   Code = R"cpp(
625   namespace std {
626     struct strong_ordering {
627       int n;
628       constexpr operator int() const { return n; }
629       static const strong_ordering equal, greater, less;
630     };
631     constexpr strong_ordering strong_ordering::equal = {0};
632     constexpr strong_ordering strong_ordering::greater = {1};
633     constexpr strong_ordering strong_ordering::less = {-1};
634     }
635 
636     struct Foo
637     {
638       int x;
639       auto operator<=>(const Foo&) const = default;
640     };
641 
642     bool x = (Foo(1) [[!=]] Foo(2));
643   )cpp";
644   EXPECT_DECLS("CXXRewrittenBinaryOperator",
645                {"bool operator==(const Foo &) const noexcept = default"});
646 }
647 
648 TEST_F(TargetDeclTest, FunctionTemplate) {
649   Code = R"cpp(
650     // Implicit specialization.
651     template<typename T> bool foo(T) { return false; };
652     bool x = [[foo]](42);
653   )cpp";
654   EXPECT_DECLS("DeclRefExpr",
655                {"template<> bool foo<int>(int)", Rel::TemplateInstantiation},
656                {"bool foo(T)", Rel::TemplatePattern});
657 
658   Code = R"cpp(
659     // Explicit specialization.
660     template<typename T> bool foo(T) { return false; };
661     template<> bool foo<int>(int) { return false; };
662     bool x = [[foo]](42);
663   )cpp";
664   EXPECT_DECLS("DeclRefExpr", "template<> bool foo<int>(int)");
665 }
666 
667 TEST_F(TargetDeclTest, VariableTemplate) {
668   // Pretty-printer doesn't do a very good job of variable templates :-(
669   Code = R"cpp(
670     // Implicit specialization.
671     template<typename T> int foo;
672     int x = [[foo]]<char>;
673   )cpp";
674   EXPECT_DECLS("DeclRefExpr", {"int foo", Rel::TemplateInstantiation},
675                {"int foo", Rel::TemplatePattern});
676 
677   Code = R"cpp(
678     // Explicit specialization.
679     template<typename T> int foo;
680     template <> bool foo<char>;
681     int x = [[foo]]<char>;
682   )cpp";
683   EXPECT_DECLS("DeclRefExpr", "bool foo");
684 
685   Code = R"cpp(
686     // Partial specialization.
687     template<typename T> int foo;
688     template<typename T> bool foo<T*>;
689     bool x = [[foo]]<char*>;
690   )cpp";
691   EXPECT_DECLS("DeclRefExpr", {"bool foo", Rel::TemplateInstantiation},
692                {"bool foo", Rel::TemplatePattern});
693 }
694 
695 TEST_F(TargetDeclTest, TypeAliasTemplate) {
696   Code = R"cpp(
697     template<typename T, int X> class SmallVector {};
698     template<typename U> using TinyVector = SmallVector<U, 1>;
699     [[TinyVector<int>]] X;
700   )cpp";
701   EXPECT_DECLS("TemplateSpecializationTypeLoc",
702                {"template<> class SmallVector<int, 1>",
703                 Rel::TemplateInstantiation | Rel::Underlying},
704                {"class SmallVector", Rel::TemplatePattern | Rel::Underlying},
705                {"using TinyVector = SmallVector<U, 1>",
706                 Rel::Alias | Rel::TemplatePattern});
707 }
708 
709 TEST_F(TargetDeclTest, BuiltinTemplates) {
710   Code = R"cpp(
711     template <class T, T... Index> struct integer_sequence {};
712     [[__make_integer_seq]]<integer_sequence, int, 3> X;
713   )cpp";
714   EXPECT_DECLS(
715       "TemplateSpecializationTypeLoc",
716       {"struct integer_sequence", Rel::TemplatePattern | Rel::Underlying},
717       {"template<> struct integer_sequence<int, <0, 1, 2>>",
718        Rel::TemplateInstantiation | Rel::Underlying});
719 
720   // Dependent context.
721   Code = R"cpp(
722     template <class T, T... Index> struct integer_sequence;
723 
724     template <class T, int N>
725     using make_integer_sequence = [[__make_integer_seq]]<integer_sequence, T, N>;
726   )cpp";
727   EXPECT_DECLS("TemplateSpecializationTypeLoc", );
728 
729   Code = R"cpp(
730     template <int N, class... Pack>
731     using type_pack_element = [[__type_pack_element]]<N, Pack...>;
732   )cpp";
733   EXPECT_DECLS("TemplateSpecializationTypeLoc", );
734 }
735 
736 TEST_F(TargetDeclTest, MemberOfTemplate) {
737   Code = R"cpp(
738     template <typename T> struct Foo {
739       int x(T);
740     };
741     int y = Foo<int>().[[x]](42);
742   )cpp";
743   EXPECT_DECLS("MemberExpr", {"int x(int)", Rel::TemplateInstantiation},
744                {"int x(T)", Rel::TemplatePattern});
745 
746   Code = R"cpp(
747     template <typename T> struct Foo {
748       template <typename U>
749       int x(T, U);
750     };
751     int y = Foo<char>().[[x]]('c', 42);
752   )cpp";
753   EXPECT_DECLS("MemberExpr",
754                {"template<> int x<int>(char, int)", Rel::TemplateInstantiation},
755                {"int x(T, U)", Rel::TemplatePattern});
756 }
757 
758 TEST_F(TargetDeclTest, Lambda) {
759   Code = R"cpp(
760     void foo(int x = 42) {
761       auto l = [ [[x]] ]{ return x + 1; };
762     };
763   )cpp";
764   EXPECT_DECLS("DeclRefExpr", "int x = 42");
765 
766   // It seems like this should refer to another var, with the outer param being
767   // an underlying decl. But it doesn't seem to exist.
768   Code = R"cpp(
769     void foo(int x = 42) {
770       auto l = [x]{ return [[x]] + 1; };
771     };
772   )cpp";
773   EXPECT_DECLS("DeclRefExpr", "int x = 42");
774 
775   Code = R"cpp(
776     void foo() {
777       auto l = [x = 1]{ return [[x]] + 1; };
778     };
779   )cpp";
780   // FIXME: why both auto and int?
781   EXPECT_DECLS("DeclRefExpr", "auto int x = 1");
782 }
783 
784 TEST_F(TargetDeclTest, OverloadExpr) {
785   Flags.push_back("--target=x86_64-pc-linux-gnu");
786 
787   Code = R"cpp(
788     void func(int*);
789     void func(char*);
790 
791     template <class T>
792     void foo(T t) {
793       [[func]](t);
794     };
795   )cpp";
796   EXPECT_DECLS("UnresolvedLookupExpr", "void func(int *)", "void func(char *)");
797 
798   Code = R"cpp(
799     struct X {
800       void func(int*);
801       void func(char*);
802     };
803 
804     template <class T>
805     void foo(X x, T t) {
806       x.[[func]](t);
807     };
808   )cpp";
809   EXPECT_DECLS("UnresolvedMemberExpr", "void func(int *)", "void func(char *)");
810 
811   Code = R"cpp(
812     struct X {
813       static void *operator new(unsigned long);
814     };
815     auto* k = [[new]] X();
816   )cpp";
817   EXPECT_DECLS("CXXNewExpr", "static void *operator new(unsigned long)");
818   Code = R"cpp(
819     void *operator new(unsigned long);
820     auto* k = [[new]] int();
821   )cpp";
822   EXPECT_DECLS("CXXNewExpr", "void *operator new(unsigned long)");
823 
824   Code = R"cpp(
825     struct X {
826       static void operator delete(void *) noexcept;
827     };
828     void k(X* x) {
829       [[delete]] x;
830     }
831   )cpp";
832   EXPECT_DECLS("CXXDeleteExpr", "static void operator delete(void *) noexcept");
833   Code = R"cpp(
834     void operator delete(void *) noexcept;
835     void k(int* x) {
836       [[delete]] x;
837     }
838   )cpp";
839   // Sized deallocation is enabled by default in C++14 onwards.
840   EXPECT_DECLS("CXXDeleteExpr",
841                "void operator delete(void *, unsigned long) noexcept");
842 }
843 
844 TEST_F(TargetDeclTest, DependentExprs) {
845   Flags.push_back("--std=c++20");
846 
847   // Heuristic resolution of method of dependent field
848   Code = R"cpp(
849         struct A { void foo() {} };
850         template <typename T>
851         struct B {
852           A a;
853           void bar() {
854             this->a.[[foo]]();
855           }
856         };
857       )cpp";
858   EXPECT_DECLS("MemberExpr", "void foo()");
859 
860   // Similar to above but base expression involves a function call.
861   Code = R"cpp(
862         struct A {
863           void foo() {}
864         };
865         struct B {
866           A getA();
867         };
868         template <typename T>
869         struct C {
870           B c;
871           void bar() {
872             this->c.getA().[[foo]]();
873           }
874         };
875       )cpp";
876   EXPECT_DECLS("MemberExpr", "void foo()");
877 
878   // Similar to above but uses a function pointer.
879   Code = R"cpp(
880         struct A {
881           void foo() {}
882         };
883         struct B {
884           using FPtr = A(*)();
885           FPtr fptr;
886         };
887         template <typename T>
888         struct C {
889           B c;
890           void bar() {
891             this->c.fptr().[[foo]]();
892           }
893         };
894       )cpp";
895   EXPECT_DECLS("MemberExpr", "void foo()");
896 
897   // Base expression involves a member access into this.
898   Code = R"cpp(
899         struct Bar {
900           int aaaa;
901         };
902         template <typename T> struct Foo {
903           Bar func(int);
904           void test() {
905             func(1).[[aaaa]];
906           }
907         };
908       )cpp";
909   EXPECT_DECLS("CXXDependentScopeMemberExpr", "int aaaa");
910 
911   Code = R"cpp(
912         class Foo {
913         public:
914           static Foo k(int);
915           template <typename T> T convert() const;
916         };
917         template <typename T>
918         void test() {
919           Foo::k(T()).template [[convert]]<T>();
920         }
921       )cpp";
922   EXPECT_DECLS("CXXDependentScopeMemberExpr",
923                "template <typename T> T convert() const");
924 
925   Code = R"cpp(
926         template <typename T>
927         struct Waldo {
928           void find();
929         };
930         template <typename T>
931         using Wally = Waldo<T>;
932         template <typename T>
933         void foo(Wally<T> w) {
934           w.[[find]]();
935         }
936   )cpp";
937   EXPECT_DECLS("CXXDependentScopeMemberExpr", "void find()");
938 
939   Code = R"cpp(
940         template <typename T>
941         struct Waldo {
942           void find();
943         };
944         template <typename T>
945         struct MetaWaldo {
946           using Type = Waldo<T>;
947         };
948         template <typename T>
949         void foo(typename MetaWaldo<T>::Type w) {
950           w.[[find]]();
951         }
952   )cpp";
953   EXPECT_DECLS("CXXDependentScopeMemberExpr", "void find()");
954 
955   Code = R"cpp(
956         struct Waldo {
957           void find();
958         };
959         template <typename T>
960         using Wally = Waldo;
961         template <typename>
962         struct S : Wally<int> {
963           void Foo() { this->[[find]](); }
964         };
965   )cpp";
966   EXPECT_DECLS("MemberExpr", "void find()");
967 
968   // Base expression is the type of a non-type template parameter
969   // which is deduced using CTAD.
970   Code = R"cpp(
971         template <int N>
972         struct Waldo {
973           const int found = N;
974         };
975 
976         template <Waldo W>
977         int test() {
978           return W.[[found]];
979         }
980   )cpp";
981   EXPECT_DECLS("CXXDependentScopeMemberExpr", "const int found = N");
982 }
983 
984 TEST_F(TargetDeclTest, DependentTypes) {
985   // Heuristic resolution of dependent type name
986   Code = R"cpp(
987         template <typename>
988         struct A { struct B {}; };
989 
990         template <typename T>
991         void foo(typename A<T>::[[B]]);
992       )cpp";
993   EXPECT_DECLS("DependentNameTypeLoc", "struct B");
994 
995   // Heuristic resolution of dependent type name which doesn't get a TypeLoc
996   Code = R"cpp(
997         template <typename>
998         struct A { struct B { struct C {}; }; };
999 
1000         template <typename T>
1001         void foo(typename A<T>::[[B]]::C);
1002       )cpp";
1003   EXPECT_DECLS("NestedNameSpecifierLoc", "struct B");
1004 
1005   // Heuristic resolution of dependent type name whose qualifier is also
1006   // dependent
1007   Code = R"cpp(
1008         template <typename>
1009         struct A { struct B { struct C {}; }; };
1010 
1011         template <typename T>
1012         void foo(typename A<T>::B::[[C]]);
1013       )cpp";
1014   EXPECT_DECLS("DependentNameTypeLoc", "struct C");
1015 
1016   // Heuristic resolution of dependent template name
1017   Code = R"cpp(
1018         template <typename>
1019         struct A {
1020           template <typename> struct B {};
1021         };
1022 
1023         template <typename T>
1024         void foo(typename A<T>::template [[B]]<int>);
1025       )cpp";
1026   EXPECT_DECLS("DependentTemplateSpecializationTypeLoc",
1027                "template <typename> struct B");
1028 
1029   // Dependent name with recursive definition. We don't expect a
1030   // result, but we shouldn't get into a stack overflow either.
1031   Code = R"cpp(
1032         template <int N>
1033         struct waldo {
1034           typedef typename waldo<N - 1>::type::[[next]] type;
1035         };
1036   )cpp";
1037   EXPECT_DECLS("DependentNameTypeLoc", );
1038 
1039   // Similar to above but using mutually recursive templates.
1040   Code = R"cpp(
1041         template <int N>
1042         struct odd;
1043 
1044         template <int N>
1045         struct even {
1046           using type = typename odd<N - 1>::type::next;
1047         };
1048 
1049         template <int N>
1050         struct odd {
1051           using type = typename even<N - 1>::type::[[next]];
1052         };
1053   )cpp";
1054   EXPECT_DECLS("DependentNameTypeLoc", );
1055 }
1056 
1057 TEST_F(TargetDeclTest, TypedefCascade) {
1058   Code = R"cpp(
1059         struct C {
1060           using type = int;
1061         };
1062         struct B {
1063           using type = C::type;
1064         };
1065         struct A {
1066           using type = B::type;
1067         };
1068         A::[[type]] waldo;
1069   )cpp";
1070   EXPECT_DECLS("TypedefTypeLoc",
1071                {"using type = int", Rel::Alias | Rel::Underlying},
1072                {"using type = C::type", Rel::Alias | Rel::Underlying},
1073                {"using type = B::type", Rel::Alias});
1074 }
1075 
1076 TEST_F(TargetDeclTest, RecursiveTemplate) {
1077   Flags.push_back("-std=c++20"); // the test case uses concepts
1078 
1079   Code = R"cpp(
1080         template <typename T>
1081         concept Leaf = false;
1082 
1083         template <typename Tree>
1084         struct descend_left {
1085           using type = typename descend_left<typename Tree::left>::[[type]];
1086         };
1087 
1088         template <Leaf Tree>
1089         struct descend_left<Tree> {
1090           using type = typename Tree::value;
1091         };
1092   )cpp";
1093   EXPECT_DECLS("DependentNameTypeLoc",
1094                {"using type = typename descend_left<typename Tree::left>::type",
1095                 Rel::Alias | Rel::Underlying});
1096 }
1097 
1098 TEST_F(TargetDeclTest, ObjC) {
1099   Flags = {"-xobjective-c"};
1100   Code = R"cpp(
1101     @interface Foo {}
1102     -(void)bar;
1103     @end
1104     void test(Foo *f) {
1105       [f [[bar]] ];
1106     }
1107   )cpp";
1108   EXPECT_DECLS("ObjCMessageExpr", "- (void)bar");
1109 
1110   Code = R"cpp(
1111     @interface Foo { @public int bar; }
1112     @end
1113     int test(Foo *f) {
1114       return [[f->bar]];
1115     }
1116   )cpp";
1117   EXPECT_DECLS("ObjCIvarRefExpr", "int bar");
1118 
1119   Code = R"cpp(
1120     @interface Foo {}
1121     -(int) x;
1122     -(void) setX:(int)x;
1123     @end
1124     void test(Foo *f) {
1125       [[f.x]] = 42;
1126     }
1127   )cpp";
1128   EXPECT_DECLS("ObjCPropertyRefExpr", "- (void)setX:(int)x");
1129 
1130   Code = R"cpp(
1131     @interface I {}
1132     @property(retain) I* x;
1133     @property(retain) I* y;
1134     @end
1135     void test(I *f) {
1136       [[f.x]].y = 0;
1137     }
1138   )cpp";
1139   EXPECT_DECLS("ObjCPropertyRefExpr",
1140                "@property(atomic, retain, readwrite) I *x");
1141 
1142   Code = R"cpp(
1143     @interface MYObject
1144     @end
1145     @interface Interface
1146     @property(retain) [[MYObject]] *x;
1147     @end
1148   )cpp";
1149   EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface MYObject");
1150 
1151   Code = R"cpp(
1152     @interface MYObject2
1153     @end
1154     @interface Interface
1155     @property(retain, nonnull) [[MYObject2]] *x;
1156     @end
1157   )cpp";
1158   EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface MYObject2");
1159 
1160   Code = R"cpp(
1161     @protocol Foo
1162     @end
1163     id test() {
1164       return [[@protocol(Foo)]];
1165     }
1166   )cpp";
1167   EXPECT_DECLS("ObjCProtocolExpr", "@protocol Foo");
1168 
1169   Code = R"cpp(
1170     @interface Foo
1171     @end
1172     void test([[Foo]] *p);
1173   )cpp";
1174   EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface Foo");
1175 
1176   Code = R"cpp(// Don't consider implicit interface as the target.
1177     @implementation [[Implicit]]
1178     @end
1179   )cpp";
1180   EXPECT_DECLS("ObjCImplementationDecl", "@implementation Implicit");
1181 
1182   Code = R"cpp(
1183     @interface Foo
1184     @end
1185     @implementation [[Foo]]
1186     @end
1187   )cpp";
1188   EXPECT_DECLS("ObjCImplementationDecl", "@interface Foo");
1189 
1190   Code = R"cpp(
1191     @interface Foo
1192     @end
1193     @interface Foo (Ext)
1194     @end
1195     @implementation [[Foo]] (Ext)
1196     @end
1197   )cpp";
1198   EXPECT_DECLS("ObjCCategoryImplDecl", "@interface Foo(Ext)");
1199 
1200   Code = R"cpp(
1201     @interface Foo
1202     @end
1203     @interface Foo (Ext)
1204     @end
1205     @implementation Foo ([[Ext]])
1206     @end
1207   )cpp";
1208   EXPECT_DECLS("ObjCCategoryImplDecl", "@interface Foo(Ext)");
1209 
1210   Code = R"cpp(
1211     void test(id</*error-ok*/[[InvalidProtocol]]> p);
1212   )cpp";
1213   EXPECT_DECLS("ParmVarDecl", "id p");
1214 
1215   Code = R"cpp(
1216     @class C;
1217     @protocol Foo
1218     @end
1219     void test([[C]]<Foo> *p);
1220   )cpp";
1221   EXPECT_DECLS("ObjCInterfaceTypeLoc", "@class C;");
1222 
1223   Code = R"cpp(
1224     @class C;
1225     @protocol Foo
1226     @end
1227     void test(C<[[Foo]]> *p);
1228   )cpp";
1229   EXPECT_DECLS("ObjCProtocolLoc", "@protocol Foo");
1230 
1231   Code = R"cpp(
1232     @class C;
1233     @protocol Foo
1234     @end
1235     @protocol Bar
1236     @end
1237     void test(C<[[Foo]], Bar> *p);
1238   )cpp";
1239   EXPECT_DECLS("ObjCProtocolLoc", "@protocol Foo");
1240 
1241   Code = R"cpp(
1242     @class C;
1243     @protocol Foo
1244     @end
1245     @protocol Bar
1246     @end
1247     void test(C<Foo, [[Bar]]> *p);
1248   )cpp";
1249   EXPECT_DECLS("ObjCProtocolLoc", "@protocol Bar");
1250 
1251   Code = R"cpp(
1252     @interface Foo
1253     + (id)sharedInstance;
1254     @end
1255     @implementation Foo
1256     + (id)sharedInstance { return 0; }
1257     @end
1258     void test() {
1259       id value = [[Foo]].sharedInstance;
1260     }
1261   )cpp";
1262   EXPECT_DECLS("ObjCInterfaceTypeLoc", "@interface Foo");
1263 
1264   Code = R"cpp(
1265     @interface Foo
1266     + (id)sharedInstance;
1267     @end
1268     @implementation Foo
1269     + (id)sharedInstance { return 0; }
1270     @end
1271     void test() {
1272       id value = Foo.[[sharedInstance]];
1273     }
1274   )cpp";
1275   EXPECT_DECLS("ObjCPropertyRefExpr", "+ (id)sharedInstance");
1276 
1277   Code = R"cpp(
1278     @interface Foo
1279     + ([[id]])sharedInstance;
1280     @end
1281   )cpp";
1282   EXPECT_DECLS("TypedefTypeLoc", );
1283 
1284   Code = R"cpp(
1285     @interface Foo
1286     + ([[instancetype]])sharedInstance;
1287     @end
1288   )cpp";
1289   EXPECT_DECLS("TypedefTypeLoc", );
1290 }
1291 
1292 class FindExplicitReferencesTest : public ::testing::Test {
1293 protected:
1294   struct AllRefs {
1295     std::string AnnotatedCode;
1296     std::string DumpedReferences;
1297   };
1298 
1299   TestTU newTU(llvm::StringRef Code) {
1300     TestTU TU;
1301     TU.Code = std::string(Code);
1302 
1303     // FIXME: Auto-completion in a template requires disabling delayed template
1304     // parsing.
1305     TU.ExtraArgs.push_back("-std=c++20");
1306     TU.ExtraArgs.push_back("-xobjective-c++");
1307 
1308     return TU;
1309   }
1310 
1311   AllRefs annotatedReferences(llvm::StringRef Code, ParsedAST &AST,
1312                               std::vector<ReferenceLoc> Refs) {
1313     auto &SM = AST.getSourceManager();
1314     llvm::stable_sort(Refs, [&](const ReferenceLoc &L, const ReferenceLoc &R) {
1315       return SM.isBeforeInTranslationUnit(L.NameLoc, R.NameLoc);
1316     });
1317 
1318     std::string AnnotatedCode;
1319     unsigned NextCodeChar = 0;
1320     for (unsigned I = 0; I < Refs.size(); ++I) {
1321       auto &R = Refs[I];
1322 
1323       SourceLocation Pos = R.NameLoc;
1324       assert(Pos.isValid());
1325       if (Pos.isMacroID()) // FIXME: figure out how to show macro locations.
1326         Pos = SM.getExpansionLoc(Pos);
1327       assert(Pos.isFileID());
1328 
1329       FileID File;
1330       unsigned Offset;
1331       std::tie(File, Offset) = SM.getDecomposedLoc(Pos);
1332       if (File == SM.getMainFileID()) {
1333         // Print the reference in a source code.
1334         assert(NextCodeChar <= Offset);
1335         AnnotatedCode += Code.substr(NextCodeChar, Offset - NextCodeChar);
1336         AnnotatedCode += "$" + std::to_string(I) + "^";
1337 
1338         NextCodeChar = Offset;
1339       }
1340     }
1341     AnnotatedCode += Code.substr(NextCodeChar);
1342 
1343     std::string DumpedReferences;
1344     for (unsigned I = 0; I < Refs.size(); ++I)
1345       DumpedReferences += std::string(llvm::formatv("{0}: {1}\n", I, Refs[I]));
1346 
1347     return AllRefs{std::move(AnnotatedCode), std::move(DumpedReferences)};
1348   }
1349 
1350   /// Parses \p Code, and annotates its body with results of
1351   /// findExplicitReferences on all top level decls.
1352   /// See actual tests for examples of annotation format.
1353   AllRefs annotateAllReferences(llvm::StringRef Code) {
1354     TestTU TU = newTU(Code);
1355     auto AST = TU.build();
1356 
1357     std::vector<ReferenceLoc> Refs;
1358     for (auto *TopLevel : AST.getLocalTopLevelDecls())
1359       findExplicitReferences(
1360           TopLevel, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1361           AST.getHeuristicResolver());
1362     return annotatedReferences(Code, AST, std::move(Refs));
1363   }
1364 
1365   /// Parses \p Code, finds function or namespace '::foo' and annotates its body
1366   /// with results of findExplicitReferences.
1367   /// See actual tests for examples of annotation format.
1368   AllRefs annotateReferencesInFoo(llvm::StringRef Code) {
1369     TestTU TU = newTU(Code);
1370     auto AST = TU.build();
1371     auto *TestDecl = &findDecl(AST, "foo");
1372     if (auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
1373       TestDecl = T->getTemplatedDecl();
1374 
1375     std::vector<ReferenceLoc> Refs;
1376     if (const auto *Func = llvm::dyn_cast<FunctionDecl>(TestDecl))
1377       findExplicitReferences(
1378           Func->getBody(),
1379           [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1380           AST.getHeuristicResolver());
1381     else if (const auto *NS = llvm::dyn_cast<NamespaceDecl>(TestDecl))
1382       findExplicitReferences(
1383           NS,
1384           [&Refs, &NS](ReferenceLoc R) {
1385             // Avoid adding the namespace foo decl to the results.
1386             if (R.Targets.size() == 1 && R.Targets.front() == NS)
1387               return;
1388             Refs.push_back(std::move(R));
1389           },
1390           AST.getHeuristicResolver());
1391     else if (const auto *OC = llvm::dyn_cast<ObjCContainerDecl>(TestDecl))
1392       findExplicitReferences(
1393           OC, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1394           AST.getHeuristicResolver());
1395     else
1396       ADD_FAILURE() << "Failed to find ::foo decl for test";
1397 
1398     return annotatedReferences(Code, AST, std::move(Refs));
1399   }
1400 };
1401 
1402 TEST_F(FindExplicitReferencesTest, AllRefsInFoo) {
1403   std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
1404       {// Simple expressions.
1405        {R"cpp(
1406         int global;
1407         int func();
1408         void foo(int param) {
1409           $0^global = $1^param + $2^func();
1410         }
1411         )cpp",
1412         "0: targets = {global}\n"
1413         "1: targets = {param}\n"
1414         "2: targets = {func}\n"},
1415        {R"cpp(
1416         struct X { int a; };
1417         void foo(X x) {
1418           $0^x.$1^a = 10;
1419         }
1420         )cpp",
1421         "0: targets = {x}\n"
1422         "1: targets = {X::a}\n"},
1423        {R"cpp(
1424         // error-ok: testing with broken code
1425         int bar();
1426         int foo() {
1427           return $0^bar() + $1^bar(42);
1428         }
1429         )cpp",
1430         "0: targets = {bar}\n"
1431         "1: targets = {bar}\n"},
1432        // Namespaces and aliases.
1433        {R"cpp(
1434           namespace ns {}
1435           namespace alias = ns;
1436           void foo() {
1437             using namespace $0^ns;
1438             using namespace $1^alias;
1439           }
1440         )cpp",
1441         "0: targets = {ns}\n"
1442         "1: targets = {alias}\n"},
1443        // Using declarations.
1444        {R"cpp(
1445           namespace ns { int global; }
1446           void foo() {
1447             using $0^ns::$1^global;
1448           }
1449         )cpp",
1450         "0: targets = {ns}\n"
1451         "1: targets = {ns::global}, qualifier = 'ns::'\n"},
1452        // Using enum declarations.
1453        {R"cpp(
1454           namespace ns { enum class A {}; }
1455           void foo() {
1456             using enum $0^ns::$1^A;
1457           }
1458         )cpp",
1459         "0: targets = {ns}\n"
1460         "1: targets = {ns::A}, qualifier = 'ns::'\n"},
1461        // Simple types.
1462        {R"cpp(
1463          struct Struct { int a; };
1464          using Typedef = int;
1465          void foo() {
1466            $0^Struct $1^x;
1467            $2^Typedef $3^y;
1468            static_cast<$4^Struct*>(0);
1469          }
1470        )cpp",
1471         "0: targets = {Struct}\n"
1472         "1: targets = {x}, decl\n"
1473         "2: targets = {Typedef}\n"
1474         "3: targets = {y}, decl\n"
1475         "4: targets = {Struct}\n"},
1476        // Name qualifiers.
1477        {R"cpp(
1478          namespace a { namespace b { struct S { typedef int type; }; } }
1479          void foo() {
1480            $0^a::$1^b::$2^S $3^x;
1481            using namespace $4^a::$5^b;
1482            $6^S::$7^type $8^y;
1483          }
1484         )cpp",
1485         "0: targets = {a}\n"
1486         "1: targets = {a::b}, qualifier = 'a::'\n"
1487         "2: targets = {a::b::S}, qualifier = 'a::b::'\n"
1488         "3: targets = {x}, decl\n"
1489         "4: targets = {a}\n"
1490         "5: targets = {a::b}, qualifier = 'a::'\n"
1491         "6: targets = {a::b::S}\n"
1492         "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
1493         "8: targets = {y}, decl\n"},
1494        {R"cpp(
1495          void foo() {
1496            $0^ten: // PRINT "HELLO WORLD!"
1497            goto $1^ten;
1498          }
1499        )cpp",
1500         "0: targets = {ten}, decl\n"
1501         "1: targets = {ten}\n"},
1502        // Simple templates.
1503        {R"cpp(
1504           template <class T> struct vector { using value_type = T; };
1505           template <> struct vector<bool> { using value_type = bool; };
1506           void foo() {
1507             $0^vector<int> $1^vi;
1508             $2^vector<bool> $3^vb;
1509           }
1510         )cpp",
1511         "0: targets = {vector<int>}\n"
1512         "1: targets = {vi}, decl\n"
1513         "2: targets = {vector<bool>}\n"
1514         "3: targets = {vb}, decl\n"},
1515        // Template type aliases.
1516        {R"cpp(
1517             template <class T> struct vector { using value_type = T; };
1518             template <> struct vector<bool> { using value_type = bool; };
1519             template <class T> using valias = vector<T>;
1520             void foo() {
1521               $0^valias<int> $1^vi;
1522               $2^valias<bool> $3^vb;
1523             }
1524           )cpp",
1525         "0: targets = {valias}\n"
1526         "1: targets = {vi}, decl\n"
1527         "2: targets = {valias}\n"
1528         "3: targets = {vb}, decl\n"},
1529        // Injected class name.
1530        {R"cpp(
1531             namespace foo {
1532               template <typename $0^T>
1533               class $1^Bar {
1534                 ~$2^Bar();
1535                 void $3^f($4^Bar);
1536               };
1537             }
1538           )cpp",
1539         "0: targets = {foo::Bar::T}, decl\n"
1540         "1: targets = {foo::Bar}, decl\n"
1541         "2: targets = {foo::Bar}\n"
1542         "3: targets = {foo::Bar::f}, decl\n"
1543         "4: targets = {foo::Bar}\n"},
1544        // MemberExpr should know their using declaration.
1545        {R"cpp(
1546             struct X { void func(int); };
1547             struct Y : X {
1548               using X::func;
1549             };
1550             void foo(Y y) {
1551               $0^y.$1^func(1);
1552             }
1553         )cpp",
1554         "0: targets = {y}\n"
1555         "1: targets = {Y::func}\n"},
1556        // DeclRefExpr should know their using declaration.
1557        {R"cpp(
1558             namespace ns { void bar(int); }
1559             using ns::bar;
1560 
1561             void foo() {
1562               $0^bar(10);
1563             }
1564         )cpp",
1565         "0: targets = {bar}\n"},
1566        // References from a macro.
1567        {R"cpp(
1568             #define FOO a
1569             #define BAR b
1570 
1571             void foo(int a, int b) {
1572               $0^FOO+$1^BAR;
1573             }
1574         )cpp",
1575         "0: targets = {a}\n"
1576         "1: targets = {b}\n"},
1577        // No references from implicit nodes.
1578        {R"cpp(
1579             struct vector {
1580               int *begin();
1581               int *end();
1582             };
1583 
1584             void foo() {
1585               for (int $0^x : $1^vector()) {
1586                 $2^x = 10;
1587               }
1588             }
1589         )cpp",
1590         "0: targets = {x}, decl\n"
1591         "1: targets = {vector}\n"
1592         "2: targets = {x}\n"},
1593        // Handle UnresolvedLookupExpr.
1594        {R"cpp(
1595             namespace ns1 { void func(char*); }
1596             namespace ns2 { void func(int*); }
1597             using namespace ns1;
1598             using namespace ns2;
1599 
1600             template <class T>
1601             void foo(T t) {
1602               $0^func($1^t);
1603             }
1604         )cpp",
1605         "0: targets = {ns1::func, ns2::func}\n"
1606         "1: targets = {t}\n"},
1607        // Handle UnresolvedMemberExpr.
1608        {R"cpp(
1609             struct X {
1610               void func(char*);
1611               void func(int*);
1612             };
1613 
1614             template <class T>
1615             void foo(X x, T t) {
1616               $0^x.$1^func($2^t);
1617             }
1618         )cpp",
1619         "0: targets = {x}\n"
1620         "1: targets = {X::func, X::func}\n"
1621         "2: targets = {t}\n"},
1622        // Handle DependentScopeDeclRefExpr.
1623        {R"cpp(
1624             template <class T>
1625             struct S {
1626               static int value;
1627             };
1628 
1629             template <class T>
1630             void foo() {
1631               $0^S<$1^T>::$2^value;
1632             }
1633        )cpp",
1634         "0: targets = {S}\n"
1635         "1: targets = {T}\n"
1636         "2: targets = {S::value}, qualifier = 'S<T>::'\n"},
1637        // Handle CXXDependentScopeMemberExpr.
1638        {R"cpp(
1639             template <class T>
1640             struct S {
1641               int value;
1642             };
1643 
1644             template <class T>
1645             void foo(S<T> t) {
1646               $0^t.$1^value;
1647             }
1648        )cpp",
1649         "0: targets = {t}\n"
1650         "1: targets = {S::value}\n"},
1651        // Type template parameters.
1652        {R"cpp(
1653             template <class T>
1654             void foo() {
1655               static_cast<$0^T>(0);
1656               $1^T();
1657               $2^T $3^t;
1658             }
1659         )cpp",
1660         "0: targets = {T}\n"
1661         "1: targets = {T}\n"
1662         "2: targets = {T}\n"
1663         "3: targets = {t}, decl\n"},
1664        // Non-type template parameters.
1665        {R"cpp(
1666             template <int I>
1667             void foo() {
1668               int $0^x = $1^I;
1669             }
1670         )cpp",
1671         "0: targets = {x}, decl\n"
1672         "1: targets = {I}\n"},
1673        // Template template parameters.
1674        {R"cpp(
1675             template <class T> struct vector {};
1676 
1677             template <template<class> class TT, template<class> class ...TP>
1678             void foo() {
1679               $0^TT<int> $1^x;
1680               $2^foo<$3^TT>();
1681               $4^foo<$5^vector>();
1682               $6^foo<$7^TP...>();
1683             }
1684         )cpp",
1685         "0: targets = {TT}\n"
1686         "1: targets = {x}, decl\n"
1687         "2: targets = {foo}\n"
1688         "3: targets = {TT}\n"
1689         "4: targets = {foo}\n"
1690         "5: targets = {vector}\n"
1691         "6: targets = {foo}\n"
1692         "7: targets = {TP}\n"},
1693        // Non-type template parameters with declarations.
1694        {R"cpp(
1695             int func();
1696             template <int(*)()> struct wrapper {};
1697 
1698             template <int(*FuncParam)()>
1699             void foo() {
1700               $0^wrapper<$1^func> $2^w;
1701               $3^FuncParam();
1702             }
1703         )cpp",
1704         "0: targets = {wrapper<&func>}\n"
1705         "1: targets = {func}\n"
1706         "2: targets = {w}, decl\n"
1707         "3: targets = {FuncParam}\n"},
1708        // declaration references.
1709        {R"cpp(
1710              namespace ns {}
1711              class S {};
1712              void foo() {
1713                class $0^Foo { $1^Foo(); ~$2^Foo(); int $3^field; };
1714                int $4^Var;
1715                enum $5^E { $6^ABC };
1716                typedef int $7^INT;
1717                using $8^INT2 = int;
1718                namespace $9^NS = $10^ns;
1719              }
1720            )cpp",
1721         "0: targets = {Foo}, decl\n"
1722         "1: targets = {foo()::Foo::Foo}, decl\n"
1723         "2: targets = {Foo}\n"
1724         "3: targets = {foo()::Foo::field}, decl\n"
1725         "4: targets = {Var}, decl\n"
1726         "5: targets = {E}, decl\n"
1727         "6: targets = {foo()::ABC}, decl\n"
1728         "7: targets = {INT}, decl\n"
1729         "8: targets = {INT2}, decl\n"
1730         "9: targets = {NS}, decl\n"
1731         "10: targets = {ns}\n"},
1732        // User-defined conversion operator.
1733        {R"cpp(
1734             void foo() {
1735                class $0^Bar {};
1736                class $1^Foo {
1737                public:
1738                  // FIXME: This should have only one reference to Bar.
1739                  $2^operator $3^$4^Bar();
1740                };
1741 
1742                $5^Foo $6^f;
1743                $7^f.$8^operator $9^Bar();
1744             }
1745         )cpp",
1746         "0: targets = {Bar}, decl\n"
1747         "1: targets = {Foo}, decl\n"
1748         "2: targets = {foo()::Foo::operator Bar}, decl\n"
1749         "3: targets = {Bar}\n"
1750         "4: targets = {Bar}\n"
1751         "5: targets = {Foo}\n"
1752         "6: targets = {f}, decl\n"
1753         "7: targets = {f}\n"
1754         "8: targets = {foo()::Foo::operator Bar}\n"
1755         "9: targets = {Bar}\n"},
1756        // Destructor.
1757        {R"cpp(
1758              void foo() {
1759                class $0^Foo {
1760                public:
1761                  ~$1^Foo() {}
1762 
1763                  void $2^destructMe() {
1764                    this->~$3^Foo();
1765                  }
1766                };
1767 
1768                $4^Foo $5^f;
1769                $6^f.~ /*...*/ $7^Foo();
1770              }
1771            )cpp",
1772         "0: targets = {Foo}, decl\n"
1773         // FIXME: It's better to target destructor's FunctionDecl instead of
1774         // the type itself (similar to constructor).
1775         "1: targets = {Foo}\n"
1776         "2: targets = {foo()::Foo::destructMe}, decl\n"
1777         "3: targets = {Foo}\n"
1778         "4: targets = {Foo}\n"
1779         "5: targets = {f}, decl\n"
1780         "6: targets = {f}\n"
1781         "7: targets = {Foo}\n"},
1782        // cxx constructor initializer.
1783        {R"cpp(
1784              class Base {};
1785              void foo() {
1786                // member initializer
1787                class $0^X {
1788                  int $1^abc;
1789                  $2^X(): $3^abc() {}
1790                };
1791                // base initializer
1792                class $4^Derived : public $5^Base {
1793                  $6^Base $7^B;
1794                  $8^Derived() : $9^Base() {}
1795                };
1796                // delegating initializer
1797                class $10^Foo {
1798                  $11^Foo(int);
1799                  $12^Foo(): $13^Foo(111) {}
1800                };
1801              }
1802            )cpp",
1803         "0: targets = {X}, decl\n"
1804         "1: targets = {foo()::X::abc}, decl\n"
1805         "2: targets = {foo()::X::X}, decl\n"
1806         "3: targets = {foo()::X::abc}\n"
1807         "4: targets = {Derived}, decl\n"
1808         "5: targets = {Base}\n"
1809         "6: targets = {Base}\n"
1810         "7: targets = {foo()::Derived::B}, decl\n"
1811         "8: targets = {foo()::Derived::Derived}, decl\n"
1812         "9: targets = {Base}\n"
1813         "10: targets = {Foo}, decl\n"
1814         "11: targets = {foo()::Foo::Foo}, decl\n"
1815         "12: targets = {foo()::Foo::Foo}, decl\n"
1816         "13: targets = {Foo}\n"},
1817        // Anonymous entities should not be reported.
1818        {
1819            R"cpp(
1820              void foo() {
1821               $0^class {} $1^x;
1822               int (*$2^fptr)(int $3^a, int) = nullptr;
1823              }
1824            )cpp",
1825            "0: targets = {(unnamed)}\n"
1826            "1: targets = {x}, decl\n"
1827            "2: targets = {fptr}, decl\n"
1828            "3: targets = {a}, decl\n"},
1829        // Namespace aliases should be handled properly.
1830        {
1831            R"cpp(
1832                 namespace ns { struct Type {}; }
1833                 namespace alias = ns;
1834                 namespace rec_alias = alias;
1835 
1836                 void foo() {
1837                   $0^ns::$1^Type $2^a;
1838                   $3^alias::$4^Type $5^b;
1839                   $6^rec_alias::$7^Type $8^c;
1840                 }
1841            )cpp",
1842            "0: targets = {ns}\n"
1843            "1: targets = {ns::Type}, qualifier = 'ns::'\n"
1844            "2: targets = {a}, decl\n"
1845            "3: targets = {alias}\n"
1846            "4: targets = {ns::Type}, qualifier = 'alias::'\n"
1847            "5: targets = {b}, decl\n"
1848            "6: targets = {rec_alias}\n"
1849            "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n"
1850            "8: targets = {c}, decl\n"},
1851        // Handle SizeOfPackExpr.
1852        {
1853            R"cpp(
1854                 template <typename... E>
1855                 void foo() {
1856                   constexpr int $0^size = sizeof...($1^E);
1857                 };
1858             )cpp",
1859            "0: targets = {size}, decl\n"
1860            "1: targets = {E}\n"},
1861        // Class template argument deduction
1862        {
1863            R"cpp(
1864                 template <typename T>
1865                 struct Test {
1866                 Test(T);
1867               };
1868               void foo() {
1869                 $0^Test $1^a(5);
1870               }
1871             )cpp",
1872            "0: targets = {Test}\n"
1873            "1: targets = {a}, decl\n"},
1874        // Templates
1875        {R"cpp(
1876             namespace foo {
1877               template <typename $0^T>
1878               class $1^Bar {};
1879             }
1880           )cpp",
1881         "0: targets = {foo::Bar::T}, decl\n"
1882         "1: targets = {foo::Bar}, decl\n"},
1883        // Templates
1884        {R"cpp(
1885             namespace foo {
1886               template <typename $0^T>
1887               void $1^func();
1888             }
1889           )cpp",
1890         "0: targets = {T}, decl\n"
1891         "1: targets = {foo::func}, decl\n"},
1892        // Templates
1893        {R"cpp(
1894             namespace foo {
1895               template <typename $0^T>
1896               $1^T $2^x;
1897             }
1898           )cpp",
1899         "0: targets = {foo::T}, decl\n"
1900         "1: targets = {foo::T}\n"
1901         "2: targets = {foo::x}, decl\n"},
1902        // Templates
1903        {R"cpp(
1904             template<typename T> class vector {};
1905             namespace foo {
1906               template <typename $0^T>
1907               using $1^V = $2^vector<$3^T>;
1908             }
1909           )cpp",
1910         "0: targets = {foo::T}, decl\n"
1911         "1: targets = {foo::V}, decl\n"
1912         "2: targets = {vector}\n"
1913         "3: targets = {foo::T}\n"},
1914        // Concept
1915        {
1916            R"cpp(
1917               template <typename T>
1918               concept Drawable = requires (T t) { t.draw(); };
1919 
1920               namespace foo {
1921                 template <typename $0^T> requires $1^Drawable<$2^T>
1922                 void $3^bar($4^T $5^t) {
1923                   $6^t.$7^draw();
1924                 }
1925               }
1926           )cpp",
1927            "0: targets = {T}, decl\n"
1928            "1: targets = {Drawable}\n"
1929            "2: targets = {T}\n"
1930            "3: targets = {foo::bar}, decl\n"
1931            "4: targets = {T}\n"
1932            "5: targets = {t}, decl\n"
1933            "6: targets = {t}\n"
1934            "7: targets = {}\n"},
1935        // Objective-C: instance variables
1936        {
1937            R"cpp(
1938             @interface I {
1939             @public
1940               I *_z;
1941             }
1942             @end
1943             I *f;
1944             void foo() {
1945               $0^f->$1^_z = 0;
1946             }
1947           )cpp",
1948            "0: targets = {f}\n"
1949            "1: targets = {I::_z}\n"},
1950        // Objective-C: properties
1951        {
1952            R"cpp(
1953             @interface I {}
1954             @property(retain) I* x;
1955             @property(retain) I* y;
1956             @end
1957             I *f;
1958             void foo() {
1959               $0^f.$1^x.$2^y = 0;
1960             }
1961           )cpp",
1962            "0: targets = {f}\n"
1963            "1: targets = {I::x}\n"
1964            "2: targets = {I::y}\n"},
1965        // Objective-C: implicit properties
1966        {
1967            R"cpp(
1968             @interface I {}
1969             -(I*)x;
1970             -(void)setY:(I*)y;
1971             @end
1972             I *f;
1973             void foo() {
1974               $0^f.$1^x.$2^y = 0;
1975             }
1976           )cpp",
1977            "0: targets = {f}\n"
1978            "1: targets = {I::x}\n"
1979            "2: targets = {I::setY:}\n"},
1980        // Objective-C: class properties
1981        {
1982            R"cpp(
1983             @interface I {}
1984             @property(class) I *x;
1985             @end
1986             id local;
1987             void foo() {
1988               $0^I.$1^x = 0;
1989               $2^local = $3^I.$4^x;
1990             }
1991           )cpp",
1992            "0: targets = {I}\n"
1993            "1: targets = {I::setX:}\n"
1994            "2: targets = {local}\n"
1995            "3: targets = {I}\n"
1996            "4: targets = {I::x}\n"},
1997        // Objective-C: implicit class properties
1998        {
1999            R"cpp(
2000             @interface I {}
2001             +(I*)x;
2002             +(void)setX:(I*)x;
2003             @end
2004             id local;
2005             void foo() {
2006               $0^I.$1^x = 0;
2007               $2^local = $3^I.$4^x;
2008             }
2009           )cpp",
2010            "0: targets = {I}\n"
2011            "1: targets = {I::setX:}\n"
2012            "2: targets = {local}\n"
2013            "3: targets = {I}\n"
2014            "4: targets = {I::x}\n"},
2015        {// Objective-C: methods
2016         R"cpp(
2017             @interface I
2018               -(void) a:(int)x b:(int)y;
2019             @end
2020             void foo(I *i) {
2021               [$0^i $1^a:1 b:2];
2022             }
2023           )cpp",
2024         "0: targets = {i}\n"
2025         "1: targets = {I::a:b:}\n"},
2026        {// Objective-C: protocols
2027         R"cpp(
2028             @interface I
2029             @end
2030             @protocol P
2031             @end
2032             void foo() {
2033               $0^I<$1^P> *$2^x;
2034             }
2035           )cpp",
2036         "0: targets = {I}\n"
2037         "1: targets = {P}\n"
2038         "2: targets = {x}, decl\n"},
2039 
2040        // Designated initializers.
2041        {R"cpp(
2042             void foo() {
2043               struct $0^Foo {
2044                 int $1^Bar;
2045               };
2046               $2^Foo $3^f { .$4^Bar = 42 };
2047             }
2048         )cpp",
2049         "0: targets = {Foo}, decl\n"
2050         "1: targets = {foo()::Foo::Bar}, decl\n"
2051         "2: targets = {Foo}\n"
2052         "3: targets = {f}, decl\n"
2053         "4: targets = {foo()::Foo::Bar}\n"},
2054        {R"cpp(
2055             void foo() {
2056               struct $0^Baz {
2057                 int $1^Field;
2058               };
2059               struct $2^Bar {
2060                 $3^Baz $4^Foo;
2061               };
2062               $5^Bar $6^bar { .$7^Foo.$8^Field = 42 };
2063             }
2064         )cpp",
2065         "0: targets = {Baz}, decl\n"
2066         "1: targets = {foo()::Baz::Field}, decl\n"
2067         "2: targets = {Bar}, decl\n"
2068         "3: targets = {Baz}\n"
2069         "4: targets = {foo()::Bar::Foo}, decl\n"
2070         "5: targets = {Bar}\n"
2071         "6: targets = {bar}, decl\n"
2072         "7: targets = {foo()::Bar::Foo}\n"
2073         "8: targets = {foo()::Baz::Field}\n"},
2074        {R"cpp(
2075            template<typename T>
2076            void crash(T);
2077            template<typename T>
2078            void foo() {
2079              $0^crash({.$1^x = $2^T()});
2080            }
2081         )cpp",
2082         "0: targets = {crash}\n"
2083         "1: targets = {}\n"
2084         "2: targets = {T}\n"},
2085        // unknown template name should not crash.
2086        {R"cpp(
2087         template <template <typename> typename T>
2088         struct Base {};
2089         namespace foo {
2090         template <typename $0^T>
2091         struct $1^Derive : $2^Base<$3^T::template $4^Unknown> {};
2092         }
2093       )cpp",
2094         "0: targets = {foo::Derive::T}, decl\n"
2095         "1: targets = {foo::Derive}, decl\n"
2096         "2: targets = {Base}\n"
2097         "3: targets = {foo::Derive::T}\n"
2098         "4: targets = {}, qualifier = 'T::'\n"},
2099        // deduction guide
2100        {R"cpp(
2101           namespace foo {
2102             template <typename $0^T>
2103             struct $1^Test {
2104               template <typename $2^I>
2105               $3^Test($4^I);
2106             };
2107             template <typename $5^I>
2108             $6^Test($7^I) -> $8^Test<typename $9^I::$10^type>;
2109           }
2110         )cpp",
2111         "0: targets = {T}, decl\n"
2112         "1: targets = {foo::Test}, decl\n"
2113         "2: targets = {I}, decl\n"
2114         "3: targets = {foo::Test::Test<T>}, decl\n"
2115         "4: targets = {I}\n"
2116         "5: targets = {I}, decl\n"
2117         "6: targets = {foo::Test}\n"
2118         "7: targets = {I}\n"
2119         "8: targets = {foo::Test}\n"
2120         "9: targets = {I}\n"
2121         "10: targets = {}, qualifier = 'I::'\n"}};
2122 
2123   for (const auto &C : Cases) {
2124     llvm::StringRef ExpectedCode = C.first;
2125     llvm::StringRef ExpectedRefs = C.second;
2126 
2127     auto Actual =
2128         annotateReferencesInFoo(llvm::Annotations(ExpectedCode).code());
2129     EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
2130     EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
2131   }
2132 }
2133 
2134 TEST_F(FindExplicitReferencesTest, AllRefs) {
2135   std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
2136       {{R"cpp(
2137       @interface $0^MyClass
2138       @end
2139       @implementation $1^$2^MyClass
2140       @end
2141       )cpp",
2142         "0: targets = {MyClass}, decl\n"
2143         "1: targets = {MyClass}\n"
2144         "2: targets = {MyClass}, decl\n"},
2145        {R"cpp(
2146       @interface $0^MyClass
2147       @end
2148       @interface $1^MyClass ($2^Category)
2149       @end
2150       @implementation $3^MyClass ($4^$5^Category)
2151       @end
2152       )cpp",
2153         "0: targets = {MyClass}, decl\n"
2154         "1: targets = {MyClass}\n"
2155         "2: targets = {Category}, decl\n"
2156         "3: targets = {MyClass}\n"
2157         "4: targets = {Category}\n"
2158         "5: targets = {Category}, decl\n"}};
2159 
2160   for (const auto &C : Cases) {
2161     llvm::StringRef ExpectedCode = C.first;
2162     llvm::StringRef ExpectedRefs = C.second;
2163 
2164     auto Actual = annotateAllReferences(llvm::Annotations(ExpectedCode).code());
2165     EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
2166     EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
2167   }
2168 }
2169 
2170 } // namespace
2171 } // namespace clangd
2172 } // namespace clang
2173