Debian Codegraph @

llvm-project/clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

raw
1 //===--- WalkASTTest.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 "AnalysisInternal.h"
9 #include "clang/AST/ASTContext.h"
10 #include "clang/Basic/FileManager.h"
11 #include "clang/Basic/SourceLocation.h"
12 #include "clang/Frontend/TextDiagnostic.h"
13 #include "clang/Testing/TestAST.h"
14 #include "llvm/ADT/ArrayRef.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Support/Error.h"
17 #include "llvm/Support/ScopedPrinter.h"
18 #include "llvm/Testing/Annotations/Annotations.h"
19 #include "gtest/gtest.h"
20 #include <cstddef>
21 #include <unordered_map>
22 #include <utility>
23 #include <vector>
24
25 namespace clang::include_cleaner {
26 namespace {
27
28 // Specifies a test of which symbols are referenced by a piece of code.
29 // Target should contain points annotated with the reference kind.
30 // Example:
31 // Target: int $explicit^foo();
32 // Referencing: int x = ^foo();
33 // There must be exactly one referencing location marked.
34 void testWalk(llvm::StringRef TargetCode, llvm::StringRef ReferencingCode) {
35 llvm::Annotations Target(TargetCode);
36 llvm::Annotations Referencing(ReferencingCode);
37
38 TestInputs Inputs(Referencing.code());
39 Inputs.ExtraFiles["target.h"] = Target.code().str();
40 Inputs.ExtraArgs.push_back("-include");
41 Inputs.ExtraArgs.push_back("target.h");
42 Inputs.ExtraArgs.push_back("-std=c++17");
43 TestAST AST(Inputs);
44 const auto &SM = AST.sourceManager();
45
46 // We're only going to record references from the nominated point,
47 // to the target file.
48 FileID ReferencingFile = SM.getMainFileID();
49 SourceLocation ReferencingLoc =
50 SM.getComposedLoc(ReferencingFile, Referencing.point());
51 FileID TargetFile = SM.translateFile(
52 llvm::cantFail(AST.fileManager().getFileRef("target.h")));
53
54 // Perform the walk, and capture the offsets of the referenced targets.
55 std::unordered_map<RefType, std::vector<size_t>> ReferencedOffsets;
56 for (Decl *D : AST.context().getTranslationUnitDecl()->decls()) {
57 if (ReferencingFile != SM.getDecomposedExpansionLoc(D->getLocation()).first)
58 continue;
59 walkAST(*D, [&](SourceLocation Loc, NamedDecl &ND, RefType RT) {
60 if (SM.getFileLoc(Loc) != ReferencingLoc)
61 return;
62 auto NDLoc = SM.getDecomposedLoc(SM.getFileLoc(ND.getLocation()));
63 if (NDLoc.first != TargetFile)
64 return;
65 ReferencedOffsets[RT].push_back(NDLoc.second);
66 });
67 }
68 for (auto &Entry : ReferencedOffsets)
69 llvm::sort(Entry.second);
70
71 // Compare results to the expected points.
72 // For each difference, show the target point in context, like a diagnostic.
73 std::string DiagBuf;
74 llvm::raw_string_ostream DiagOS(DiagBuf);
75 auto *DiagOpts = new DiagnosticOptions();
76 DiagOpts->ShowLevel = 0;
77 DiagOpts->ShowNoteIncludeStack = 0;
78 TextDiagnostic Diag(DiagOS, AST.context().getLangOpts(), DiagOpts);
79 auto DiagnosePoint = [&](llvm::StringRef Message, unsigned Offset) {
80 Diag.emitDiagnostic(
81 FullSourceLoc(SM.getComposedLoc(TargetFile, Offset), SM),
82 DiagnosticsEngine::Note, Message, {}, {});
83 };
84 for (auto RT : {RefType::Explicit, RefType::Implicit, RefType::Ambiguous}) {
85 auto RTStr = llvm::to_string(RT);
86 for (auto Expected : Target.points(RTStr))
87 if (!llvm::is_contained(ReferencedOffsets[RT], Expected))
88 DiagnosePoint("location not marked used with type " + RTStr, Expected);
89 for (auto Actual : ReferencedOffsets[RT])
90 if (!llvm::is_contained(Target.points(RTStr), Actual))
91 DiagnosePoint("location unexpectedly used with type " + RTStr, Actual);
92 }
93
94 // If there were any differences, we print the entire referencing code once.
95 if (!DiagBuf.empty())
96 ADD_FAILURE() << DiagBuf << "\nfrom code:\n" << ReferencingCode;
97 }
98
99 TEST(WalkAST, DeclRef) {
100 testWalk("int $explicit^x;", "int y = ^x;");
101 testWalk("int $explicit^foo();", "int y = ^foo();");
102 testWalk("namespace ns { int $explicit^x; }", "int y = ns::^x;");
103 testWalk("struct S { static int $explicit^x; };", "int y = S::^x;");
104 // Canonical declaration only.
105 testWalk("extern int $explicit^x; int x;", "int y = ^x;");
106 // Return type of `foo` isn't used.
107 testWalk("struct S{}; S $explicit^foo();", "auto bar() { return ^foo(); }");
108 }
109
110 TEST(WalkAST, TagType) {
111 testWalk("struct $explicit^S {};", "^S *y;");
112 testWalk("enum $explicit^E {};", "^E *y;");
113 testWalk("struct $explicit^S { static int x; };", "int y = ^S::x;");
114 }
115
116 TEST(WalkAST, Alias) {
117 testWalk(R"cpp(
118 namespace ns { int x; }
119 using ns::$explicit^x;
120 )cpp",
121 "int y = ^x;");
122 testWalk("using $explicit^foo = int;", "^foo x;");
123 testWalk("struct S {}; using $explicit^foo = S;", "^foo x;");
124 }
125
126 TEST(WalkAST, Using) {
127 // We should report unused overloads as ambiguous.
128 testWalk(R"cpp(
129 namespace ns {
130 void $explicit^x(); void $ambiguous^x(int); void $ambiguous^x(char);
131 })cpp",
132 "using ns::^x; void foo() { x(); }");
133 testWalk(R"cpp(
134 namespace ns {
135 void $ambiguous^x(); void $ambiguous^x(int); void $ambiguous^x(char);
136 })cpp",
137 "using ns::^x;");
138 testWalk("namespace ns { struct S; } using ns::$explicit^S;", "^S *s;");
139
140 testWalk(R"cpp(
141 namespace ns {
142 template<class T>
143 class $ambiguous^Y {};
144 })cpp",
145 "using ns::^Y;");
146 testWalk(R"cpp(
147 namespace ns {
148 template<class T>
149 class Y {};
150 }
151 using ns::$explicit^Y;)cpp",
152 "^Y<int> x;");
153 }
154
155 TEST(WalkAST, Namespaces) {
156 testWalk("namespace ns { void x(); }", "using namespace ^ns;");
157 }
158
159 TEST(WalkAST, TemplateNames) {
160 testWalk("template<typename> struct $explicit^S {};", "^S<int> s;");
161 // FIXME: Template decl has the wrong primary location for type-alias template
162 // decls.
163 testWalk(R"cpp(
164 template <typename> struct S {};
165 template <typename T> $explicit^using foo = S<T>;)cpp",
166 "^foo<int> x;");
167 testWalk(R"cpp(
168 namespace ns {template <typename> struct S {}; }
169 using ns::$explicit^S;)cpp",
170 "^S<int> x;");
171 testWalk("template<typename> struct $explicit^S {};",
172 R"cpp(
173 template <template <typename> typename> struct X {};
174 X<^S> x;)cpp");
175 testWalk("template<typename T> struct $explicit^S { S(T); };", "^S s(42);");
176 // Should we mark the specialization instead?
177 testWalk(
178 "template<typename> struct $explicit^S {}; template <> struct S<int> {};",
179 "^S<int> s;");
180 }
181
182 TEST(WalkAST, MemberExprs) {
183 testWalk("struct $implicit^S { void foo(); };", "void foo() { S{}.^foo(); }");
184 testWalk(
185 "struct S { void foo(); }; struct $implicit^X : S { using S::foo; };",
186 "void foo() { X{}.^foo(); }");
187 testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
188 "void fun(Derived d) { d.^a; }");
189 testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
190 "void fun(Derived* d) { d->^a; }");
191 testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
192 "void fun(Derived& d) { d.^a; }");
193 testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
194 "void fun() { Derived().^a; }");
195 testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
196 "Derived foo(); void fun() { foo().^a; }");
197 testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
198 "Derived& foo(); void fun() { foo().^a; }");
199 testWalk(R"cpp(
200 template <typename T>
201 struct unique_ptr {
202 T *operator->();
203 };
204 struct $implicit^Foo { int a; };)cpp",
205 "void test(unique_ptr<Foo> &V) { V->^a; }");
206 testWalk(R"cpp(
207 template <typename T>
208 struct $implicit^unique_ptr {
209 void release();
210 };
211 struct Foo {};)cpp",
212 "void test(unique_ptr<Foo> &V) { V.^release(); }");
213 // Respect the sugar type (typedef, using-type).
214 testWalk(R"cpp(
215 namespace ns { struct Foo { int a; }; }
216 using $implicit^Bar = ns::Foo;)cpp",
217 "void test(Bar b) { b.^a; }");
218 testWalk(R"cpp(
219 namespace ns { struct Foo { int a; }; }
220 using ns::$implicit^Foo;)cpp",
221 "void test(Foo b) { b.^a; }");
222 testWalk(R"cpp(
223 namespace ns { struct Foo { int a; }; }
224 namespace ns2 { using Bar = ns::Foo; }
225 using ns2::$implicit^Bar;
226 )cpp",
227 "void test(Bar b) { b.^a; }");
228 testWalk(R"cpp(
229 namespace ns { template<typename> struct Foo { int a; }; }
230 using ns::$implicit^Foo;)cpp",
231 "void k(Foo<int> b) { b.^a; }");
232 // Test the dependent-type case (CXXDependentScopeMemberExpr)
233 testWalk("template<typename T> struct $implicit^Base { void method(); };",
234 "template<typename T> void k(Base<T> t) { t.^method(); }");
235 testWalk("template<typename T> struct $implicit^Base { void method(); };",
236 "template<typename T> void k(Base<T>& t) { t.^method(); }");
237 testWalk("template<typename T> struct $implicit^Base { void method(); };",
238 "template<typename T> void k(Base<T>* t) { t->^method(); }");
239 }
240
241 TEST(WalkAST, ConstructExprs) {
242 testWalk("struct $implicit^S {};", "S ^t;");
243 testWalk("struct $implicit^S { S(); };", "S ^t;");
244 testWalk("struct $explicit^S { S(int); };", "S ^t(42);");
245 testWalk("struct $implicit^S { S(int); };", "S t = ^42;");
246 testWalk("namespace ns { struct S{}; } using ns::$implicit^S;", "S ^t;");
247 }
248
249 TEST(WalkAST, Operator) {
250 // References to operators are not counted as uses.
251 testWalk("struct string {}; int operator+(string, string);",
252 "int k = string() ^+ string();");
253 testWalk("struct string {int operator+(string); }; ",
254 "int k = string() ^+ string();");
255 testWalk("struct string { friend int operator+(string, string); }; ",
256 "int k = string() ^+ string();");
257 }
258
259 TEST(WalkAST, Functions) {
260 // Definition uses declaration, not the other way around.
261 testWalk("void $explicit^foo();", "void ^foo() {}");
262 testWalk("void foo() {}", "void ^foo();");
263
264 // Unresolved calls marks all the overloads.
265 testWalk("void $ambiguous^foo(int); void $ambiguous^foo(char);",
266 "template <typename T> void bar() { ^foo(T{}); }");
267 }
268
269 TEST(WalkAST, Enums) {
270 testWalk("enum E { $explicit^A = 42, B = 43 };", "int e = ^A;");
271 testWalk("enum class $explicit^E : int;", "enum class ^E : int {};");
272 testWalk("enum class E : int {};", "enum class ^E : int ;");
273 }
274
275 } // namespace
276 } // namespace clang::include_cleaner