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