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 {
"bool operator==(const Foo &) const noexcept = default"});
648TEST_F(TargetDeclTest, FunctionTemplate) {
650 // Implicit specialization.
651 template<typename T> bool foo(T) { return false; };
652 bool x = [[foo]](42);
655 {
"template<> bool foo<int>(int)", Rel::TemplateInstantiation},
656 {
"bool foo(T)", Rel::TemplatePattern});
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);
664 EXPECT_DECLS("DeclRefExpr",
"template<> bool foo<int>(int)");
667TEST_F(TargetDeclTest, VariableTemplate) {
670 // Implicit specialization.
671 template<typename T> int foo;
672 int x = [[foo]]<char>;
674 EXPECT_DECLS("DeclRefExpr", {
"int foo", Rel::TemplateInstantiation},
675 {
"int foo", Rel::TemplatePattern});
678 // Explicit specialization.
679 template<typename T> int foo;
680 template <> bool foo<char>;
681 int x = [[foo]]<char>;
686 // Partial specialization.
687 template<typename T> int foo;
688 template<typename T> bool foo<T*>;
689 bool x = [[foo]]<char*>;
691 EXPECT_DECLS("DeclRefExpr", {
"bool foo", Rel::TemplateInstantiation},
692 {
"bool foo", Rel::TemplatePattern});
695TEST_F(TargetDeclTest, TypeAliasTemplate) {
697 template<typename T, int X> class SmallVector {};
698 template<typename U> using TinyVector = SmallVector<U, 1>;
699 [[TinyVector<int>]] X;
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});
709TEST_F(TargetDeclTest, BuiltinTemplates) {
711 template <class T, T... Index> struct integer_sequence {};
712 [[__make_integer_seq]]<integer_sequence, int, 3> X;
715 "TemplateSpecializationTypeLoc",
716 {
"struct integer_sequence", Rel::TemplatePattern | Rel::Underlying},
717 {
"template<> struct integer_sequence<int, <0, 1, 2>>",
718 Rel::TemplateInstantiation | Rel::Underlying});
722 template <class T, T... Index> struct integer_sequence;
724 template <class T, int N>
725 using make_integer_sequence = [[__make_integer_seq]]<integer_sequence, T, N>;
730 template <int N, class... Pack>
731 using type_pack_element = [[__type_pack_element]]<N, Pack...>;
736TEST_F(TargetDeclTest, MemberOfTemplate) {
738 template <typename T> struct Foo {
741 int y = Foo<int>().[[x]](42);
743 EXPECT_DECLS("MemberExpr", {
"int x(int)", Rel::TemplateInstantiation},
744 {
"int x(T)", Rel::TemplatePattern});
747 template <typename T> struct Foo {
748 template <typename U>
751 int y = Foo<char>().[[x]]('c', 42);
754 {
"template<> int x<int>(char, int)", Rel::TemplateInstantiation},
755 {
"int x(T, U)", Rel::TemplatePattern});
758TEST_F(TargetDeclTest, Lambda) {
760 void foo(int x = 42) {
761 auto l = [ [[x]] ]{ return x + 1; };
769 void foo(int x = 42) {
770 auto l = [x]{ return [[x]] + 1; };
777 auto l = [x = 1]{ return [[x]] + 1; };
784TEST_F(TargetDeclTest, OverloadExpr) {
785 Flags.push_back(
"--target=x86_64-pc-linux-gnu");
796 EXPECT_DECLS("UnresolvedLookupExpr",
"void func(int *)",
"void func(char *)");
809 EXPECT_DECLS("UnresolvedMemberExpr",
"void func(int *)",
"void func(char *)");
813 static void *operator new(unsigned long);
815 auto* k = [[new]] X();
817 EXPECT_DECLS("CXXNewExpr",
"static void *operator new(unsigned long)");
819 void *operator new(unsigned long);
820 auto* k = [[new]] int();
822 EXPECT_DECLS("CXXNewExpr",
"void *operator new(unsigned long)");
826 static void operator delete(void *) noexcept;
832 EXPECT_DECLS("CXXDeleteExpr",
"static void operator delete(void *) noexcept");
834 void operator delete(void *) noexcept;
841 "void operator delete(void *, unsigned long) noexcept");
844TEST_F(TargetDeclTest, DependentExprs) {
847 struct A { void foo() {} };
848 template <typename T>
866 template <typename T>
870 this->c.getA().[[foo]]();
885 template <typename T>
889 this->c.fptr().[[foo]]();
900 template <typename T> struct Foo {
907 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"int aaaa");
913 template <typename T> T convert() const;
915 template <typename T>
917 Foo::k(T()).template [[convert]]<T>();
921 "template <typename T> T convert() const");
924 template <typename T>
928 template <typename T>
929 using Wally = Waldo<T>;
930 template <typename T>
931 void foo(Wally<T> w) {
935 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void find()");
938 template <typename T>
942 template <typename T>
944 using Type = Waldo<T>;
946 template <typename T>
947 void foo(typename MetaWaldo<T>::Type w) {
951 EXPECT_DECLS("CXXDependentScopeMemberExpr",
"void find()");
957 template <typename T>
960 struct S : Wally<int> {
961 void Foo() { this->[[find]](); }
967TEST_F(TargetDeclTest, DependentTypes) {
971 struct A { struct B {}; };
973 template <typename T>
974 void foo(typename A<T>::[[B]]);
981 struct A { struct B { struct C {}; }; };
983 template <typename T>
984 void foo(typename A<T>::[[B]]::C);
992 struct A { struct B { struct C {}; }; };
994 template <typename T>
995 void foo(typename A<T>::B::[[C]]);
1003 template <typename> struct B {};
1006 template <typename T>
1007 void foo(typename A<T>::template [[B]]<int>);
1010 "template <typename> struct B");
1017 typedef typename waldo<N - 1>::type::[[next]] type;
1029 using type = typename odd<N - 1>::type::next;
1034 using type = typename even<N - 1>::type::[[next]];
1040TEST_F(TargetDeclTest, TypedefCascade) {
1046 using type = C::type;
1049 using type = B::type;
1054 {
"using type = int", Rel::Alias | Rel::Underlying},
1055 {
"using type = C::type", Rel::Alias | Rel::Underlying},
1056 {
"using type = B::type", Rel::Alias});
1059TEST_F(TargetDeclTest, RecursiveTemplate) {
1060 Flags.push_back(
"-std=c++20");
1063 template <typename T>
1064 concept Leaf = false;
1066 template <typename Tree>
1067 struct descend_left {
1068 using type = typename descend_left<typename Tree::left>::[[type]];
1071 template <Leaf Tree>
1072 struct descend_left<Tree> {
1073 using type = typename Tree::value;
1077 {
"using type = typename descend_left<typename Tree::left>::type",
1078 Rel::Alias | Rel::Underlying});
1081TEST_F(TargetDeclTest, ObjC) {
1082 Flags = {
"-xobjective-c"};
1094 @interface Foo { @public int bar; }
1105 -(void) setX:(int)x;
1111 EXPECT_DECLS("ObjCPropertyRefExpr",
"- (void)setX:(int)x");
1115 @property(retain) I* x;
1116 @property(retain) I* y;
1123 "@property(atomic, retain, readwrite) I *x");
1128 @interface Interface
1129 @property(retain) [[MYObject]] *x;
1132 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface MYObject");
1135 @interface MYObject2
1137 @interface Interface
1138 @property(retain, nonnull) [[MYObject2]] *x;
1141 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface MYObject2");
1147 return [[@protocol(Foo)]];
1155 void test([[Foo]] *p);
1157 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface Foo");
1159 Code = R
"cpp(// Don't consider implicit interface as the target.
1160 @implementation [[Implicit]]
1163 EXPECT_DECLS("ObjCImplementationDecl",
"@implementation Implicit");
1168 @implementation [[Foo]]
1171 EXPECT_DECLS("ObjCImplementationDecl",
"@interface Foo");
1176 @interface Foo (Ext)
1178 @implementation [[Foo]] (Ext)
1181 EXPECT_DECLS("ObjCCategoryImplDecl",
"@interface Foo(Ext)");
1186 @interface Foo (Ext)
1188 @implementation Foo ([[Ext]])
1191 EXPECT_DECLS("ObjCCategoryImplDecl",
"@interface Foo(Ext)");
1194 void test(id</*error-ok*/[[InvalidProtocol]]> p);
1202 void test([[C]]<Foo> *p);
1210 void test(C<[[Foo]]> *p);
1220 void test(C<[[Foo]], Bar> *p);
1230 void test(C<Foo, [[Bar]]> *p);
1236 + (id)sharedInstance;
1239 + (id)sharedInstance { return 0; }
1242 id value = [[Foo]].sharedInstance;
1245 EXPECT_DECLS("ObjCInterfaceTypeLoc",
"@interface Foo");
1249 + (id)sharedInstance;
1252 + (id)sharedInstance { return 0; }
1255 id value = Foo.[[sharedInstance]];
1258 EXPECT_DECLS("ObjCPropertyRefExpr",
"+ (id)sharedInstance");
1262 + ([[id]])sharedInstance;
1269 + ([[instancetype]])sharedInstance;
1275class FindExplicitReferencesTest :
public ::testing::Test {
1282 TestTU newTU(llvm::StringRef
Code) {
1284 TU.Code = std::string(
Code);
1288 TU.ExtraArgs.push_back(
"-std=c++20");
1289 TU.ExtraArgs.push_back(
"-xobjective-c++");
1294 AllRefs annotatedReferences(llvm::StringRef
Code, ParsedAST &
AST,
1295 std::vector<ReferenceLoc> Refs) {
1296 auto &SM =
AST.getSourceManager();
1297 llvm::stable_sort(Refs, [&](
const ReferenceLoc &L,
const ReferenceLoc &R) {
1298 return SM.isBeforeInTranslationUnit(L.NameLoc, R.NameLoc);
1302 unsigned NextCodeChar = 0;
1303 for (
unsigned I = 0; I < Refs.size(); ++I) {
1306 SourceLocation
Pos = R.NameLoc;
1307 assert(
Pos.isValid());
1308 if (
Pos.isMacroID())
1309 Pos = SM.getExpansionLoc(
Pos);
1310 assert(
Pos.isFileID());
1315 if (
File == SM.getMainFileID()) {
1317 assert(NextCodeChar <=
Offset);
1327 for (
unsigned I = 0; I < Refs.size(); ++I)
1336 AllRefs annotateAllReferences(llvm::StringRef
Code) {
1337 TestTU TU = newTU(
Code);
1338 auto AST = TU.build();
1340 std::vector<ReferenceLoc> Refs;
1341 for (
auto *TopLevel :
AST.getLocalTopLevelDecls())
1343 TopLevel, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1344 AST.getHeuristicResolver());
1345 return annotatedReferences(
Code,
AST, std::move(Refs));
1351 AllRefs annotateReferencesInFoo(llvm::StringRef
Code) {
1352 TestTU TU = newTU(
Code);
1353 auto AST = TU.build();
1355 if (
auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
1356 TestDecl =
T->getTemplatedDecl();
1358 std::vector<ReferenceLoc> Refs;
1359 if (
const auto *Func = llvm::dyn_cast<FunctionDecl>(TestDecl))
1362 [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1363 AST.getHeuristicResolver());
1364 else if (
const auto *NS = llvm::dyn_cast<NamespaceDecl>(TestDecl))
1367 [&Refs, &NS](ReferenceLoc R) {
1369 if (R.Targets.size() == 1 && R.Targets.front() == NS)
1371 Refs.push_back(std::move(R));
1373 AST.getHeuristicResolver());
1374 else if (
const auto *OC = llvm::dyn_cast<ObjCContainerDecl>(TestDecl))
1376 OC, [&Refs](ReferenceLoc R) { Refs.push_back(std::move(R)); },
1377 AST.getHeuristicResolver());
1379 ADD_FAILURE() <<
"Failed to find ::foo decl for test";
1381 return annotatedReferences(
Code,
AST, std::move(Refs));
1385TEST_F(FindExplicitReferencesTest, AllRefsInFoo) {
1386 std::pair< llvm::StringRef, llvm::StringRef> Cases[] =
1391 void foo(int param) {
1392 $0^global = $1^param + $2^func();
1395 "0: targets = {global}\n"
1396 "1: targets = {param}\n"
1397 "2: targets = {func}\n"},
1399 struct X { int a; };
1404 "0: targets = {x}\n"
1405 "1: targets = {X::a}\n"},
1407 // error-ok: testing with broken code
1410 return $0^bar() + $1^bar(42);
1413 "0: targets = {bar}\n"
1414 "1: targets = {bar}\n"},
1418 namespace alias = ns;
1420 using namespace $0^ns;
1421 using namespace $1^alias;
1424 "0: targets = {ns}\n"
1425 "1: targets = {alias}\n"},
1428 namespace ns { int global; }
1430 using $0^ns::$1^global;
1433 "0: targets = {ns}\n"
1434 "1: targets = {ns::global}, qualifier = 'ns::'\n"},
1437 namespace ns { enum class A {}; }
1439 using enum $0^ns::$1^A;
1442 "0: targets = {ns}\n"
1443 "1: targets = {ns::A}, qualifier = 'ns::'\n"},
1446 struct Struct { int a; };
1447 using Typedef = int;
1451 static_cast<$4^Struct*>(0);
1454 "0: targets = {Struct}\n"
1455 "1: targets = {x}, decl\n"
1456 "2: targets = {Typedef}\n"
1457 "3: targets = {y}, decl\n"
1458 "4: targets = {Struct}\n"},
1461 namespace a { namespace b { struct S { typedef int type; }; } }
1463 $0^a::$1^b::$2^S $3^x;
1464 using namespace $4^a::$5^b;
1468 "0: targets = {a}\n"
1469 "1: targets = {a::b}, qualifier = 'a::'\n"
1470 "2: targets = {a::b::S}, qualifier = 'a::b::'\n"
1471 "3: targets = {x}, decl\n"
1472 "4: targets = {a}\n"
1473 "5: targets = {a::b}, qualifier = 'a::'\n"
1474 "6: targets = {a::b::S}\n"
1475 "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
1476 "8: targets = {y}, decl\n"},
1479 $0^ten: // PRINT "HELLO WORLD!"
1483 "0: targets = {ten}, decl\n"
1484 "1: targets = {ten}\n"},
1487 template <class T> struct vector { using value_type = T; };
1488 template <> struct vector<bool> { using value_type = bool; };
1490 $0^vector<int> $1^vi;
1491 $2^vector<bool> $3^vb;
1494 "0: targets = {vector<int>}\n"
1495 "1: targets = {vi}, decl\n"
1496 "2: targets = {vector<bool>}\n"
1497 "3: targets = {vb}, decl\n"},
1500 template <class T> struct vector { using value_type = T; };
1501 template <> struct vector<bool> { using value_type = bool; };
1502 template <class T> using valias = vector<T>;
1504 $0^valias<int> $1^vi;
1505 $2^valias<bool> $3^vb;
1508 "0: targets = {valias}\n"
1509 "1: targets = {vi}, decl\n"
1510 "2: targets = {valias}\n"
1511 "3: targets = {vb}, decl\n"},
1515 template <typename $0^T>
1522 "0: targets = {foo::Bar::T}, decl\n"
1523 "1: targets = {foo::Bar}, decl\n"
1524 "2: targets = {foo::Bar}\n"
1525 "3: targets = {foo::Bar::f}, decl\n"
1526 "4: targets = {foo::Bar}\n"},
1529 struct X { void func(int); };
1537 "0: targets = {y}\n"
1538 "1: targets = {Y::func}\n"},
1541 namespace ns { void bar(int); }
1548 "0: targets = {bar}\n"},
1554 void foo(int a, int b) {
1558 "0: targets = {a}\n"
1559 "1: targets = {b}\n"},
1568 for (int $0^x : $1^vector()) {
1573 "0: targets = {x}, decl\n"
1574 "1: targets = {vector}\n"
1575 "2: targets = {x}\n"},
1578 namespace ns1 { void func(char*); }
1579 namespace ns2 { void func(int*); }
1580 using namespace ns1;
1581 using namespace ns2;
1588 "0: targets = {ns1::func, ns2::func}\n"
1589 "1: targets = {t}\n"},
1598 void foo(X x, T t) {
1602 "0: targets = {x}\n"
1603 "1: targets = {X::func, X::func}\n"
1604 "2: targets = {t}\n"},
1614 $0^S<$1^T>::$2^value;
1617 "0: targets = {S}\n"
1618 "1: targets = {T}\n"
1619 "2: targets = {S::value}, qualifier = 'S<T>::'\n"},
1632 "0: targets = {t}\n"
1633 "1: targets = {S::value}\n"},
1638 static_cast<$0^T>(0);
1643 "0: targets = {T}\n"
1644 "1: targets = {T}\n"
1645 "2: targets = {T}\n"
1646 "3: targets = {t}, decl\n"},
1654 "0: targets = {x}, decl\n"
1655 "1: targets = {I}\n"},
1658 template <class T> struct vector {};
1660 template <template<class> class TT, template<class> class ...TP>
1664 $4^foo<$5^vector>();
1668 "0: targets = {TT}\n"
1669 "1: targets = {x}, decl\n"
1670 "2: targets = {foo}\n"
1671 "3: targets = {TT}\n"
1672 "4: targets = {foo}\n"
1673 "5: targets = {vector}\n"
1674 "6: targets = {foo}\n"
1675 "7: targets = {TP}\n"},
1679 template <int(*)()> struct wrapper {};
1681 template <int(*FuncParam)()>
1683 $0^wrapper<$1^func> $2^w;
1687 "0: targets = {wrapper<&func>}\n"
1688 "1: targets = {func}\n"
1689 "2: targets = {w}, decl\n"
1690 "3: targets = {FuncParam}\n"},
1696 class $0^Foo { $1^Foo(); ~$2^Foo(); int $3^field; };
1698 enum $5^E { $6^ABC };
1700 using $8^INT2 = int;
1701 namespace $9^NS = $10^ns;
1704 "0: targets = {Foo}, decl\n"
1705 "1: targets = {foo()::Foo::Foo}, decl\n"
1706 "2: targets = {Foo}\n"
1707 "3: targets = {foo()::Foo::field}, decl\n"
1708 "4: targets = {Var}, decl\n"
1709 "5: targets = {E}, decl\n"
1710 "6: targets = {foo()::ABC}, decl\n"
1711 "7: targets = {INT}, decl\n"
1712 "8: targets = {INT2}, decl\n"
1713 "9: targets = {NS}, decl\n"
1714 "10: targets = {ns}\n"},
1721 // FIXME: This should have only one reference to Bar.
1722 $2^operator $3^$4^Bar();
1726 $7^f.$8^operator $9^Bar();
1729 "0: targets = {Bar}, decl\n"
1730 "1: targets = {Foo}, decl\n"
1731 "2: targets = {foo()::Foo::operator Bar}, decl\n"
1732 "3: targets = {Bar}\n"
1733 "4: targets = {Bar}\n"
1734 "5: targets = {Foo}\n"
1735 "6: targets = {f}, decl\n"
1736 "7: targets = {f}\n"
1737 "8: targets = {foo()::Foo::operator Bar}\n"
1738 "9: targets = {Bar}\n"},
1746 void $2^destructMe() {
1752 $6^f.~ /*...*/ $7^Foo();
1755 "0: targets = {Foo}, decl\n"
1758 "1: targets = {Foo}\n"
1759 "2: targets = {foo()::Foo::destructMe}, decl\n"
1760 "3: targets = {Foo}\n"
1761 "4: targets = {Foo}\n"
1762 "5: targets = {f}, decl\n"
1763 "6: targets = {f}\n"
1764 "7: targets = {Foo}\n"},
1769 // member initializer
1775 class $4^Derived : public $5^Base {
1777 $8^Derived() : $9^Base() {}
1779 // delegating initializer
1782 $12^Foo(): $13^Foo(111) {}
1786 "0: targets = {X}, decl\n"
1787 "1: targets = {foo()::X::abc}, decl\n"
1788 "2: targets = {foo()::X::X}, decl\n"
1789 "3: targets = {foo()::X::abc}\n"
1790 "4: targets = {Derived}, decl\n"
1791 "5: targets = {Base}\n"
1792 "6: targets = {Base}\n"
1793 "7: targets = {foo()::Derived::B}, decl\n"
1794 "8: targets = {foo()::Derived::Derived}, decl\n"
1795 "9: targets = {Base}\n"
1796 "10: targets = {Foo}, decl\n"
1797 "11: targets = {foo()::Foo::Foo}, decl\n"
1798 "12: targets = {foo()::Foo::Foo}, decl\n"
1799 "13: targets = {Foo}\n"},
1805 int (*$2^fptr)(int $3^a, int) = nullptr;
1808 "0: targets = {(unnamed)}\n"
1809 "1: targets = {x}, decl\n"
1810 "2: targets = {fptr}, decl\n"
1811 "3: targets = {a}, decl\n"},
1815 namespace ns { struct Type {}; }
1816 namespace alias = ns;
1817 namespace rec_alias = alias;
1820 $0^ns::$1^Type $2^a;
1821 $3^alias::$4^Type $5^b;
1822 $6^rec_alias::$7^Type $8^c;
1825 "0: targets = {ns}\n"
1826 "1: targets = {ns::Type}, qualifier = 'ns::'\n"
1827 "2: targets = {a}, decl\n"
1828 "3: targets = {alias}\n"
1829 "4: targets = {ns::Type}, qualifier = 'alias::'\n"
1830 "5: targets = {b}, decl\n"
1831 "6: targets = {rec_alias}\n"
1832 "7: targets = {ns::Type}, qualifier = 'rec_alias::'\n"
1833 "8: targets = {c}, decl\n"},
1837 template <typename... E>
1839 constexpr int $0^size = sizeof...($1^E);
1842 "0: targets = {size}, decl\n"
1843 "1: targets = {E}\n"},
1847 template <typename T>
1855 "0: targets = {Test}\n"
1856 "1: targets = {a}, decl\n"},
1860 template <typename $0^T>
1864 "0: targets = {foo::Bar::T}, decl\n"
1865 "1: targets = {foo::Bar}, decl\n"},
1869 template <typename $0^T>
1873 "0: targets = {T}, decl\n"
1874 "1: targets = {foo::func}, decl\n"},
1878 template <typename $0^T>
1882 "0: targets = {foo::T}, decl\n"
1883 "1: targets = {foo::T}\n"
1884 "2: targets = {foo::x}, decl\n"},
1887 template<typename T> class vector {};
1889 template <typename $0^T>
1890 using $1^V = $2^vector<$3^T>;
1893 "0: targets = {foo::T}, decl\n"
1894 "1: targets = {foo::V}, decl\n"
1895 "2: targets = {vector}\n"
1896 "3: targets = {foo::T}\n"},
1900 template <typename T>
1901 concept Drawable = requires (T t) { t.draw(); };
1904 template <typename $0^T> requires $1^Drawable<$2^T>
1905 void $3^bar($4^T $5^t) {
1910 "0: targets = {T}, decl\n"
1911 "1: targets = {Drawable}\n"
1912 "2: targets = {T}\n"
1913 "3: targets = {foo::bar}, decl\n"
1914 "4: targets = {T}\n"
1915 "5: targets = {t}, decl\n"
1916 "6: targets = {t}\n"
1917 "7: targets = {}\n"},
1931 "0: targets = {f}\n"
1932 "1: targets = {I::_z}\n"},
1937 @property(retain) I* x;
1938 @property(retain) I* y;
1945 "0: targets = {f}\n"
1946 "1: targets = {I::x}\n"
1947 "2: targets = {I::y}\n"},
1960 "0: targets = {f}\n"
1961 "1: targets = {I::x}\n"
1962 "2: targets = {I::setY:}\n"},
1967 @property(class) I *x;
1972 $2^local = $3^I.$4^x;
1975 "0: targets = {I}\n"
1976 "1: targets = {I::setX:}\n"
1977 "2: targets = {local}\n"
1978 "3: targets = {I}\n"
1979 "4: targets = {I::x}\n"},
1990 $2^local = $3^I.$4^x;
1993 "0: targets = {I}\n"
1994 "1: targets = {I::setX:}\n"
1995 "2: targets = {local}\n"
1996 "3: targets = {I}\n"
1997 "4: targets = {I::x}\n"},
2001 -(void) a:(int)x b:(int)y;
2007 "0: targets = {i}\n"
2008 "1: targets = {I::a:b:}\n"},
2019 "0: targets = {I}\n"
2020 "1: targets = {P}\n"
2021 "2: targets = {x}, decl\n"},
2029 $2^Foo $3^f { .$4^Bar = 42 };
2032 "0: targets = {Foo}, decl\n"
2033 "1: targets = {foo()::Foo::Bar}, decl\n"
2034 "2: targets = {Foo}\n"
2035 "3: targets = {f}, decl\n"
2036 "4: targets = {foo()::Foo::Bar}\n"},
2045 $5^Bar $6^bar { .$7^Foo.$8^Field = 42 };
2048 "0: targets = {Baz}, decl\n"
2049 "1: targets = {foo()::Baz::Field}, decl\n"
2050 "2: targets = {Bar}, decl\n"
2051 "3: targets = {Baz}\n"
2052 "4: targets = {foo()::Bar::Foo}, decl\n"
2053 "5: targets = {Bar}\n"
2054 "6: targets = {bar}, decl\n"
2055 "7: targets = {foo()::Bar::Foo}\n"
2056 "8: targets = {foo()::Baz::Field}\n"},
2058 template<typename T>
2060 template<typename T>
2062 $0^crash({.$1^x = $2^T()});
2065 "0: targets = {crash}\n"
2067 "2: targets = {T}\n"},
2070 template <template <typename> typename T>
2073 template <typename $0^T>
2074 struct $1^Derive : $2^Base<$3^T::template $4^Unknown> {};
2077 "0: targets = {foo::Derive::T}, decl\n"
2078 "1: targets = {foo::Derive}, decl\n"
2079 "2: targets = {Base}\n"
2080 "3: targets = {foo::Derive::T}\n"
2081 "4: targets = {}, qualifier = 'T::'\n"},
2085 template <typename $0^T>
2087 template <typename $2^I>
2090 template <typename $5^I>
2091 $6^Test($7^I) -> $8^Test<typename $9^I::$10^type>;
2094 "0: targets = {T}, decl\n"
2095 "1: targets = {foo::Test}, decl\n"
2096 "2: targets = {I}, decl\n"
2097 "3: targets = {foo::Test::Test<T>}, decl\n"
2098 "4: targets = {I}\n"
2099 "5: targets = {I}, decl\n"
2100 "6: targets = {foo::Test}\n"
2101 "7: targets = {I}\n"
2102 "8: targets = {foo::Test}\n"
2103 "9: targets = {I}\n"
2104 "10: targets = {}, qualifier = 'I::'\n"}};
2106 for (
const auto &
C : Cases) {
2107 llvm::StringRef ExpectedCode =
C.first;
2108 llvm::StringRef ExpectedRefs =
C.second;
2111 annotateReferencesInFoo(llvm::Annotations(ExpectedCode).code());
2112 EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
2113 EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
2117TEST_F(FindExplicitReferencesTest, AllRefs) {
2118 std::pair< llvm::StringRef, llvm::StringRef> Cases[] =
2120 @interface $0^MyClass
2122 @implementation $1^$2^MyClass
2125 "0: targets = {MyClass}, decl\n"
2126 "1: targets = {MyClass}\n"
2127 "2: targets = {MyClass}, decl\n"},
2129 @interface $0^MyClass
2131 @interface $1^MyClass ($2^Category)
2133 @implementation $3^MyClass ($4^$5^Category)
2136 "0: targets = {MyClass}, decl\n"
2137 "1: targets = {MyClass}\n"
2138 "2: targets = {Category}, decl\n"
2139 "3: targets = {MyClass}\n"
2140 "4: targets = {Category}\n"
2141 "5: targets = {Category}, decl\n"}};
2143 for (
const auto &
C : Cases) {
2144 llvm::StringRef ExpectedCode =
C.first;
2145 llvm::StringRef ExpectedRefs =
C.second;
2147 auto Actual = annotateAllReferences(llvm::Annotations(ExpectedCode).code());
2148 EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
2149 EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
llvm::SmallString< 256U > Name
#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)