1 | //===- unittest/Tooling/LexicallyOrderedRecursiveASTVisitorTest.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 | #include "clang/AST/LexicallyOrderedRecursiveASTVisitor.h" |
11 | #include <stack> |
12 | |
13 | using namespace clang; |
14 | |
15 | namespace { |
16 | |
17 | class DummyMatchVisitor; |
18 | |
19 | class LexicallyOrderedDeclVisitor |
20 | : public LexicallyOrderedRecursiveASTVisitor<LexicallyOrderedDeclVisitor> { |
21 | public: |
22 | LexicallyOrderedDeclVisitor(DummyMatchVisitor &Matcher, |
23 | const SourceManager &SM, bool EmitDeclIndices, |
24 | bool EmitStmtIndices) |
25 | : LexicallyOrderedRecursiveASTVisitor(SM), Matcher(Matcher), |
26 | EmitDeclIndices(EmitDeclIndices), EmitStmtIndices(EmitStmtIndices) {} |
27 | |
28 | bool TraverseDecl(Decl *D) { |
29 | TraversalStack.push_back(Elt: D); |
30 | LexicallyOrderedRecursiveASTVisitor::TraverseDecl(D); |
31 | TraversalStack.pop_back(); |
32 | return true; |
33 | } |
34 | |
35 | bool TraverseStmt(Stmt *S); |
36 | |
37 | bool VisitNamedDecl(const NamedDecl *D); |
38 | bool VisitDeclRefExpr(const DeclRefExpr *D); |
39 | |
40 | private: |
41 | DummyMatchVisitor &Matcher; |
42 | bool EmitDeclIndices, EmitStmtIndices; |
43 | unsigned Index = 0; |
44 | llvm::SmallVector<Decl *, 8> TraversalStack; |
45 | }; |
46 | |
47 | class DummyMatchVisitor : public ExpectedLocationVisitor { |
48 | bool EmitDeclIndices, EmitStmtIndices; |
49 | |
50 | public: |
51 | DummyMatchVisitor(bool EmitDeclIndices = false, bool EmitStmtIndices = false) |
52 | : EmitDeclIndices(EmitDeclIndices), EmitStmtIndices(EmitStmtIndices) {} |
53 | |
54 | bool VisitTranslationUnitDecl(TranslationUnitDecl *TU) override { |
55 | const ASTContext &Context = TU->getASTContext(); |
56 | const SourceManager &SM = Context.getSourceManager(); |
57 | LexicallyOrderedDeclVisitor SubVisitor(*this, SM, EmitDeclIndices, |
58 | EmitStmtIndices); |
59 | SubVisitor.TraverseDecl(TU); |
60 | return false; |
61 | } |
62 | |
63 | template <class T> void match(StringRef Path, const T *D) { |
64 | Match(Name: Path, Location: D->getBeginLoc()); |
65 | } |
66 | }; |
67 | |
68 | bool LexicallyOrderedDeclVisitor::TraverseStmt(Stmt *S) { |
69 | Matcher.match(Path: "overridden TraverseStmt" , D: S); |
70 | return LexicallyOrderedRecursiveASTVisitor::TraverseStmt(S); |
71 | } |
72 | |
73 | bool LexicallyOrderedDeclVisitor::VisitNamedDecl(const NamedDecl *D) { |
74 | std::string Path; |
75 | llvm::raw_string_ostream OS(Path); |
76 | assert(TraversalStack.back() == D); |
77 | for (const Decl *D : TraversalStack) { |
78 | if (isa<TranslationUnitDecl>(Val: D)) { |
79 | OS << "/" ; |
80 | continue; |
81 | } |
82 | if (const auto *ND = dyn_cast<NamedDecl>(Val: D)) |
83 | OS << ND->getNameAsString(); |
84 | else |
85 | OS << "???" ; |
86 | if (isa<DeclContext>(Val: D) || isa<TemplateDecl>(Val: D)) |
87 | OS << "/" ; |
88 | } |
89 | if (EmitDeclIndices) |
90 | OS << "@" << Index++; |
91 | Matcher.match(Path, D); |
92 | return true; |
93 | } |
94 | |
95 | bool LexicallyOrderedDeclVisitor::VisitDeclRefExpr(const DeclRefExpr *D) { |
96 | std::string Name = D->getFoundDecl()->getNameAsString(); |
97 | llvm::raw_string_ostream OS(Name); |
98 | if (EmitStmtIndices) |
99 | OS << "@" << Index++; |
100 | Matcher.match(Path: Name, D); |
101 | return true; |
102 | } |
103 | |
104 | TEST(LexicallyOrderedRecursiveASTVisitor, VisitDeclsInImplementation) { |
105 | StringRef Source = R"( |
106 | @interface I |
107 | @end |
108 | @implementation I |
109 | |
110 | void nestedFunction() { } |
111 | |
112 | - (void) method{ } |
113 | |
114 | int anotherNestedFunction(int x) { |
115 | return x; |
116 | } |
117 | |
118 | int innerVariable = 0; |
119 | |
120 | @end |
121 | |
122 | int outerVariable = 0; |
123 | |
124 | @implementation I(Cat) |
125 | |
126 | void catF() { } |
127 | |
128 | @end |
129 | |
130 | void outerFunction() { } |
131 | )" ; |
132 | DummyMatchVisitor Visitor; |
133 | Visitor.DisallowMatch("/nestedFunction/" , 6, 1); |
134 | Visitor.ExpectMatch("/I/nestedFunction/" , 6, 1); |
135 | Visitor.ExpectMatch("/I/method/" , 8, 1); |
136 | Visitor.DisallowMatch("/anotherNestedFunction/" , 10, 1); |
137 | Visitor.ExpectMatch("/I/anotherNestedFunction/" , 10, 1); |
138 | Visitor.DisallowMatch("/innerVariable" , 14, 1); |
139 | Visitor.ExpectMatch("/I/innerVariable" , 14, 1); |
140 | Visitor.ExpectMatch("/outerVariable" , 18, 1); |
141 | Visitor.DisallowMatch("/catF/" , 22, 1); |
142 | Visitor.ExpectMatch("/Cat/catF/" , 22, 1); |
143 | Visitor.ExpectMatch("/outerFunction/" , 26, 1); |
144 | EXPECT_TRUE(Visitor.runOver(Source, DummyMatchVisitor::Lang_OBJC)); |
145 | } |
146 | |
147 | TEST(LexicallyOrderedRecursiveASTVisitor, VisitMacroDeclsInImplementation) { |
148 | StringRef Source = R"( |
149 | @interface I |
150 | @end |
151 | |
152 | void outerFunction() { } |
153 | |
154 | #define MACRO_F(x) void nestedFunction##x() { } |
155 | |
156 | @implementation I |
157 | |
158 | MACRO_F(1) |
159 | |
160 | @end |
161 | |
162 | MACRO_F(2) |
163 | )" ; |
164 | DummyMatchVisitor Visitor; |
165 | Visitor.ExpectMatch("/outerFunction/" , 5, 1); |
166 | Visitor.ExpectMatch("/I/nestedFunction1/" , 7, 20); |
167 | Visitor.ExpectMatch("/nestedFunction2/" , 7, 20); |
168 | EXPECT_TRUE(Visitor.runOver(Source, DummyMatchVisitor::Lang_OBJC)); |
169 | } |
170 | |
171 | TEST(LexicallyOrderedRecursiveASTVisitor, VisitTemplateDecl) { |
172 | StringRef Source = R"( |
173 | template <class T> T f(); |
174 | template <class U, class = void> class Class {}; |
175 | )" ; |
176 | DummyMatchVisitor Visitor(/*EmitIndices=*/true); |
177 | Visitor.ExpectMatch("/f/T@1" , 2, 11); |
178 | Visitor.ExpectMatch("/f/f/@2" , 2, 20); |
179 | Visitor.ExpectMatch("/Class/U@4" , 3, 11); |
180 | Visitor.ExpectMatch("/Class/@5" , 3, 20); |
181 | Visitor.ExpectMatch("/Class/Class/@6" , 3, 34); |
182 | EXPECT_TRUE(Visitor.runOver(Source)); |
183 | } |
184 | |
185 | TEST(LexicallyOrderedRecursiveASTVisitor, VisitCXXOperatorCallExpr) { |
186 | StringRef Source = R"( |
187 | struct S { |
188 | S &operator+(S&); |
189 | S *operator->(); |
190 | S &operator++(); |
191 | S operator++(int); |
192 | void operator()(int, int); |
193 | void operator[](int); |
194 | void f(); |
195 | }; |
196 | S a, b, c; |
197 | |
198 | void test() { |
199 | a = b + c; |
200 | a->f(); |
201 | a(1, 2); |
202 | b[0]; |
203 | ++a; |
204 | b++; |
205 | } |
206 | )" ; |
207 | DummyMatchVisitor Visitor(/*EmitDeclIndices=*/false, |
208 | /*EmitStmtIndices=*/true); |
209 | // There are two overloaded operators that start at this point |
210 | // This makes sure they are both traversed using the overridden |
211 | // TraverseStmt, as the traversal is implemented by us for |
212 | // CXXOperatorCallExpr. |
213 | Visitor.ExpectMatch("overridden TraverseStmt" , 14, 3, 2); |
214 | Visitor.ExpectMatch("a@0" , 14, 3); |
215 | Visitor.ExpectMatch("operator=@1" , 14, 5); |
216 | Visitor.ExpectMatch("b@2" , 14, 7); |
217 | Visitor.ExpectMatch("operator+@3" , 14, 9); |
218 | Visitor.ExpectMatch("c@4" , 14, 11); |
219 | Visitor.ExpectMatch("operator->@6" , 15, 4); |
220 | Visitor.ExpectMatch("operator()@8" , 16, 4); |
221 | Visitor.ExpectMatch("operator[]@10" , 17, 4); |
222 | Visitor.ExpectMatch("operator++@11" , 18, 3); |
223 | Visitor.ExpectMatch("operator++@14" , 19, 4); |
224 | EXPECT_TRUE(Visitor.runOver(Source)); |
225 | } |
226 | |
227 | } // end anonymous namespace |
228 | |