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>
35 PrintedDecl(
const char *Name, DeclRelationSet Relations = {})
36 :
Name(Name), Relations(Relations) {}
37 PrintedDecl(
const NamedDecl *D, DeclRelationSet Relations = {})
38 : Relations(Relations) {
40 llvm::raw_string_ostream
OS(S);
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(
" {"));
49 DeclRelationSet Relations;
51bool operator==(
const PrintedDecl &L,
const PrintedDecl &R) {
52 return std::tie(L.Name, L.Relations) == std::tie(R.Name, R.Relations);
54llvm::raw_ostream &
operator<<(llvm::raw_ostream &
OS,
const PrintedDecl &D) {
55 return OS << D.Name <<
" Rel=" << D.Relations;
64class TargetDeclTest :
public ::testing::Test {
73 std::vector<PrintedDecl> assertNodeAndPrintDecls(
const char *NodeType) {
74 llvm::Annotations A(
Code);
77 auto AST = TU.build();
78 llvm::Annotations::Range R = A.range();
80 AST.getASTContext(),
AST.getTokens(), R.Begin, R.End);
81 const SelectionTree::Node *N = Selection.commonAncestor();
83 ADD_FAILURE() <<
"No node selected!\n" <<
Code;
86 EXPECT_EQ(N->kind(), NodeType) << Selection;
88 std::vector<PrintedDecl> ActualDecls;
89 for (
const auto &
Entry :
91 ActualDecls.emplace_back(
Entry.first,
Entry.second);
98#define EXPECT_DECLS(NodeType, ...) \
99 EXPECT_THAT(assertNodeAndPrintDecls(NodeType), \
100 ::testing::UnorderedElementsAreArray( \
101 std::vector<PrintedDecl>({__VA_ARGS__}))) \
103using ExpectedDecls = std::vector<PrintedDecl>;
105TEST_F(TargetDeclTest, Exprs) {
113 struct S { S operator+(S) const; };
114 auto X = S() [[+]] S();
126 void operator()(int n);
133 EXPECT_DECLS("CXXOperatorCallExpr",
"void operator()(int n)");
152TEST_F(TargetDeclTest, RecoveryForC) {
153 Flags = {
"-xc",
"-Xclang",
"-frecovery-ast"};
155 // error-ok: testing behavior on broken code
163TEST_F(TargetDeclTest, Recovery) {
165 // error-ok: testing behavior on broken code
170 EXPECT_DECLS("UnresolvedLookupExpr",
"int f()",
"int f(int, int)");
173TEST_F(TargetDeclTest, RecoveryType) {
175 // error-ok: testing behavior on broken code
176 struct S { int member; };
179 // No overload matches, but we have recovery-expr with the correct type.
180 overloaded().[[member]];
186TEST_F(TargetDeclTest, UsingDecl) {
196 EXPECT_DECLS(
"DeclRefExpr", {
"using foo::f", Rel::Alias}, {
"int f(int)"});
206 EXPECT_DECLS(
"UsingDecl", {
"using foo::f", Rel::Alias}, {
"int f(int)"},
216 int x = Y().[[foo]]();
218 EXPECT_DECLS("MemberExpr", {
"using X::foo", Rel::Alias}, {
"int foo()"});
221 template <typename T>
225 template <typename T>
226 struct Derived : Base<T> {
227 using Base<T>::[[waldo]];
230 EXPECT_DECLS("UnresolvedUsingValueDecl", {
"using Base<T>::waldo", Rel::Alias},
235 template<typename T> class S {};
243 EXPECT_DECLS("TemplateSpecializationTypeLoc", {
"using ns::S", Rel::Alias},
244 {
"template <typename T> class S"},
245 {
"class S", Rel::TemplatePattern});
249 template<typename T> class S {};
253 template <template <typename> class T> class X {};
256 EXPECT_DECLS("TemplateArgumentLoc", {
"using ns::S", Rel::Alias},
257 {
"template <typename T> class S"});
261 template<typename T> class S { public: S(T); };
267 Flags.push_back("-std=c++17");
269 {
"using ns::S", Rel::Alias}, {
"template <typename T> class S"},
270 {
"class S", Rel::TemplatePattern});
274 class Foo { public: class foo {}; };
275 template <class T> class A : public Foo<T> {
276 using typename Foo<T>::foo;
281 {
"using typename Foo<T>::foo", Rel::Alias});
284 Flags.push_back(
"-std=c++20");
286 namespace ns { enum class A { X }; }
287 [[using enum ns::A]];
292 namespace ns { enum class A { X }; }
299TEST_F(TargetDeclTest, BaseSpecifier) {
302 struct Y : [[private]] X {};
307 struct Y : [[private X]] {};
312 struct Y : private [[X]] {};
317TEST_F(TargetDeclTest, ConstructorInitList) {
335TEST_F(TargetDeclTest, DesignatedInit) {
339 struct Y { int b; struct X c[2]; };
340 struct Y y = { .c[0].[[a]] = 1 };
345TEST_F(TargetDeclTest, NestedNameSpecifier) {
347 namespace a { namespace b { int c; } }
353 namespace a { struct X { enum { y }; }; }
359 template <typename T>
365 namespace a { int x; }
369 EXPECT_DECLS("NestedNameSpecifierLoc", {
"namespace b = a", Rel::Alias},
370 {
"namespace a", Rel::Underlying});
373TEST_F(TargetDeclTest, Types) {
385 EXPECT_DECLS("TypedefTypeLoc", {
"typedef S X", Rel::Alias},
386 {
"struct S", Rel::Underlying});
388 namespace ns { struct S{}; }
392 EXPECT_DECLS("TypedefTypeLoc", {
"typedef ns::S X", Rel::Alias},
393 {
"struct S", Rel::Underlying});
397 void foo() { [[T]] x; }
403 template<template<typename> class T>
404 void foo() { [[T<int>]] x; }
406 EXPECT_DECLS("TemplateSpecializationTypeLoc",
"template <typename> class T");
410 template<template<typename> class ...T>
415 EXPECT_DECLS("TemplateArgumentLoc", {
"template <typename> class ...T"});
423 EXPECT_DECLS("DecltypeTypeLoc", {
"struct S", Rel::Underlying});
433 template <typename... E>
435 static const int size = sizeof...([[E]]);
441 template <typename T>
449TEST_F(TargetDeclTest, ClassTemplate) {
451 // Implicit specialization.
452 template<int x> class Foo{};
456 {
"template<> class Foo<42>", Rel::TemplateInstantiation},
457 {
"class Foo", Rel::TemplatePattern});
460 template<typename T> class Foo {};
461 // The "Foo<int>" SpecializationDecl is incomplete, there is no
462 // instantiation happening.
463 void func([[Foo<int>]] *);
466 {
"class Foo", Rel::TemplatePattern},
467 {
"template<> class Foo<int>", Rel::TemplateInstantiation});
470 // Explicit specialization.
471 template<int x> class Foo{};
472 template<> class Foo<42>{};
475 EXPECT_DECLS("TemplateSpecializationTypeLoc",
"template<> class Foo<42>");
478 // Partial specialization.
479 template<typename T> class Foo{};
480 template<typename T> class Foo<T*>{};
484 {
"template<> class Foo<int *>", Rel::TemplateInstantiation},
485 {
"template <typename T> class Foo<T *>", Rel::TemplatePattern});
488 // Template template argument.
489 template<typename T> struct Vector {};
490 template <template <typename> class Container>
494 EXPECT_DECLS("TemplateArgumentLoc", {
"template <typename T> struct Vector"});
496 Flags.push_back(
"-std=c++17");
499 // Class template argument deduction
500 template <typename T>
509 {
"struct Test", Rel::TemplatePattern});
513 template <typename T>
515 template <typename I>
518 template <typename I>
519 [[Test]](I, I) -> Test<typename I::type>;
521 EXPECT_DECLS("CXXDeductionGuideDecl", {
"template <typename T> struct Test"});
525 Flags.push_back(
"-std=c++20");
531 template <typename T>
532 concept Fooable = requires (T t) { t.foo(); };
534 template <typename T> requires [[Fooable]]<T>
541 {
"template <typename T> concept Fooable = requires (T t) { t.foo(); }"});
545 template <typename T>
546 concept Fooable = true;
548 template <typename T>
549 void foo() requires [[Fooable]]<T>;
552 {
"template <typename T> concept Fooable = true"});
556 template <typename T>
557 concept Fooable = true;
559 template <[[Fooable]] T>
563 {
"template <typename T> concept Fooable = true"});
567 template <typename T, typename U>
568 concept Fooable = true;
570 template <[[Fooable]]<int> T>
574 {
"template <typename T, typename U> concept Fooable = true"});
577TEST_F(TargetDeclTest, Coroutine) {
578 Flags.push_back(
"-std=c++20");
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;
592 struct awaitable_frame {
593 awaitable get_return_object();
595 void unhandled_exception();
598 bool await_ready() const noexcept;
599 void await_suspend(std::coroutine_handle<void>) noexcept;
600 void await_resume() const noexcept;
602 result_t initial_suspend() noexcept;
603 result_t final_suspend() noexcept;
604 result_t await_transform(executor) noexcept;
609 struct coroutine_traits<awaitable> {
610 typedef awaitable_frame promise_type;
615 co_await [[executor]]();
621TEST_F(TargetDeclTest, RewrittenBinaryOperator) {
622 Flags.push_back(
"-std=c++20");
626 struct strong_ordering {
628 constexpr operator int() const { return n; }
629 static const strong_ordering equal, greater, less;
631 constexpr strong_ordering strong_ordering::equal = {0};
632 constexpr strong_ordering strong_ordering::greater = {1};
633 constexpr strong_ordering strong_ordering::less = {-1};
639 auto operator<=>(const Foo&) const = default;
642 bool x = (Foo(1) [[!=]] Foo(2));
645 {
"std::strong_ordering operator<=>(const Foo &) const = default",
646 Rel::TemplatePattern},
647 {
"bool operator==(const Foo &) const noexcept = default",
648 Rel::TemplateInstantiation});
651TEST_F(TargetDeclTest, FunctionTemplate) {
653 // Implicit specialization.
654 template<typename T> bool foo(T) { return false; };
655 bool x = [[foo]](42);
658 {
"template<> bool foo<int>(int)", Rel::TemplateInstantiation},
659 {
"bool foo(T)", Rel::TemplatePattern});
662 // Explicit specialization.
663 template<typename T> bool foo(T) { return false; };
664 template<> bool foo<int>(int) { return false; };
665 bool x = [[foo]](42);
667 EXPECT_DECLS("DeclRefExpr",
"template<> bool foo<int>(int)");
670TEST_F(TargetDeclTest, VariableTemplate) {
673 // Implicit specialization.
674 template<typename T> int foo;
675 int x = [[foo]]<char>;
677 EXPECT_DECLS("DeclRefExpr", {
"int foo", Rel::TemplateInstantiation},
678 {
"int foo", Rel::TemplatePattern});
681 // Explicit specialization.
682 template<typename T> int foo;
683 template <> bool foo<char>;
684 int x = [[foo]]<char>;
689 // Partial specialization.
690 template<typename T> int foo;
691 template<typename T> bool foo<T*>;
692 bool x = [[foo]]<char*>;
694 EXPECT_DECLS("DeclRefExpr", {
"bool foo", Rel::TemplateInstantiation},
695 {
"bool foo", Rel::TemplatePattern});
698TEST_F(TargetDeclTest, TypeAliasTemplate) {
700 template<typename T, int X> class SmallVector {};
701 template<typename U> using TinyVector = SmallVector<U, 1>;
702 [[TinyVector<int>]] X;
705 {
"template<> class SmallVector<int, 1>",
706 Rel::TemplateInstantiation | Rel::Underlying},
707 {
"class SmallVector", Rel::TemplatePattern | Rel::Underlying},
708 {
"using TinyVector = SmallVector<U, 1>",
709 Rel::Alias | Rel::TemplatePattern});
712TEST_F(TargetDeclTest, MemberOfTemplate) {
714 template <typename T> struct Foo {
717 int y = Foo<int>().[[x]](42);
719 EXPECT_DECLS("MemberExpr", {
"int x(int)", Rel::TemplateInstantiation},
720 {
"int x(T)", Rel::TemplatePattern});
723 template <typename T> struct Foo {
724 template <typename U>
727 int y = Foo<char>().[[x]]('c', 42);
730 {
"template<> int x<int>(char, int)", Rel::TemplateInstantiation},
731 {
"int x(T, U)", Rel::TemplatePattern});
734TEST_F(TargetDeclTest, Lambda) {
736 void foo(int x = 42) {
737 auto l = [ [[x]] ]{ return x + 1; };
745 void foo(int x = 42) {
746 auto l = [x]{ return [[x]] + 1; };
753 auto l = [x = 1]{ return [[x]] + 1; };
760TEST_F(TargetDeclTest, OverloadExpr) {
761 Flags.push_back(
"--target=x86_64-pc-linux-gnu");
772 EXPECT_DECLS("UnresolvedLookupExpr",
"void func(int *)",
"void func(char *)");
785 EXPECT_DECLS("UnresolvedMemberExpr",
"void func(int *)",
"void func(char *)");
789 static void *operator new(unsigned long);
791 auto* k = [[new]] X();
793 EXPECT_DECLS("CXXNewExpr",
"static void *operator new(unsigned long)");
795 void *operator new(unsigned long);
796 auto* k = [[new]] int();
798 EXPECT_DECLS("CXXNewExpr",
"void *operator new(unsigned long)");
802 static void operator delete(void *) noexcept;
808 EXPECT_DECLS("CXXDeleteExpr",
"static void operator delete(void *) noexcept");
810 void operator delete(void *) noexcept;
815 EXPECT_DECLS("CXXDeleteExpr",
"void operator delete(void *) noexcept");
818TEST_F(TargetDeclTest, DependentExprs) {
821 struct A { void foo() {} };
822 template <typename T>
830 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void foo()");
840 template <typename T>
844 this->c.getA().[[foo]]();
848 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void foo()");
859 template <typename T>
863 this->c.fptr().[[foo]]();
867 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void foo()");
874 template <typename T> struct Foo {
881 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"int aaaa");
887 template <typename T> T convert() const;
889 template <typename T>
891 Foo::k(T()).template [[convert]]<T>();
895 "template <typename T> T convert() const");
898 template <typename T>
902 template <typename T>
903 using Wally = Waldo<T>;
904 template <typename T>
905 void foo(Wally<T> w) {
909 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void find()");
912 template <typename T>
916 template <typename T>
918 using Type = Waldo<T>;
920 template <typename T>
921 void foo(typename MetaWaldo<T>::Type w) {
925 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void find()");
931 template <typename T>
934 struct S : Wally<int> {
935 void Foo() { this->[[find]](); }
938 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void find()");
941TEST_F(TargetDeclTest, DependentTypes) {
945 struct A { struct B {}; };
947 template <typename T>
948 void foo(typename A<T>::[[B]]);
955 struct A { struct B { struct C {}; }; };
957 template <typename T>
958 void foo(typename A<T>::[[B]]::C);
966 struct A { struct B { struct C {}; }; };
968 template <typename T>
969 void foo(typename A<T>::B::[[C]]);
977 template <typename> struct B {};
980 template <typename T>
981 void foo(typename A<T>::template [[B]]<int>);
984 "template <typename> struct B");
987TEST_F(TargetDeclTest, TypedefCascade) {
993 using type = C::type;
996 using type = B::type;
1001 {
"using type = int", Rel::Alias | Rel::Underlying},
1002 {
"using type = C::type", Rel::Alias | Rel::Underlying},
1003 {
"using type = B::type", Rel::Alias});
1006TEST_F(TargetDeclTest, RecursiveTemplate) {
1007 Flags.push_back(
"-std=c++20");
1010 template <typename T>
1011 concept Leaf = false;
1013 template <typename Tree>
1014 struct descend_left {
1015 using type = typename descend_left<typename Tree::left>::[[type]];
1018 template <Leaf Tree>
1019 struct descend_left<Tree> {
1020 using type = typename Tree::value;
1024 {
"using type = typename descend_left<typename Tree::left>::type",
1025 Rel::Alias | Rel::Underlying});
1028TEST_F(TargetDeclTest, ObjC) {
1029 Flags = {
"-xobjective-c"};
1041 @interface Foo { @public int bar; }
1052 -(void) setX:(int)x;
1058 EXPECT_DECLS("ObjCPropertyRefExpr",
"- (void)setX:(int)x");
1062 @property(retain) I* x;
1063 @property(retain) I* y;
1070 "@property(atomic, retain, readwrite) I *x");
1075 @interface Interface
1076 @property(retain) [[MYObject]] *x;
1079 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface MYObject");
1082 @interface MYObject2
1084 @interface Interface
1085 @property(retain, nonnull) [[MYObject2]] *x;
1088 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface MYObject2");
1094 return [[@protocol(Foo)]];
1102 void test([[Foo]] *p);
1104 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface Foo");
1106 Code = R
"cpp(// Don't consider implicit interface as the target.
1107 @implementation [[Implicit]]
1110 EXPECT_DECLS("ObjCImplementationDecl",
"@implementation Implicit");
1115 @implementation [[Foo]]
1118 EXPECT_DECLS("ObjCImplementationDecl",
"@interface Foo");
1123 @interface Foo (Ext)
1125 @implementation [[Foo]] (Ext)
1128 EXPECT_DECLS("ObjCCategoryImplDecl",
"@interface Foo(Ext)");
1133 @interface Foo (Ext)
1135 @implementation Foo ([[Ext]])
1138 EXPECT_DECLS("ObjCCategoryImplDecl",
"@interface Foo(Ext)");
1141 void test(id</*error-ok*/[[InvalidProtocol]]> p);
1149 void test([[C]]<Foo> *p);
1157 void test(C<[[Foo]]> *p);
1167 void test(C<[[Foo]], Bar> *p);
1177 void test(C<Foo, [[Bar]]> *p);
1183 + (id)sharedInstance;
1186 + (id)sharedInstance { return 0; }
1189 id value = [[Foo]].sharedInstance;
1192 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface Foo");
1196 + (id)sharedInstance;
1199 + (id)sharedInstance { return 0; }
1202 id value = Foo.[[sharedInstance]];
1205 EXPECT_DECLS("ObjCPropertyRefExpr",
"+ (id)sharedInstance");
1209 + ([[id]])sharedInstance;
1216 + ([[instancetype]])sharedInstance;
1222class FindExplicitReferencesTest :
public ::testing::Test {
1229 TestTU newTU(llvm::StringRef
Code) {
1231 TU.Code = std::string(
Code);
1235 TU.ExtraArgs.push_back(
"-std=c++20");
1236 TU.ExtraArgs.push_back(
"-xobjective-c++");
1241 AllRefs annotatedReferences(llvm::StringRef
Code, ParsedAST &
AST,
1242 std::vector<ReferenceLoc> Refs) {
1243 auto &SM =
AST.getSourceManager();
1244 llvm::stable_sort(Refs, [&](
const ReferenceLoc &L,
const ReferenceLoc &R) {
1245 return SM.isBeforeInTranslationUnit(L.NameLoc, R.NameLoc);
1249 unsigned NextCodeChar = 0;
1250 for (
unsigned I = 0; I < Refs.size(); ++I) {
1253 SourceLocation
Pos = R.NameLoc;
1254 assert(
Pos.isValid());
1255 if (
Pos.isMacroID())
1256 Pos = SM.getExpansionLoc(
Pos);
1257 assert(
Pos.isFileID());
1262 if (
File == SM.getMainFileID()) {
1264 assert(NextCodeChar <=
Offset);
1274 for (
unsigned I = 0; I < Refs.size(); ++I)
1283 AllRefs annotateAllReferences(llvm::StringRef
Code) {
1284 TestTU TU = newTU(
Code);
1285 auto AST = TU.build();
1287 std::vector<ReferenceLoc> Refs;
1288 for (
auto *TopLevel :
AST.getLocalTopLevelDecls())
1290 TopLevel, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1291 AST.getHeuristicResolver());
1292 return annotatedReferences(
Code,
AST, std::move(Refs));
1298 AllRefs annotateReferencesInFoo(llvm::StringRef
Code) {
1299 TestTU TU = newTU(
Code);
1300 auto AST = TU.build();
1302 if (
auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
1303 TestDecl = T->getTemplatedDecl();
1305 std::vector<ReferenceLoc> Refs;
1306 if (
const auto *Func = llvm::dyn_cast<FunctionDecl>(TestDecl))
1309 [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1310 AST.getHeuristicResolver());
1311 else if (
const auto *NS = llvm::dyn_cast<NamespaceDecl>(TestDecl))
1314 [&Refs, &NS](ReferenceLoc R) {
1316 if (R.Targets.size() == 1 && R.Targets.front() == NS)
1318 Refs.push_back(std::move(R));
1320 AST.getHeuristicResolver());
1321 else if (
const auto *OC = llvm::dyn_cast<ObjCContainerDecl>(TestDecl))
1323 OC, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1324 AST.getHeuristicResolver());
1326 ADD_FAILURE() <<
"Failed to find ::foo decl for test";
1328 return annotatedReferences(
Code,
AST, std::move(Refs));
1332TEST_F(FindExplicitReferencesTest, AllRefsInFoo) {
1333 std::pair< llvm::StringRef, llvm::StringRef> Cases[] =
1338 void foo(int param) {
1339 $0^global = $1^param + $2^func();
1342 "0: targets = {global}\n"
1343 "1: targets = {param}\n"
1344 "2: targets = {func}\n"},
1346 struct X { int a; };
1351 "0: targets = {x}\n"
1352 "1: targets = {X::a}\n"},
1354 // error-ok: testing with broken code
1357 return $0^bar() + $1^bar(42);
1360 "0: targets = {bar}\n"
1361 "1: targets = {bar}\n"},
1365 namespace alias = ns;
1367 using namespace $0^ns;
1368 using namespace $1^alias;
1371 "0: targets = {ns}\n"
1372 "1: targets = {alias}\n"},
1375 namespace ns { int global; }
1377 using $0^ns::$1^global;
1380 "0: targets = {ns}\n"
1381 "1: targets = {ns::global}, qualifier = 'ns::'\n"},
1384 namespace ns { enum class A {}; }
1386 using enum $0^ns::$1^A;
1389 "0: targets = {ns}\n"
1390 "1: targets = {ns::A}, qualifier = 'ns::'\n"},
1393 struct Struct { int a; };
1394 using Typedef = int;
1398 static_cast<$4^Struct*>(0);
1401 "0: targets = {Struct}\n"
1402 "1: targets = {x}, decl\n"
1403 "2: targets = {Typedef}\n"
1404 "3: targets = {y}, decl\n"
1405 "4: targets = {Struct}\n"},
1408 namespace a { namespace b { struct S { typedef int type; }; } }
1410 $0^a::$1^b::$2^S $3^x;
1411 using namespace $4^a::$5^b;
1415 "0: targets = {a}\n"
1416 "1: targets = {a::b}, qualifier = 'a::'\n"
1417 "2: targets = {a::b::S}, qualifier = 'a::b::'\n"
1418 "3: targets = {x}, decl\n"
1419 "4: targets = {a}\n"
1420 "5: targets = {a::b}, qualifier = 'a::'\n"
1421 "6: targets = {a::b::S}\n"
1422 "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
1423 "8: targets = {y}, decl\n"},
1426 $0^ten: // PRINT "HELLO WORLD!"
1430 "0: targets = {ten}, decl\n"
1431 "1: targets = {ten}\n"},
1434 template <class T> struct vector { using value_type = T; };
1435 template <> struct vector<bool> { using value_type = bool; };
1437 $0^vector<int> $1^vi;
1438 $2^vector<bool> $3^vb;
1441 "0: targets = {vector<int>}\n"
1442 "1: targets = {vi}, decl\n"
1443 "2: targets = {vector<bool>}\n"
1444 "3: targets = {vb}, decl\n"},
1447 template <class T> struct vector { using value_type = T; };
1448 template <> struct vector<bool> { using value_type = bool; };
1449 template <class T> using valias = vector<T>;
1451 $0^valias<int> $1^vi;
1452 $2^valias<bool> $3^vb;
1455 "0: targets = {valias}\n"
1456 "1: targets = {vi}, decl\n"
1457 "2: targets = {valias}\n"
1458 "3: targets = {vb}, decl\n"},
1462 template <typename $0^T>
1469 "0: targets = {foo::Bar::T}, decl\n"
1470 "1: targets = {foo::Bar}, decl\n"
1471 "2: targets = {foo::Bar}\n"
1472 "3: targets = {foo::Bar::f}, decl\n"
1473 "4: targets = {foo::Bar}\n"},
1476 struct X { void func(int); };
1484 "0: targets = {y}\n"
1485 "1: targets = {Y::func}\n"},
1488 namespace ns { void bar(int); }
1495 "0: targets = {bar}\n"},
1501 void foo(int a, int b) {
1505 "0: targets = {a}\n"
1506 "1: targets = {b}\n"},
1515 for (int $0^x : $1^vector()) {
1520 "0: targets = {x}, decl\n"
1521 "1: targets = {vector}\n"
1522 "2: targets = {x}\n"},
1525 namespace ns1 { void func(char*); }
1526 namespace ns2 { void func(int*); }
1527 using namespace ns1;
1528 using namespace ns2;
1535 "0: targets = {ns1::func, ns2::func}\n"
1536 "1: targets = {t}\n"},
1545 void foo(X x, T t) {
1549 "0: targets = {x}\n"
1550 "1: targets = {X::func, X::func}\n"
1551 "2: targets = {t}\n"},
1561 $0^S<$1^T>::$2^value;
1564 "0: targets = {S}\n"
1565 "1: targets = {T}\n"
1566 "2: targets = {S::value}, qualifier = 'S<T>::'\n"},
1579 "0: targets = {t}\n"
1580 "1: targets = {S::value}\n"},
1585 static_cast<$0^T>(0);
1590 "0: targets = {T}\n"
1591 "1: targets = {T}\n"
1592 "2: targets = {T}\n"
1593 "3: targets = {t}, decl\n"},
1601 "0: targets = {x}, decl\n"
1602 "1: targets = {I}\n"},
1605 template <class T> struct vector {};
1607 template <template<class> class TT, template<class> class ...TP>
1611 $4^foo<$5^vector>();
1615 "0: targets = {TT}\n"
1616 "1: targets = {x}, decl\n"
1617 "2: targets = {foo}\n"
1618 "3: targets = {TT}\n"
1619 "4: targets = {foo}\n"
1620 "5: targets = {vector}\n"
1621 "6: targets = {foo}\n"
1622 "7: targets = {TP}\n"},
1626 template <int(*)()> struct wrapper {};
1628 template <int(*FuncParam)()>
1630 $0^wrapper<$1^func> $2^w;
1634 "0: targets = {wrapper<&func>}\n"
1635 "1: targets = {func}\n"
1636 "2: targets = {w}, decl\n"
1637 "3: targets = {FuncParam}\n"},
1643 class $0^Foo { $1^Foo(); ~$2^Foo(); int $3^field; };
1645 enum $5^E { $6^ABC };
1647 using $8^INT2 = int;
1648 namespace $9^NS = $10^ns;
1651 "0: targets = {Foo}, decl\n"
1652 "1: targets = {foo()::Foo::Foo}, decl\n"
1653 "2: targets = {Foo}\n"
1654 "3: targets = {foo()::Foo::field}, decl\n"
1655 "4: targets = {Var}, decl\n"
1656 "5: targets = {E}, decl\n"
1657 "6: targets = {foo()::ABC}, decl\n"
1658 "7: targets = {INT}, decl\n"
1659 "8: targets = {INT2}, decl\n"
1660 "9: targets = {NS}, decl\n"
1661 "10: targets = {ns}\n"},
1668 // FIXME: This should have only one reference to Bar.
1669 $2^operator $3^$4^Bar();
1673 $7^f.$8^operator $9^Bar();
1676 "0: targets = {Bar}, decl\n"
1677 "1: targets = {Foo}, decl\n"
1678 "2: targets = {foo()::Foo::operator Bar}, decl\n"
1679 "3: targets = {Bar}\n"
1680 "4: targets = {Bar}\n"
1681 "5: targets = {Foo}\n"
1682 "6: targets = {f}, decl\n"
1683 "7: targets = {f}\n"
1684 "8: targets = {foo()::Foo::operator Bar}\n"
1685 "9: targets = {Bar}\n"},
1693 void $2^destructMe() {
1699 $6^f.~ /*...*/ $7^Foo();
1702 "0: targets = {Foo}, decl\n"
1705 "1: targets = {Foo}\n"
1706 "2: targets = {foo()::Foo::destructMe}, decl\n"
1707 "3: targets = {Foo}\n"
1708 "4: targets = {Foo}\n"
1709 "5: targets = {f}, decl\n"
1710 "6: targets = {f}\n"
1711 "7: targets = {Foo}\n"},
1716 // member initializer
1722 class $4^Derived : public $5^Base {
1724 $8^Derived() : $9^Base() {}
1726 // delegating initializer
1729 $12^Foo(): $13^Foo(111) {}
1733 "0: targets = {X}, decl\n"
1734 "1: targets = {foo()::X::abc}, decl\n"
1735 "2: targets = {foo()::X::X}, decl\n"
1736 "3: targets = {foo()::X::abc}\n"
1737 "4: targets = {Derived}, decl\n"
1738 "5: targets = {Base}\n"
1739 "6: targets = {Base}\n"
1740 "7: targets = {foo()::Derived::B}, decl\n"
1741 "8: targets = {foo()::Derived::Derived}, decl\n"
1742 "9: targets = {Base}\n"
1743 "10: targets = {Foo}, decl\n"
1744 "11: targets = {foo()::Foo::Foo}, decl\n"
1745 "12: targets = {foo()::Foo::Foo}, decl\n"
1746 "13: targets = {Foo}\n"},
1752 int (*$2^fptr)(int $3^a, int) = nullptr;
1755 "0: targets = {(unnamed)}\n"
1756 "1: targets = {x}, decl\n"
1757 "2: targets = {fptr}, decl\n"
1758 "3: targets = {a}, decl\n"},
1762 namespace ns { struct Type {}; }
1763 namespace alias = ns;
1764 namespace rec_alias = alias;
1767 $0^ns::$1^Type $2^a;
1768 $3^alias::$4^Type $5^b;
1769 $6^rec_alias::$7^Type $8^c;
1772 "0: targets = {ns}\n"
1773 "1: targets = {ns::Type}, qualifier = 'ns::'\n"
1774 "2: targets = {a}, decl\n"
1775 "3: targets = {alias}\n"
1776 "4: targets = {ns::Type}, qualifier = 'alias::'\n"
1777 "5: targets = {b}, decl\n"
1778 "6: targets = {rec_alias}\n"
1779 "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n"
1780 "8: targets = {c}, decl\n"},
1784 template <typename... E>
1786 constexpr int $0^size = sizeof...($1^E);
1789 "0: targets = {size}, decl\n"
1790 "1: targets = {E}\n"},
1794 template <typename T>
1802 "0: targets = {Test}\n"
1803 "1: targets = {a}, decl\n"},
1807 template <typename $0^T>
1811 "0: targets = {foo::Bar::T}, decl\n"
1812 "1: targets = {foo::Bar}, decl\n"},
1816 template <typename $0^T>
1820 "0: targets = {T}, decl\n"
1821 "1: targets = {foo::func}, decl\n"},
1825 template <typename $0^T>
1829 "0: targets = {foo::T}, decl\n"
1830 "1: targets = {foo::T}\n"
1831 "2: targets = {foo::x}, decl\n"},
1834 template<typename T> class vector {};
1836 template <typename $0^T>
1837 using $1^V = $2^vector<$3^T>;
1840 "0: targets = {foo::T}, decl\n"
1841 "1: targets = {foo::V}, decl\n"
1842 "2: targets = {vector}\n"
1843 "3: targets = {foo::T}\n"},
1847 template <typename T>
1848 concept Drawable = requires (T t) { t.draw(); };
1851 template <typename $0^T> requires $1^Drawable<$2^T>
1852 void $3^bar($4^T $5^t) {
1857 "0: targets = {T}, decl\n"
1858 "1: targets = {Drawable}\n"
1859 "2: targets = {T}\n"
1860 "3: targets = {foo::bar}, decl\n"
1861 "4: targets = {T}\n"
1862 "5: targets = {t}, decl\n"
1863 "6: targets = {t}\n"
1864 "7: targets = {}\n"},
1878 "0: targets = {f}\n"
1879 "1: targets = {I::_z}\n"},
1884 @property(retain) I* x;
1885 @property(retain) I* y;
1892 "0: targets = {f}\n"
1893 "1: targets = {I::x}\n"
1894 "2: targets = {I::y}\n"},
1907 "0: targets = {f}\n"
1908 "1: targets = {I::x}\n"
1909 "2: targets = {I::setY:}\n"},
1914 @property(class) I *x;
1919 $2^local = $3^I.$4^x;
1922 "0: targets = {I}\n"
1923 "1: targets = {I::setX:}\n"
1924 "2: targets = {local}\n"
1925 "3: targets = {I}\n"
1926 "4: targets = {I::x}\n"},
1937 $2^local = $3^I.$4^x;
1940 "0: targets = {I}\n"
1941 "1: targets = {I::setX:}\n"
1942 "2: targets = {local}\n"
1943 "3: targets = {I}\n"
1944 "4: targets = {I::x}\n"},
1948 -(void) a:(int)x b:(int)y;
1954 "0: targets = {i}\n"
1955 "1: targets = {I::a:b:}\n"},
1966 "0: targets = {I}\n"
1967 "1: targets = {P}\n"
1968 "2: targets = {x}, decl\n"},
1976 $2^Foo $3^f { .$4^Bar = 42 };
1979 "0: targets = {Foo}, decl\n"
1980 "1: targets = {foo()::Foo::Bar}, decl\n"
1981 "2: targets = {Foo}\n"
1982 "3: targets = {f}, decl\n"
1983 "4: targets = {foo()::Foo::Bar}\n"},
1992 $5^Bar $6^bar { .$7^Foo.$8^Field = 42 };
1995 "0: targets = {Baz}, decl\n"
1996 "1: targets = {foo()::Baz::Field}, decl\n"
1997 "2: targets = {Bar}, decl\n"
1998 "3: targets = {Baz}\n"
1999 "4: targets = {foo()::Bar::Foo}, decl\n"
2000 "5: targets = {Bar}\n"
2001 "6: targets = {bar}, decl\n"
2002 "7: targets = {foo()::Bar::Foo}\n"
2003 "8: targets = {foo()::Baz::Field}\n"},
2005 template<typename T>
2007 template<typename T>
2009 $0^crash({.$1^x = $2^T()});
2012 "0: targets = {crash}\n"
2014 "2: targets = {T}\n"},
2017 template <template <typename> typename T>
2020 template <typename $0^T>
2021 struct $1^Derive : $2^Base<$3^T::template $4^Unknown> {};
2024 "0: targets = {foo::Derive::T}, decl\n"
2025 "1: targets = {foo::Derive}, decl\n"
2026 "2: targets = {Base}\n"
2027 "3: targets = {foo::Derive::T}\n"
2028 "4: targets = {}, qualifier = 'T::'\n"},
2032 template <typename $0^T>
2034 template <typename $2^I>
2037 template <typename $5^I>
2038 $6^Test($7^I) -> $8^Test<typename $9^I::$10^type>;
2041 "0: targets = {T}, decl\n"
2042 "1: targets = {foo::Test}, decl\n"
2043 "2: targets = {I}, decl\n"
2044 "3: targets = {foo::Test::Test<T>}, decl\n"
2045 "4: targets = {I}\n"
2046 "5: targets = {I}, decl\n"
2047 "6: targets = {foo::Test}\n"
2048 "7: targets = {I}\n"
2049 "8: targets = {foo::Test}\n"
2050 "9: targets = {I}\n"
2051 "10: targets = {}, qualifier = 'I::'\n"}};
2053 for (
const auto &
C : Cases) {
2054 llvm::StringRef ExpectedCode =
C.first;
2055 llvm::StringRef ExpectedRefs =
C.second;
2058 annotateReferencesInFoo(llvm::Annotations(ExpectedCode).code());
2059 EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
2060 EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
2064TEST_F(FindExplicitReferencesTest, AllRefs) {
2065 std::pair< llvm::StringRef, llvm::StringRef> Cases[] =
2067 @interface $0^MyClass
2069 @implementation $1^$2^MyClass
2072 "0: targets = {MyClass}, decl\n"
2073 "1: targets = {MyClass}\n"
2074 "2: targets = {MyClass}, decl\n"},
2076 @interface $0^MyClass
2078 @interface $1^MyClass ($2^Category)
2080 @implementation $3^MyClass ($4^$5^Category)
2083 "0: targets = {MyClass}, decl\n"
2084 "1: targets = {MyClass}\n"
2085 "2: targets = {Category}, decl\n"
2086 "3: targets = {MyClass}\n"
2087 "4: targets = {Category}\n"
2088 "5: targets = {Category}, decl\n"}};
2090 for (
const auto &
C : Cases) {
2091 llvm::StringRef ExpectedCode =
C.first;
2092 llvm::StringRef ExpectedRefs =
C.second;
2094 auto Actual = annotateAllReferences(llvm::Annotations(ExpectedCode).code());
2095 EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
2096 EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
#define EXPECT_DECLS(NodeType,...)
std::string AnnotatedCode
std::string DumpedReferences
llvm::raw_string_ostream OS
static SelectionTree createRight(ASTContext &AST, const syntax::TokenBuffer &Tokens, unsigned Begin, unsigned End)
TEST_F(BackgroundIndexTest, NoCrashOnErrorFile)
const NamedDecl & findDecl(ParsedAST &AST, llvm::StringRef QName)
llvm::SmallVector< std::pair< const NamedDecl *, DeclRelationSet >, 1 > allTargetDecls(const DynTypedNode &N, const HeuristicResolver *Resolver)
Similar to targetDecl(), however instead of applying a filter, all possible decls are returned along ...
void findExplicitReferences(const Stmt *S, llvm::function_ref< void(ReferenceLoc)> Out, const HeuristicResolver *Resolver)
Recursively traverse S and report all references explicitly written in the code.
bool operator==(const Inclusion &LHS, const Inclusion &RHS)
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const CodeCompletion &C)
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
static TestTU withCode(llvm::StringRef Code)