RecursiveASTVisitorTestDeclVisitor.cpp source code [clang_source_code/unittests/Tooling/RecursiveASTVisitorTestDeclVisitor.cpp]

1	//===- unittest/Tooling/RecursiveASTVisitorTestDeclVisitor.cpp ------------===//
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
9	#include "TestVisitor.h"
10
11	using namespace clang;
12
13	namespace {
14
15	class VarDeclVisitor : public ExpectedLocationVisitor<VarDeclVisitor> {
16	public:
17	bool VisitVarDecl(VarDecl *Variable) {
18	Match(Variable->getNameAsString(), Variable->getBeginLoc());
19	return true;
20	}
21	};
22
23	TEST(RecursiveASTVisitor, VisitsCXXForRangeStmtLoopVariable) {
24	VarDeclVisitor Visitor;
25	Visitor.ExpectMatch("i", 2, 17);
26	EXPECT_TRUE(Visitor.runOver(
27	"int x[5];\n"
28	"void f() { for (int i : x) {} }",
29	VarDeclVisitor::Lang_CXX11));
30	}
31
32	class ParmVarDeclVisitorForImplicitCode :
33	public ExpectedLocationVisitor<ParmVarDeclVisitorForImplicitCode> {
34	public:
35	bool shouldVisitImplicitCode() const { return true; }
36
37	bool VisitParmVarDecl(ParmVarDecl *ParamVar) {
38	Match(ParamVar->getNameAsString(), ParamVar->getBeginLoc());
39	return true;
40	}
41	};
42
43	// Test RAV visits parameter variable declaration of the implicit
44	// copy assignment operator and implicit copy constructor.
45	TEST(RecursiveASTVisitor, VisitsParmVarDeclForImplicitCode) {
46	ParmVarDeclVisitorForImplicitCode Visitor;
47	// Match parameter variable name of implicit copy assignment operator and
48	// implicit copy constructor.
49	// This parameter name does not have a valid IdentifierInfo, and shares
50	// same SourceLocation with its class declaration, so we match an empty name
51	// with the class' source location.
52	Visitor.ExpectMatch("", 1, 7);
53	Visitor.ExpectMatch("", 3, 7);
54	EXPECT_TRUE(Visitor.runOver(
55	"class X {};\n"
56	"void foo(X a, X b) {a = b;}\n"
57	"class Y {};\n"
58	"void bar(Y a) {Y b = a;}"));
59	}
60
61	class NamedDeclVisitor
62	: public ExpectedLocationVisitor<NamedDeclVisitor> {
63	public:
64	bool VisitNamedDecl(NamedDecl *Decl) {
65	std::string NameWithTemplateArgs;
66	llvm::raw_string_ostream OS(NameWithTemplateArgs);
67	Decl->getNameForDiagnostic(OS,
68	Decl->getASTContext().getPrintingPolicy(),
69	true);
70	Match(OS.str(), Decl->getLocation());
71	return true;
72	}
73	};
74
75	TEST(RecursiveASTVisitor, VisitsPartialTemplateSpecialization) {
76	// From cfe-commits/Week-of-Mon-20100830/033998.html
77	// Contrary to the approach suggested in that email, we visit all
78	// specializations when we visit the primary template. Visiting them when we
79	// visit the associated specialization is problematic for specializations of
80	// template members of class templates.
81	NamedDeclVisitor Visitor;
82	Visitor.ExpectMatch("A<bool>", 1, 26);
83	Visitor.ExpectMatch("A<char *>", 2, 26);
84	EXPECT_TRUE(Visitor.runOver(
85	"template <class T> class A {};\n"
86	"template <class T> class A<T*> {};\n"
87	"A<bool> ab;\n"
88	"A<char*> acp;\n"));
89	}
90
91	TEST(RecursiveASTVisitor, VisitsUndefinedClassTemplateSpecialization) {
92	NamedDeclVisitor Visitor;
93	Visitor.ExpectMatch("A<int>", 1, 29);
94	EXPECT_TRUE(Visitor.runOver(
95	"template<typename T> struct A;\n"
96	"A<int> *p;\n"));
97	}
98
99	TEST(RecursiveASTVisitor, VisitsNestedUndefinedClassTemplateSpecialization) {
100	NamedDeclVisitor Visitor;
101	Visitor.ExpectMatch("A<int>::B<char>", 2, 31);
102	EXPECT_TRUE(Visitor.runOver(
103	"template<typename T> struct A {\n"
104	" template<typename U> struct B;\n"
105	"};\n"
106	"A<int>::B<char> *p;\n"));
107	}
108
109	TEST(RecursiveASTVisitor, VisitsUndefinedFunctionTemplateSpecialization) {
110	NamedDeclVisitor Visitor;
111	Visitor.ExpectMatch("A<int>", 1, 26);
112	EXPECT_TRUE(Visitor.runOver(
113	"template<typename T> int A();\n"
114	"int k = A<int>();\n"));
115	}
116
117	TEST(RecursiveASTVisitor, VisitsNestedUndefinedFunctionTemplateSpecialization) {
118	NamedDeclVisitor Visitor;
119	Visitor.ExpectMatch("A<int>::B<char>", 2, 35);
120	EXPECT_TRUE(Visitor.runOver(
121	"template<typename T> struct A {\n"
122	" template<typename U> static int B();\n"
123	"};\n"
124	"int k = A<int>::B<char>();\n"));
125	}
126
127	TEST(RecursiveASTVisitor, NoRecursionInSelfFriend) {
128	// From cfe-commits/Week-of-Mon-20100830/033977.html
129	NamedDeclVisitor Visitor;
130	Visitor.ExpectMatch("vector_iterator<int>", 2, 7);
131	EXPECT_TRUE(Visitor.runOver(
132	"template<typename Container>\n"
133	"class vector_iterator {\n"
134	" template <typename C> friend class vector_iterator;\n"
135	"};\n"
136	"vector_iterator<int> it_int;\n"));
137	}
138
139	} // end anonymous namespace
140

Clang Project