Debian Codegraph @

llvm-project/clang/unittests/AST/DeclTest.cpp

raw
1 //===- unittests/AST/DeclTest.cpp --- Declaration tests -------------------===//
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 // Unit tests for Decl nodes in the AST.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/Decl.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Mangle.h"
16 #include "clang/ASTMatchers/ASTMatchFinder.h"
17 #include "clang/ASTMatchers/ASTMatchers.h"
18 #include "clang/Basic/LLVM.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Lex/Lexer.h"
21 #include "clang/Tooling/Tooling.h"
22 #include "llvm/IR/DataLayout.h"
23 #include "llvm/Testing/Annotations/Annotations.h"
24 #include "gtest/gtest.h"
25
26 using namespace clang::ast_matchers;
27 using namespace clang::tooling;
28 using namespace clang;
29
30 TEST(Decl, CleansUpAPValues) {
31 MatchFinder Finder;
32 std::unique_ptr<FrontendActionFactory> Factory(
33 newFrontendActionFactory(&Finder));
34
35 // This is a regression test for a memory leak in APValues for structs that
36 // allocate memory. This test only fails if run under valgrind with full leak
37 // checking enabled.
38 std::vector<std::string> Args(1, "-std=c++11");
39 Args.push_back("-fno-ms-extensions");
40 ASSERT_TRUE(runToolOnCodeWithArgs(
41 Factory->create(),
42 "struct X { int a; }; constexpr X x = { 42 };"
43 "union Y { constexpr Y(int a) : a(a) {} int a; }; constexpr Y y = { 42 };"
44 "constexpr int z[2] = { 42, 43 };"
45 "constexpr int __attribute__((vector_size(16))) v1 = {};"
46 "\n#ifdef __SIZEOF_INT128__\n"
47 "constexpr __uint128_t large_int = 0xffffffffffffffff;"
48 "constexpr __uint128_t small_int = 1;"
49 "\n#endif\n"
50 "constexpr double d1 = 42.42;"
51 "constexpr long double d2 = 42.42;"
52 "constexpr _Complex long double c1 = 42.0i;"
53 "constexpr _Complex long double c2 = 42.0;"
54 "template<int N> struct A : A<N-1> {};"
55 "template<> struct A<0> { int n; }; A<50> a;"
56 "constexpr int &r = a.n;"
57 "constexpr int A<50>::*p = &A<50>::n;"
58 "void f() { foo: bar: constexpr int k = __builtin_constant_p(0) ?"
59 " (char*)&&foo - (char*)&&bar : 0; }",
60 Args));
61
62 // FIXME: Once this test starts breaking we can test APValue::needsCleanup
63 // for ComplexInt.
64 ASSERT_FALSE(runToolOnCodeWithArgs(
65 Factory->create(),
66 "constexpr _Complex __uint128_t c = 0xffffffffffffffff;",
67 Args));
68 }
69
70 TEST(Decl, AsmLabelAttr) {
71 // Create two method decls: `f` and `g`.
72 StringRef Code = R"(
73 struct S {
74 void f() {}
75 void g() {}
76 };
77 )";
78 auto AST =
79 tooling::buildASTFromCodeWithArgs(Code, {"-target", "i386-apple-darwin"});
80 ASTContext &Ctx = AST->getASTContext();
81 assert(Ctx.getTargetInfo().getUserLabelPrefix() == StringRef("_") &&
82 "Expected target to have a global prefix");
83 DiagnosticsEngine &Diags = AST->getDiagnostics();
84
85 const auto *DeclS =
86 selectFirst<CXXRecordDecl>("d", match(cxxRecordDecl().bind("d"), Ctx));
87 NamedDecl *DeclF = *DeclS->method_begin();
88 NamedDecl *DeclG = *(++DeclS->method_begin());
89
90 // Attach asm labels to the decls: one literal, and one not.
91 DeclF->addAttr(::new (Ctx) AsmLabelAttr(Ctx, SourceLocation(), "foo",
92 /*LiteralLabel=*/true));
93 DeclG->addAttr(::new (Ctx) AsmLabelAttr(Ctx, SourceLocation(), "goo",
94 /*LiteralLabel=*/false));
95
96 // Mangle the decl names.
97 std::string MangleF, MangleG;
98 std::unique_ptr<ItaniumMangleContext> MC(
99 ItaniumMangleContext::create(Ctx, Diags));
100 {
101 llvm::raw_string_ostream OS_F(MangleF);
102 llvm::raw_string_ostream OS_G(MangleG);
103 MC->mangleName(DeclF, OS_F);
104 MC->mangleName(DeclG, OS_G);
105 }
106
107 ASSERT_TRUE(0 == MangleF.compare("\x01" "foo"));
108 ASSERT_TRUE(0 == MangleG.compare("goo"));
109 }
110
111 TEST(Decl, MangleDependentSizedArray) {
112 StringRef Code = R"(
113 template <int ...N>
114 int A[] = {N...};
115
116 template <typename T, int N>
117 struct S {
118 T B[N];
119 };
120 )";
121 auto AST =
122 tooling::buildASTFromCodeWithArgs(Code, {"-target", "i386-apple-darwin"});
123 ASTContext &Ctx = AST->getASTContext();
124 assert(Ctx.getTargetInfo().getUserLabelPrefix() == StringRef("_") &&
125 "Expected target to have a global prefix");
126 DiagnosticsEngine &Diags = AST->getDiagnostics();
127
128 const auto *DeclA =
129 selectFirst<VarDecl>("A", match(varDecl().bind("A"), Ctx));
130 const auto *DeclB =
131 selectFirst<FieldDecl>("B", match(fieldDecl().bind("B"), Ctx));
132
133 std::string MangleA, MangleB;
134 llvm::raw_string_ostream OS_A(MangleA), OS_B(MangleB);
135 std::unique_ptr<ItaniumMangleContext> MC(
136 ItaniumMangleContext::create(Ctx, Diags));
137
138 MC->mangleTypeName(DeclA->getType(), OS_A);
139 MC->mangleTypeName(DeclB->getType(), OS_B);
140
141 ASSERT_TRUE(0 == MangleA.compare("_ZTSA_i"));
142 ASSERT_TRUE(0 == MangleB.compare("_ZTSAT0__T_"));
143 }
144
145 TEST(Decl, EnumDeclRange) {
146 llvm::Annotations Code(R"(
147 typedef int Foo;
148 [[enum Bar : Foo]];)");
149 auto AST = tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{});
150 ASTContext &Ctx = AST->getASTContext();
151 const auto &SM = Ctx.getSourceManager();
152
153 const auto *Bar =
154 selectFirst<TagDecl>("Bar", match(enumDecl().bind("Bar"), Ctx));
155 auto BarRange =
156 Lexer::getAsCharRange(Bar->getSourceRange(), SM, Ctx.getLangOpts());
157 EXPECT_EQ(SM.getFileOffset(BarRange.getBegin()), Code.range().Begin);
158 EXPECT_EQ(SM.getFileOffset(BarRange.getEnd()), Code.range().End);
159 }
160
161 TEST(Decl, IsInExportDeclContext) {
162 llvm::Annotations Code(R"(
163 export module m;
164 export template <class T>
165 void f() {})");
166 auto AST =
167 tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{"-std=c++20"});
168 ASTContext &Ctx = AST->getASTContext();
169
170 const auto *f =
171 selectFirst<FunctionDecl>("f", match(functionDecl().bind("f"), Ctx));
172 EXPECT_TRUE(f->isInExportDeclContext());
173 }
174
175 TEST(Decl, InConsistLinkageForTemplates) {
176 llvm::Annotations Code(R"(
177 export module m;
178 export template <class T>
179 void f() {}
180
181 template <>
182 void f<int>() {}
183
184 export template <class T>
185 class C {};
186
187 template<>
188 class C<int> {};
189 )");
190
191 auto AST =
192 tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{"-std=c++20"});
193 ASTContext &Ctx = AST->getASTContext();
194
195 llvm::SmallVector<ast_matchers::BoundNodes, 2> Funcs =
196 match(functionDecl().bind("f"), Ctx);
197
198 EXPECT_EQ(Funcs.size(), 2U);
199 const FunctionDecl *TemplateF = Funcs[0].getNodeAs<FunctionDecl>("f");
200 const FunctionDecl *SpecializedF = Funcs[1].getNodeAs<FunctionDecl>("f");
201 EXPECT_EQ(TemplateF->getLinkageInternal(),
202 SpecializedF->getLinkageInternal());
203
204 llvm::SmallVector<ast_matchers::BoundNodes, 1> ClassTemplates =
205 match(classTemplateDecl().bind("C"), Ctx);
206 llvm::SmallVector<ast_matchers::BoundNodes, 1> ClassSpecializations =
207 match(classTemplateSpecializationDecl().bind("C"), Ctx);
208
209 EXPECT_EQ(ClassTemplates.size(), 1U);
210 EXPECT_EQ(ClassSpecializations.size(), 1U);
211 const NamedDecl *TemplatedC = ClassTemplates[0].getNodeAs<NamedDecl>("C");
212 const NamedDecl *SpecializedC = ClassSpecializations[0].getNodeAs<NamedDecl>("C");
213 EXPECT_EQ(TemplatedC->getLinkageInternal(),
214 SpecializedC->getLinkageInternal());
215 }
216
217 TEST(Decl, ModuleAndInternalLinkage) {
218 llvm::Annotations Code(R"(
219 export module M;
220 static int a;
221 static int f(int x);
222
223 int b;
224 int g(int x);)");
225
226 auto AST =
227 tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{"-std=c++20"});
228 ASTContext &Ctx = AST->getASTContext();
229
230 const auto *a =
231 selectFirst<VarDecl>("a", match(varDecl(hasName("a")).bind("a"), Ctx));
232 const auto *f = selectFirst<FunctionDecl>(
233 "f", match(functionDecl(hasName("f")).bind("f"), Ctx));
234
235 EXPECT_EQ(a->getLinkageInternal(), InternalLinkage);
236 EXPECT_EQ(f->getLinkageInternal(), InternalLinkage);
237
238 const auto *b =
239 selectFirst<VarDecl>("b", match(varDecl(hasName("b")).bind("b"), Ctx));
240 const auto *g = selectFirst<FunctionDecl>(
241 "g", match(functionDecl(hasName("g")).bind("g"), Ctx));
242
243 EXPECT_EQ(b->getLinkageInternal(), ModuleLinkage);
244 EXPECT_EQ(g->getLinkageInternal(), ModuleLinkage);
245
246 AST = tooling::buildASTFromCodeWithArgs(
247 Code.code(), /*Args=*/{"-std=c++20", "-fmodules-ts"});
248 ASTContext &CtxTS = AST->getASTContext();
249 a = selectFirst<VarDecl>("a", match(varDecl(hasName("a")).bind("a"), CtxTS));
250 f = selectFirst<FunctionDecl>(
251 "f", match(functionDecl(hasName("f")).bind("f"), CtxTS));
252
253 EXPECT_EQ(a->getLinkageInternal(), ModuleInternalLinkage);
254 EXPECT_EQ(f->getLinkageInternal(), ModuleInternalLinkage);
255
256 b = selectFirst<VarDecl>("b", match(varDecl(hasName("b")).bind("b"), CtxTS));
257 g = selectFirst<FunctionDecl>(
258 "g", match(functionDecl(hasName("g")).bind("g"), CtxTS));
259
260 EXPECT_EQ(b->getLinkageInternal(), ModuleLinkage);
261 EXPECT_EQ(g->getLinkageInternal(), ModuleLinkage);
262 }
263
264 TEST(Decl, GetNonTransparentDeclContext) {
265 llvm::Annotations Code(R"(
266 export module m3;
267 export template <class> struct X {
268 template <class Self> friend void f(Self &&self) {
269 (Self&)self;
270 }
271 };)");
272
273 auto AST =
274 tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{"-std=c++20"});
275 ASTContext &Ctx = AST->getASTContext();
276
277 auto *f = selectFirst<FunctionDecl>(
278 "f", match(functionDecl(hasName("f")).bind("f"), Ctx));
279
280 EXPECT_TRUE(f->getNonTransparentDeclContext()->isFileContext());
281 }
282
283 TEST(Decl, MemberFunctionInModules) {
284 llvm::Annotations Code(R"(
285 module;
286 class G {
287 void bar() {}
288 };
289 export module M;
290 class A {
291 void foo() {}
292 };
293 )");
294
295 auto AST =
296 tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{"-std=c++20"});
297 ASTContext &Ctx = AST->getASTContext();
298
299 auto *foo = selectFirst<FunctionDecl>(
300 "foo", match(functionDecl(hasName("foo")).bind("foo"), Ctx));
301
302 // The function defined within a class definition is not implicitly inline
303 // if it is not attached to global module
304 EXPECT_FALSE(foo->isInlined());
305
306 auto *bar = selectFirst<FunctionDecl>(
307 "bar", match(functionDecl(hasName("bar")).bind("bar"), Ctx));
308
309 // In global module, the function defined within a class definition is
310 // implicitly inline.
311 EXPECT_TRUE(bar->isInlined());
312 }
313
314 TEST(Decl, MemberFunctionInHeaderUnit) {
315 llvm::Annotations Code(R"(
316 class foo {
317 public:
318 int memFn() {
319 return 43;
320 }
321 };
322 )");
323
324 auto AST = tooling::buildASTFromCodeWithArgs(
325 Code.code(), {"-std=c++20", " -xc++-user-header ", "-emit-header-unit"});
326 ASTContext &Ctx = AST->getASTContext();
327
328 auto *memFn = selectFirst<FunctionDecl>(
329 "memFn", match(functionDecl(hasName("memFn")).bind("memFn"), Ctx));
330
331 EXPECT_TRUE(memFn->isInlined());
332 }
333
334 TEST(Decl, FriendFunctionWithinClassInHeaderUnit) {
335 llvm::Annotations Code(R"(
336 class foo {
337 int value;
338 public:
339 foo(int v) : value(v) {}
340
341 friend int getFooValue(foo f) {
342 return f.value;
343 }
344 };
345 )");
346
347 auto AST = tooling::buildASTFromCodeWithArgs(
348 Code.code(), {"-std=c++20", " -xc++-user-header ", "-emit-header-unit"});
349 ASTContext &Ctx = AST->getASTContext();
350
351 auto *getFooValue = selectFirst<FunctionDecl>(
352 "getFooValue",
353 match(functionDecl(hasName("getFooValue")).bind("getFooValue"), Ctx));
354
355 EXPECT_TRUE(getFooValue->isInlined());
356 }
357
358 TEST(Decl, NoProtoFunctionDeclAttributes) {
359 llvm::Annotations Code(R"(
360 void f();
361 )");
362
363 auto AST = tooling::buildASTFromCodeWithArgs(
364 Code.code(),
365 /*Args=*/{"-target", "i386-apple-darwin", "-x", "objective-c",
366 "-std=c89"});
367 ASTContext &Ctx = AST->getASTContext();
368
369 auto *f = selectFirst<FunctionDecl>(
370 "f", match(functionDecl(hasName("f")).bind("f"), Ctx));
371
372 const auto *FPT = f->getType()->getAs<FunctionNoProtoType>();
373
374 // Functions without prototypes always have 0 initialized qualifiers
375 EXPECT_FALSE(FPT->isConst());
376 EXPECT_FALSE(FPT->isVolatile());
377 EXPECT_FALSE(FPT->isRestrict());
378 }
379
380 TEST(Decl, ImplicitlyDeclaredAllocationFunctionsInModules) {
381 // C++ [basic.stc.dynamic.general]p2:
382 // The library provides default definitions for the global allocation
383 // and deallocation functions. Some global allocation and deallocation
384 // functions are replaceable ([new.delete]); these are attached to the
385 // global module ([module.unit]).
386
387 llvm::Annotations Code(R"(
388 export module base;
389
390 export struct Base {
391 virtual void hello() = 0;
392 virtual ~Base() = default;
393 };
394 )");
395
396 auto AST =
397 tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{"-std=c++20"});
398 ASTContext &Ctx = AST->getASTContext();
399
400 // void* operator new(std::size_t);
401 auto *SizedOperatorNew = selectFirst<FunctionDecl>(
402 "operator new",
403 match(functionDecl(hasName("operator new"), parameterCountIs(1),
404 hasParameter(0, hasType(isUnsignedInteger())))
405 .bind("operator new"),
406 Ctx));
407 ASSERT_TRUE(SizedOperatorNew->getOwningModule());
408 EXPECT_TRUE(SizedOperatorNew->getOwningModule()->isGlobalModule());
409
410 // void* operator new(std::size_t, std::align_val_t);
411 auto *SizedAlignedOperatorNew = selectFirst<FunctionDecl>(
412 "operator new",
413 match(functionDecl(
414 hasName("operator new"), parameterCountIs(2),
415 hasParameter(0, hasType(isUnsignedInteger())),
416 hasParameter(1, hasType(enumDecl(hasName("std::align_val_t")))))
417 .bind("operator new"),
418 Ctx));
419 ASSERT_TRUE(SizedAlignedOperatorNew->getOwningModule());
420 EXPECT_TRUE(SizedAlignedOperatorNew->getOwningModule()->isGlobalModule());
421
422 // void* operator new[](std::size_t);
423 auto *SizedArrayOperatorNew = selectFirst<FunctionDecl>(
424 "operator new[]",
425 match(functionDecl(hasName("operator new[]"), parameterCountIs(1),
426 hasParameter(0, hasType(isUnsignedInteger())))
427 .bind("operator new[]"),
428 Ctx));
429 ASSERT_TRUE(SizedArrayOperatorNew->getOwningModule());
430 EXPECT_TRUE(SizedArrayOperatorNew->getOwningModule()->isGlobalModule());
431
432 // void* operator new[](std::size_t, std::align_val_t);
433 auto *SizedAlignedArrayOperatorNew = selectFirst<FunctionDecl>(
434 "operator new[]",
435 match(functionDecl(
436 hasName("operator new[]"), parameterCountIs(2),
437 hasParameter(0, hasType(isUnsignedInteger())),
438 hasParameter(1, hasType(enumDecl(hasName("std::align_val_t")))))
439 .bind("operator new[]"),
440 Ctx));
441 ASSERT_TRUE(SizedAlignedArrayOperatorNew->getOwningModule());
442 EXPECT_TRUE(
443 SizedAlignedArrayOperatorNew->getOwningModule()->isGlobalModule());
444
445 // void operator delete(void*) noexcept;
446 auto *Delete = selectFirst<FunctionDecl>(
447 "operator delete",
448 match(functionDecl(
449 hasName("operator delete"), parameterCountIs(1),
450 hasParameter(0, hasType(pointerType(pointee(voidType())))))
451 .bind("operator delete"),
452 Ctx));
453 ASSERT_TRUE(Delete->getOwningModule());
454 EXPECT_TRUE(Delete->getOwningModule()->isGlobalModule());
455
456 // void operator delete(void*, std::align_val_t) noexcept;
457 auto *AlignedDelete = selectFirst<FunctionDecl>(
458 "operator delete",
459 match(functionDecl(
460 hasName("operator delete"), parameterCountIs(2),
461 hasParameter(0, hasType(pointerType(pointee(voidType())))),
462 hasParameter(1, hasType(enumDecl(hasName("std::align_val_t")))))
463 .bind("operator delete"),
464 Ctx));
465 ASSERT_TRUE(AlignedDelete->getOwningModule());
466 EXPECT_TRUE(AlignedDelete->getOwningModule()->isGlobalModule());
467
468 // Sized deallocation is not enabled by default. So we skip it here.
469
470 // void operator delete[](void*) noexcept;
471 auto *ArrayDelete = selectFirst<FunctionDecl>(
472 "operator delete[]",
473 match(functionDecl(
474 hasName("operator delete[]"), parameterCountIs(1),
475 hasParameter(0, hasType(pointerType(pointee(voidType())))))
476 .bind("operator delete[]"),
477 Ctx));
478 ASSERT_TRUE(ArrayDelete->getOwningModule());
479 EXPECT_TRUE(ArrayDelete->getOwningModule()->isGlobalModule());
480
481 // void operator delete[](void*, std::align_val_t) noexcept;
482 auto *AlignedArrayDelete = selectFirst<FunctionDecl>(
483 "operator delete[]",
484 match(functionDecl(
485 hasName("operator delete[]"), parameterCountIs(2),
486 hasParameter(0, hasType(pointerType(pointee(voidType())))),
487 hasParameter(1, hasType(enumDecl(hasName("std::align_val_t")))))
488 .bind("operator delete[]"),
489 Ctx));
490 ASSERT_TRUE(AlignedArrayDelete->getOwningModule());
491 EXPECT_TRUE(AlignedArrayDelete->getOwningModule()->isGlobalModule());
492 }