1 //===- unittest/Tooling/QualTypeNameTest.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 "clang/AST/QualTypeNames.h"
10 #include "TestVisitor.h"
11 using namespace clang;
12
13 namespace {
14 struct TypeNameVisitor : TestVisitor<TypeNameVisitor> {
15 llvm::StringMap<std::string> ExpectedQualTypeNames;
16 bool WithGlobalNsPrefix = false;
17
18 // ValueDecls are the least-derived decl with both a qualtype and a name.
VisitValueDecl__anon46f6b3fa0111::TypeNameVisitor19 bool VisitValueDecl(const ValueDecl *VD) {
20 std::string ExpectedName =
21 ExpectedQualTypeNames.lookup(VD->getNameAsString());
22 if (ExpectedName != "") {
23 PrintingPolicy Policy(Context->getPrintingPolicy());
24 Policy.SuppressScope = false;
25 Policy.AnonymousTagLocations = true;
26 Policy.PolishForDeclaration = true;
27 Policy.SuppressUnwrittenScope = true;
28 std::string ActualName = TypeName::getFullyQualifiedName(
29 VD->getType(), *Context, Policy, WithGlobalNsPrefix);
30 if (ExpectedName != ActualName) {
31 // A custom message makes it much easier to see what declaration
32 // failed compared to EXPECT_EQ.
33 ADD_FAILURE() << "Typename::getFullyQualifiedName failed for "
34 << VD->getQualifiedNameAsString() << std::endl
35 << " Actual: " << ActualName << std::endl
36 << " Exepcted: " << ExpectedName;
37 }
38 }
39 return true;
40 }
41 };
42
43 // named namespaces inside anonymous namespaces
44
TEST(QualTypeNameTest,getFullyQualifiedName)45 TEST(QualTypeNameTest, getFullyQualifiedName) {
46 TypeNameVisitor Visitor;
47 // Simple case to test the test framework itself.
48 Visitor.ExpectedQualTypeNames["CheckInt"] = "int";
49
50 // Keeping the names of the variables whose types we check unique
51 // within the entire test--regardless of their own scope--makes it
52 // easier to diagnose test failures.
53
54 // Simple namespace qualifier
55 Visitor.ExpectedQualTypeNames["CheckA"] = "A::B::Class0";
56 // Lookup up the enclosing scopes, then down another one. (These
57 // appear as elaborated type in the AST. In that case--even if
58 // policy.SuppressScope = 0--qual_type.getAsString(policy) only
59 // gives the name as it appears in the source, not the full name.
60 Visitor.ExpectedQualTypeNames["CheckB"] = "A::B::C::Class1";
61 // Template parameter expansion.
62 Visitor.ExpectedQualTypeNames["CheckC"] =
63 "A::B::Template0<A::B::C::MyInt, A::B::AnotherClass>";
64 // Recursive template parameter expansion.
65 Visitor.ExpectedQualTypeNames["CheckD"] =
66 "A::B::Template0<A::B::Template1<A::B::C::MyInt, A::B::AnotherClass>, "
67 "A::B::Template0<int, long>>";
68 // Variadic Template expansion.
69 Visitor.ExpectedQualTypeNames["CheckE"] =
70 "A::Variadic<int, A::B::Template0<int, char>, "
71 "A::B::Template1<int, long>, A::B::C::MyInt>";
72 // Using declarations should be fully expanded.
73 Visitor.ExpectedQualTypeNames["CheckF"] = "A::B::Class0";
74 // Elements found within "using namespace foo;" should be fully
75 // expanded.
76 Visitor.ExpectedQualTypeNames["CheckG"] = "A::B::C::MyInt";
77 // Type inside function
78 Visitor.ExpectedQualTypeNames["CheckH"] = "struct X";
79 // Anonymous Namespaces
80 Visitor.ExpectedQualTypeNames["CheckI"] = "aClass";
81 // Keyword inclusion with namespaces
82 Visitor.ExpectedQualTypeNames["CheckJ"] = "struct A::aStruct";
83 // Anonymous Namespaces nested in named namespaces and vice-versa.
84 Visitor.ExpectedQualTypeNames["CheckK"] = "D::aStruct";
85 // Namespace alias
86 Visitor.ExpectedQualTypeNames["CheckL"] = "A::B::C::MyInt";
87 Visitor.ExpectedQualTypeNames["non_dependent_type_var"] =
88 "Foo<X>::non_dependent_type";
89 Visitor.ExpectedQualTypeNames["AnEnumVar"] = "EnumScopeClass::AnEnum";
90 Visitor.ExpectedQualTypeNames["AliasTypeVal"] = "A::B::C::InnerAlias<int>";
91 Visitor.ExpectedQualTypeNames["AliasInnerTypeVal"] =
92 "OuterTemplateClass<A::B::Class0>::Inner";
93 Visitor.ExpectedQualTypeNames["CheckM"] = "const A::B::Class0 *";
94 Visitor.ExpectedQualTypeNames["CheckN"] = "const X *";
95 Visitor.ExpectedQualTypeNames["ttp_using"] =
96 "OuterTemplateClass<A::B::Class0>";
97 Visitor.ExpectedQualTypeNames["alias_of_template"] = "ABTemplate0IntInt";
98 Visitor.runOver(
99 "int CheckInt;\n"
100 "template <typename T>\n"
101 "class OuterTemplateClass { public: struct Inner {}; };\n"
102 "namespace A {\n"
103 " namespace B {\n"
104 " class Class0 { };\n"
105 " namespace C {\n"
106 " typedef int MyInt;"
107 " template <typename T>\n"
108 " using InnerAlias = OuterTemplateClass<T>;\n"
109 " InnerAlias<int> AliasTypeVal;\n"
110 " InnerAlias<Class0>::Inner AliasInnerTypeVal;\n"
111 " }\n"
112 " template<class X, class Y> class Template0;"
113 " template<class X, class Y> class Template1;"
114 " typedef B::Class0 AnotherClass;\n"
115 " void Function1(Template0<C::MyInt,\n"
116 " AnotherClass> CheckC);\n"
117 " void Function2(Template0<Template1<C::MyInt, AnotherClass>,\n"
118 " Template0<int, long> > CheckD);\n"
119 " void Function3(const B::Class0* CheckM);\n"
120 " }\n"
121 "template<typename... Values> class Variadic {};\n"
122 "Variadic<int, B::Template0<int, char>, "
123 " B::Template1<int, long>, "
124 " B::C::MyInt > CheckE;\n"
125 " namespace BC = B::C;\n"
126 " BC::MyInt CheckL;\n"
127 "}\n"
128 "using A::B::Class0;\n"
129 "void Function(Class0 CheckF);\n"
130 "OuterTemplateClass<Class0> ttp_using;\n"
131 "using ABTemplate0IntInt = A::B::Template0<int, int>;\n"
132 "void Function(ABTemplate0IntInt alias_of_template);\n"
133 "using namespace A::B::C;\n"
134 "void Function(MyInt CheckG);\n"
135 "void f() {\n"
136 " struct X {} CheckH;\n"
137 "}\n"
138 "struct X;\n"
139 "void f(const ::X* CheckN) {}\n"
140 "namespace {\n"
141 " class aClass {};\n"
142 " aClass CheckI;\n"
143 "}\n"
144 "namespace A {\n"
145 " struct aStruct {} CheckJ;\n"
146 "}\n"
147 "namespace {\n"
148 " namespace D {\n"
149 " namespace {\n"
150 " class aStruct {};\n"
151 " aStruct CheckK;\n"
152 " }\n"
153 " }\n"
154 "}\n"
155 "template<class T> struct Foo {\n"
156 " typedef typename T::A dependent_type;\n"
157 " typedef int non_dependent_type;\n"
158 " dependent_type dependent_type_var;\n"
159 " non_dependent_type non_dependent_type_var;\n"
160 "};\n"
161 "struct X { typedef int A; };"
162 "Foo<X> var;"
163 "void F() {\n"
164 " var.dependent_type_var = 0;\n"
165 "var.non_dependent_type_var = 0;\n"
166 "}\n"
167 "class EnumScopeClass {\n"
168 "public:\n"
169 " enum AnEnum { ZERO, ONE };\n"
170 "};\n"
171 "EnumScopeClass::AnEnum AnEnumVar;\n",
172 TypeNameVisitor::Lang_CXX11);
173
174 TypeNameVisitor Complex;
175 Complex.ExpectedQualTypeNames["CheckTX"] = "B::TX";
176 Complex.runOver(
177 "namespace A {"
178 " struct X {};"
179 "}"
180 "using A::X;"
181 "namespace fake_std {"
182 " template<class... Types > class tuple {};"
183 "}"
184 "namespace B {"
185 " using fake_std::tuple;"
186 " typedef tuple<X> TX;"
187 " TX CheckTX;"
188 " struct A { typedef int X; };"
189 "}");
190
191 TypeNameVisitor DoubleUsing;
192 DoubleUsing.ExpectedQualTypeNames["direct"] = "a::A<0>";
193 DoubleUsing.ExpectedQualTypeNames["indirect"] = "b::B";
194 DoubleUsing.ExpectedQualTypeNames["double_indirect"] = "b::B";
195 DoubleUsing.runOver(R"cpp(
196 namespace a {
197 template<int> class A {};
198 A<0> direct;
199 }
200 namespace b {
201 using B = ::a::A<0>;
202 B indirect;
203 }
204 namespace b {
205 using ::b::B;
206 B double_indirect;
207 }
208 )cpp");
209
210 TypeNameVisitor GlobalNsPrefix;
211 GlobalNsPrefix.WithGlobalNsPrefix = true;
212 GlobalNsPrefix.ExpectedQualTypeNames["IntVal"] = "int";
213 GlobalNsPrefix.ExpectedQualTypeNames["BoolVal"] = "bool";
214 GlobalNsPrefix.ExpectedQualTypeNames["XVal"] = "::A::B::X";
215 GlobalNsPrefix.ExpectedQualTypeNames["IntAliasVal"] = "::A::B::Alias<int>";
216 GlobalNsPrefix.ExpectedQualTypeNames["ZVal"] = "::A::B::Y::Z";
217 GlobalNsPrefix.ExpectedQualTypeNames["GlobalZVal"] = "::Z";
218 GlobalNsPrefix.ExpectedQualTypeNames["CheckK"] = "D::aStruct";
219 GlobalNsPrefix.ExpectedQualTypeNames["YZMPtr"] = "::A::B::X ::A::B::Y::Z::*";
220 GlobalNsPrefix.runOver(
221 "namespace A {\n"
222 " namespace B {\n"
223 " int IntVal;\n"
224 " bool BoolVal;\n"
225 " struct X {};\n"
226 " X XVal;\n"
227 " template <typename T> class CCC { };\n"
228 " template <typename T>\n"
229 " using Alias = CCC<T>;\n"
230 " Alias<int> IntAliasVal;\n"
231 " struct Y { struct Z { X YZIPtr; }; };\n"
232 " Y::Z ZVal;\n"
233 " X Y::Z::*YZMPtr;\n"
234 " }\n"
235 "}\n"
236 "struct Z {};\n"
237 "Z GlobalZVal;\n"
238 "namespace {\n"
239 " namespace D {\n"
240 " namespace {\n"
241 " class aStruct {};\n"
242 " aStruct CheckK;\n"
243 " }\n"
244 " }\n"
245 "}\n"
246 );
247
248 TypeNameVisitor InlineNamespace;
249 InlineNamespace.ExpectedQualTypeNames["c"] = "B::C";
250 InlineNamespace.runOver("inline namespace A {\n"
251 " namespace B {\n"
252 " class C {};\n"
253 " }\n"
254 "}\n"
255 "using namespace A::B;\n"
256 "C c;\n",
257 TypeNameVisitor::Lang_CXX11);
258
259 TypeNameVisitor AnonStrucs;
260 AnonStrucs.ExpectedQualTypeNames["a"] = "short";
261 AnonStrucs.ExpectedQualTypeNames["un_in_st_1"] =
262 "union (unnamed struct at input.cc:1:1)::(unnamed union at "
263 "input.cc:2:27)";
264 AnonStrucs.ExpectedQualTypeNames["b"] = "short";
265 AnonStrucs.ExpectedQualTypeNames["un_in_st_2"] =
266 "union (unnamed struct at input.cc:1:1)::(unnamed union at "
267 "input.cc:5:27)";
268 AnonStrucs.ExpectedQualTypeNames["anon_st"] =
269 "struct (unnamed struct at input.cc:1:1)";
270 AnonStrucs.runOver(R"(struct {
271 union {
272 short a;
273 } un_in_st_1;
274 union {
275 short b;
276 } un_in_st_2;
277 } anon_st;)");
278 }
279
280 } // end anonymous namespace
281