Debian Codegraph @

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

raw
1 //===- unittest/AST/SourceLocationTest.cpp - AST source loc unit 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 // This file contains tests for SourceLocation and SourceRange fields
10 // in AST nodes.
11 //
12 // FIXME: In the long-term, when we test more than source locations, we may
13 // want to have a unit test file for an AST node (or group of related nodes),
14 // rather than a unit test file for source locations for all AST nodes.
15 //
16 //===----------------------------------------------------------------------===//
17
18 #include "MatchVerifier.h"
19 #include "clang/AST/ASTContext.h"
20 #include "clang/ASTMatchers/ASTMatchFinder.h"
21 #include "clang/ASTMatchers/ASTMatchers.h"
22 #include "clang/Tooling/Tooling.h"
23 #include "llvm/Testing/Annotations/Annotations.h"
24 #include "gtest/gtest.h"
25
26 using namespace clang;
27 using namespace clang::ast_matchers;
28
29 namespace {
30
31 // FIXME: Pull the *Verifier tests into their own test file.
32
33 TEST(MatchVerifier, ParseError) {
34 LocationVerifier<VarDecl> Verifier;
35 Verifier.expectLocation(1, 1);
36 EXPECT_FALSE(Verifier.match("int i", varDecl()));
37 }
38
39 TEST(MatchVerifier, NoMatch) {
40 LocationVerifier<VarDecl> Verifier;
41 Verifier.expectLocation(1, 1);
42 EXPECT_FALSE(Verifier.match("int i;", recordDecl()));
43 }
44
45 TEST(MatchVerifier, WrongType) {
46 LocationVerifier<RecordDecl> Verifier;
47 Verifier.expectLocation(1, 1);
48 EXPECT_FALSE(Verifier.match("int i;", varDecl()));
49 }
50
51 TEST(LocationVerifier, WrongLocation) {
52 LocationVerifier<VarDecl> Verifier;
53 Verifier.expectLocation(1, 1);
54 EXPECT_FALSE(Verifier.match("int i;", varDecl()));
55 }
56
57 TEST(RangeVerifier, WrongRange) {
58 RangeVerifier<VarDecl> Verifier;
59 Verifier.expectRange(1, 1, 1, 1);
60 EXPECT_FALSE(Verifier.match("int i;", varDecl()));
61 }
62
63 class WhileParenLocationVerifier : public MatchVerifier<WhileStmt> {
64 unsigned ExpectLParenLine = 0, ExpectLParenColumn = 0;
65 unsigned ExpectRParenLine = 0, ExpectRParenColumn = 0;
66
67 public:
68 void expectLocations(unsigned LParenLine, unsigned LParenColumn,
69 unsigned RParenLine, unsigned RParenColumn) {
70 ExpectLParenLine = LParenLine;
71 ExpectLParenColumn = LParenColumn;
72 ExpectRParenLine = RParenLine;
73 ExpectRParenColumn = RParenColumn;
74 }
75
76 protected:
77 void verify(const MatchFinder::MatchResult &Result,
78 const WhileStmt &Node) override {
79 SourceLocation LParenLoc = Node.getLParenLoc();
80 SourceLocation RParenLoc = Node.getRParenLoc();
81 unsigned LParenLine =
82 Result.SourceManager->getSpellingLineNumber(LParenLoc);
83 unsigned LParenColumn =
84 Result.SourceManager->getSpellingColumnNumber(LParenLoc);
85 unsigned RParenLine =
86 Result.SourceManager->getSpellingLineNumber(RParenLoc);
87 unsigned RParenColumn =
88 Result.SourceManager->getSpellingColumnNumber(RParenLoc);
89
90 if (LParenLine != ExpectLParenLine || LParenColumn != ExpectLParenColumn ||
91 RParenLine != ExpectRParenLine || RParenColumn != ExpectRParenColumn) {
92 std::string MsgStr;
93 llvm::raw_string_ostream Msg(MsgStr);
94 Msg << "Expected LParen Location <" << ExpectLParenLine << ":"
95 << ExpectLParenColumn << ">, found <";
96 LParenLoc.print(Msg, *Result.SourceManager);
97 Msg << ">\n";
98
99 Msg << "Expected RParen Location <" << ExpectRParenLine << ":"
100 << ExpectRParenColumn << ">, found <";
101 RParenLoc.print(Msg, *Result.SourceManager);
102 Msg << ">";
103
104 this->setFailure(Msg.str());
105 }
106 }
107 };
108
109 TEST(LocationVerifier, WhileParenLoc) {
110 WhileParenLocationVerifier Verifier;
111 Verifier.expectLocations(1, 17, 1, 38);
112 EXPECT_TRUE(Verifier.match("void f() { while(true/*some comment*/) {} }",
113 whileStmt()));
114 }
115
116 class LabelDeclRangeVerifier : public RangeVerifier<LabelStmt> {
117 protected:
118 SourceRange getRange(const LabelStmt &Node) override {
119 return Node.getDecl()->getSourceRange();
120 }
121 };
122
123 TEST(LabelDecl, Range) {
124 LabelDeclRangeVerifier Verifier;
125 Verifier.expectRange(1, 12, 1, 12);
126 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
127 }
128
129 TEST(LabelStmt, Range) {
130 RangeVerifier<LabelStmt> Verifier;
131 Verifier.expectRange(1, 12, 1, 15);
132 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
133 }
134
135 TEST(ParmVarDecl, KNRLocation) {
136 LocationVerifier<ParmVarDecl> Verifier;
137 Verifier.expectLocation(1, 8);
138 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C89));
139
140 Verifier.expectLocation(1, 15);
141 EXPECT_TRUE(Verifier.match("void f(i) int i; {}", varDecl(), Lang_C99));
142 }
143
144 TEST(ParmVarDecl, KNRRange) {
145 RangeVerifier<ParmVarDecl> Verifier;
146 Verifier.expectRange(1, 8, 1, 8);
147 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C89));
148
149 Verifier.expectRange(1, 11, 1, 15);
150 EXPECT_TRUE(Verifier.match("void f(i) int i; {}", varDecl(), Lang_C99));
151 }
152
153 TEST(CXXNewExpr, ArrayRange) {
154 RangeVerifier<CXXNewExpr> Verifier;
155 Verifier.expectRange(1, 12, 1, 22);
156 EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", cxxNewExpr()));
157 }
158
159 TEST(CXXNewExpr, ParenRange) {
160 RangeVerifier<CXXNewExpr> Verifier;
161 Verifier.expectRange(1, 12, 1, 20);
162 EXPECT_TRUE(Verifier.match("void f() { new int(); }", cxxNewExpr()));
163 }
164
165 TEST(MemberExpr, ImplicitMemberRange) {
166 RangeVerifier<MemberExpr> Verifier;
167 Verifier.expectRange(2, 30, 2, 30);
168 EXPECT_TRUE(Verifier.match("struct S { operator int() const; };\n"
169 "int foo(const S& s) { return s; }",
170 memberExpr()));
171 }
172
173 class MemberExprArrowLocVerifier : public RangeVerifier<MemberExpr> {
174 protected:
175 SourceRange getRange(const MemberExpr &Node) override {
176 return Node.getOperatorLoc();
177 }
178 };
179
180 TEST(MemberExpr, ArrowRange) {
181 MemberExprArrowLocVerifier Verifier;
182 Verifier.expectRange(2, 19, 2, 19);
183 EXPECT_TRUE(Verifier.match("struct S { int x; };\n"
184 "void foo(S *s) { s->x = 0; }",
185 memberExpr()));
186 }
187
188 TEST(MemberExpr, MacroArrowRange) {
189 MemberExprArrowLocVerifier Verifier;
190 Verifier.expectRange(1, 24, 1, 24);
191 EXPECT_TRUE(Verifier.match("#define MEMBER(a, b) (a->b)\n"
192 "struct S { int x; };\n"
193 "void foo(S *s) { MEMBER(s, x) = 0; }",
194 memberExpr()));
195 }
196
197 TEST(MemberExpr, ImplicitArrowRange) {
198 MemberExprArrowLocVerifier Verifier;
199 Verifier.expectRange(0, 0, 0, 0);
200 EXPECT_TRUE(Verifier.match("struct S { int x; void Test(); };\n"
201 "void S::Test() { x = 1; }",
202 memberExpr()));
203 }
204
205 TEST(VarDecl, VMTypeFixedVarDeclRange) {
206 RangeVerifier<VarDecl> Verifier;
207 Verifier.expectRange(1, 1, 1, 23);
208 EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];",
209 varDecl(), Lang_C89));
210 }
211
212 TEST(TypeLoc, IntRange) {
213 RangeVerifier<TypeLoc> Verifier;
214 Verifier.expectRange(1, 1, 1, 1);
215 EXPECT_TRUE(Verifier.match("int a;", typeLoc()));
216 }
217
218 TEST(TypeLoc, LongRange) {
219 RangeVerifier<TypeLoc> Verifier;
220 Verifier.expectRange(1, 1, 1, 1);
221 EXPECT_TRUE(Verifier.match("long a;", typeLoc()));
222 }
223
224 TEST(TypeLoc, DecltypeTypeLocRange) {
225 llvm::Annotations Code(R"(
226 $full1[[decltype(1)]] a;
227 struct A {struct B{};} var;
228 $full2[[decltype(var)]]::B c;
229 )");
230 auto AST = tooling::buildASTFromCodeWithArgs(Code.code(), /*Args=*/{});
231 ASTContext &Ctx = AST->getASTContext();
232 const auto &SM = Ctx.getSourceManager();
233
234 auto MatchedLocs = clang::ast_matchers::match(
235 typeLoc(loc(decltypeType())).bind("target"), Ctx);
236 ASSERT_EQ(MatchedLocs.size(), 2u);
237 auto verify = [&](SourceRange ActualRange,
238 const llvm::Annotations::Range &Expected) {
239 auto ActualCharRange =
240 Lexer::getAsCharRange(ActualRange, SM, Ctx.getLangOpts());
241 EXPECT_EQ(SM.getFileOffset(ActualCharRange.getBegin()), Expected.Begin);
242 EXPECT_EQ(SM.getFileOffset(ActualCharRange.getEnd()), Expected.End);
243 };
244 const auto *Target1 = MatchedLocs[0].getNodeAs<DecltypeTypeLoc>("target");
245 verify(Target1->getSourceRange(), Code.range("full1"));
246
247 const auto *Target2 = MatchedLocs[1].getNodeAs<DecltypeTypeLoc>("target");
248 verify(Target2->getSourceRange(), Code.range("full2"));
249 }
250
251 TEST(TypeLoc, AutoTypeLocRange) {
252 RangeVerifier<TypeLoc> Verifier;
253 Verifier.expectRange(1, 1, 1, 14);
254 EXPECT_TRUE(Verifier.match("decltype(auto) a = 1;", typeLoc(loc(autoType())),
255 Lang_CXX14));
256
257 const char *Code =
258 R"cpp(template <typename T> concept C = true;
259 C auto abc();
260 )cpp";
261 // Should include "C auto" tokens.
262 Verifier.expectRange(2, 1, 2, 3); // token range.
263 EXPECT_TRUE(Verifier.match(Code, typeLoc(loc(autoType())), Lang_CXX20));
264 }
265
266 TEST(TypeLoc, LongDoubleRange) {
267 RangeVerifier<TypeLoc> Verifier;
268 Verifier.expectRange(1, 1, 1, 6);
269 EXPECT_TRUE(Verifier.match("long double a;", typeLoc()));
270 }
271
272 TEST(TypeLoc, DoubleLongRange) {
273 RangeVerifier<TypeLoc> Verifier;
274 Verifier.expectRange(1, 1, 1, 8);
275 EXPECT_TRUE(Verifier.match("double long a;", typeLoc()));
276 }
277
278 TEST(TypeLoc, LongIntRange) {
279 RangeVerifier<TypeLoc> Verifier;
280 Verifier.expectRange(1, 1, 1, 6);
281 EXPECT_TRUE(Verifier.match("long int a;", typeLoc()));
282 }
283
284 TEST(TypeLoc, IntLongRange) {
285 RangeVerifier<TypeLoc> Verifier;
286 Verifier.expectRange(1, 1, 1, 5);
287 EXPECT_TRUE(Verifier.match("int long a;", typeLoc()));
288 }
289
290 TEST(TypeLoc, UnsignedIntRange) {
291 RangeVerifier<TypeLoc> Verifier;
292 Verifier.expectRange(1, 1, 1, 10);
293 EXPECT_TRUE(Verifier.match("unsigned int a;", typeLoc()));
294 }
295
296 TEST(TypeLoc, IntUnsignedRange) {
297 RangeVerifier<TypeLoc> Verifier;
298 Verifier.expectRange(1, 1, 1, 5);
299 EXPECT_TRUE(Verifier.match("int unsigned a;", typeLoc()));
300 }
301
302 TEST(TypeLoc, LongLongRange) {
303 RangeVerifier<TypeLoc> Verifier;
304 Verifier.expectRange(1, 1, 1, 6);
305 EXPECT_TRUE(Verifier.match("long long a;", typeLoc()));
306 }
307
308 TEST(TypeLoc, UnsignedLongLongRange) {
309 RangeVerifier<TypeLoc> Verifier;
310 Verifier.expectRange(1, 1, 1, 15);
311 EXPECT_TRUE(Verifier.match("unsigned long long a;", typeLoc()));
312 }
313
314 TEST(TypeLoc, LongUnsignedLongRange) {
315 RangeVerifier<TypeLoc> Verifier;
316 Verifier.expectRange(1, 1, 1, 15);
317 EXPECT_TRUE(Verifier.match("long unsigned long a;", typeLoc()));
318 }
319
320 TEST(TypeLoc, LongLongUnsignedRange) {
321 RangeVerifier<TypeLoc> Verifier;
322 Verifier.expectRange(1, 1, 1, 11);
323 EXPECT_TRUE(Verifier.match("long long unsigned a;", typeLoc()));
324 }
325
326 TEST(TypeLoc, ConstLongLongRange) {
327 RangeVerifier<TypeLoc> Verifier;
328 Verifier.expectRange(1, 7, 1, 12);
329 EXPECT_TRUE(Verifier.match("const long long a = 0;", typeLoc()));
330 }
331
332 TEST(TypeLoc, LongConstLongRange) {
333 RangeVerifier<TypeLoc> Verifier;
334 Verifier.expectRange(1, 1, 1, 12);
335 EXPECT_TRUE(Verifier.match("long const long a = 0;", typeLoc()));
336 }
337
338 TEST(TypeLoc, LongLongConstRange) {
339 RangeVerifier<TypeLoc> Verifier;
340 Verifier.expectRange(1, 1, 1, 6);
341 EXPECT_TRUE(Verifier.match("long long const a = 0;", typeLoc()));
342 }
343
344 TEST(CXXConstructorDecl, NoRetFunTypeLocRange) {
345 RangeVerifier<CXXConstructorDecl> Verifier;
346 Verifier.expectRange(1, 11, 1, 13);
347 EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl()));
348 }
349
350 TEST(CXXConstructorDecl, DefaultedCtorLocRange) {
351 RangeVerifier<CXXConstructorDecl> Verifier;
352 Verifier.expectRange(1, 11, 1, 23);
353 EXPECT_TRUE(Verifier.match("class C { C() = default; };", functionDecl()));
354 }
355
356 TEST(CXXConstructorDecl, DeletedCtorLocRange) {
357 RangeVerifier<CXXConstructorDecl> Verifier;
358 Verifier.expectRange(1, 11, 1, 22);
359 EXPECT_TRUE(Verifier.match("class C { C() = delete; };", functionDecl()));
360 }
361
362 TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) {
363 RangeVerifier<CompoundLiteralExpr> Verifier;
364 Verifier.expectRange(2, 11, 2, 22);
365 EXPECT_TRUE(Verifier.match(
366 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
367 "int2 i2 = (int2){1, 2};", compoundLiteralExpr()));
368 }
369
370 TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) {
371 RangeVerifier<CompoundLiteralExpr> Verifier;
372 Verifier.expectRange(2, 20, 2, 31);
373 EXPECT_TRUE(Verifier.match(
374 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
375 "constant int2 i2 = (int2)(1, 2);",
376 compoundLiteralExpr(), Lang_OpenCL));
377 }
378
379 TEST(InitListExpr, VectorLiteralListBraceRange) {
380 RangeVerifier<InitListExpr> Verifier;
381 Verifier.expectRange(2, 17, 2, 22);
382 EXPECT_TRUE(Verifier.match(
383 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
384 "int2 i2 = (int2){1, 2};", initListExpr()));
385 }
386
387 TEST(InitListExpr, VectorLiteralInitListParens) {
388 RangeVerifier<InitListExpr> Verifier;
389 Verifier.expectRange(2, 26, 2, 31);
390 EXPECT_TRUE(Verifier.match(
391 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
392 "constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL));
393 }
394
395 class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> {
396 protected:
397 SourceRange getRange(const TypeLoc &Node) override {
398 TemplateSpecializationTypeLoc T =
399 Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>();
400 assert(!T.isNull());
401 return SourceRange(T.getLAngleLoc(), T.getRAngleLoc());
402 }
403 };
404
405 TEST(TemplateSpecializationTypeLoc, AngleBracketLocations) {
406 TemplateAngleBracketLocRangeVerifier Verifier;
407 Verifier.expectRange(2, 8, 2, 10);
408 EXPECT_TRUE(Verifier.match(
409 "template<typename T> struct A {}; struct B{}; void f(\n"
410 "const A<B>&);",
411 loc(templateSpecializationType())));
412 }
413
414 TEST(CXXNewExpr, TypeParenRange) {
415 RangeVerifier<CXXNewExpr> Verifier;
416 Verifier.expectRange(1, 10, 1, 18);
417 EXPECT_TRUE(Verifier.match("int* a = new (int);", cxxNewExpr()));
418 }
419
420 class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> {
421 protected:
422 SourceRange getRange(const TypeLoc &Node) override {
423 UnaryTransformTypeLoc T =
424 Node.getUnqualifiedLoc().castAs<UnaryTransformTypeLoc>();
425 assert(!T.isNull());
426 return SourceRange(T.getLParenLoc(), T.getRParenLoc());
427 }
428 };
429
430 TEST(UnaryTransformTypeLoc, ParensRange) {
431 UnaryTransformTypeLocParensRangeVerifier Verifier;
432 Verifier.expectRange(3, 26, 3, 28);
433 EXPECT_TRUE(Verifier.match(
434 "template <typename T>\n"
435 "struct S {\n"
436 "typedef __underlying_type(T) type;\n"
437 "};",
438 loc(unaryTransformType())));
439 }
440
441 TEST(PointerTypeLoc, StarLoc) {
442 llvm::Annotations Example(R"c(
443 int $star^*var;
444 )c");
445
446 auto AST = tooling::buildASTFromCode(Example.code());
447 SourceManager &SM = AST->getSourceManager();
448 auto &Ctx = AST->getASTContext();
449
450 auto *VD = selectFirst<VarDecl>("vd", match(varDecl(hasName("var")).bind("vd"), Ctx));
451 ASSERT_NE(VD, nullptr);
452
453 auto TL =
454 VD->getTypeSourceInfo()->getTypeLoc().castAs<PointerTypeLoc>();
455 ASSERT_EQ(SM.getFileOffset(TL.getStarLoc()), Example.point("star"));
456 }
457
458 TEST(PointerTypeLoc, StarLocBehindSugar) {
459 llvm::Annotations Example(R"c(
460 #define NODEREF __attribute__((noderef))
461 char $1st^* NODEREF _Nonnull $2nd^* var;
462 )c");
463
464 auto AST = tooling::buildASTFromCode(Example.code());
465 SourceManager &SM = AST->getSourceManager();
466 auto &Ctx = AST->getASTContext();
467
468 auto *VD = selectFirst<VarDecl>("vd", match(varDecl(hasName("var")).bind("vd"), Ctx));
469 ASSERT_NE(VD, nullptr);
470
471 auto TL = VD->getTypeSourceInfo()->getTypeLoc().castAs<PointerTypeLoc>();
472 EXPECT_EQ(SM.getFileOffset(TL.getStarLoc()), Example.point("2nd"));
473
474 // Cast intermediate TypeLoc to make sure the structure matches expectations.
475 auto InnerPtrTL = TL.getPointeeLoc().castAs<AttributedTypeLoc>()
476 .getNextTypeLoc().castAs<MacroQualifiedTypeLoc>()
477 .getNextTypeLoc().castAs<AttributedTypeLoc>()
478 .getNextTypeLoc().castAs<PointerTypeLoc>();
479 EXPECT_EQ(SM.getFileOffset(InnerPtrTL.getStarLoc()), Example.point("1st"));
480 }
481
482 TEST(CXXFunctionalCastExpr, SourceRange) {
483 RangeVerifier<CXXFunctionalCastExpr> Verifier;
484 Verifier.expectRange(2, 10, 2, 14);
485 EXPECT_TRUE(Verifier.match(
486 "int foo() {\n"
487 " return int{};\n"
488 "}",
489 cxxFunctionalCastExpr(), Lang_CXX11));
490 }
491
492 TEST(CXXConstructExpr, SourceRange) {
493 RangeVerifier<CXXConstructExpr> Verifier;
494 Verifier.expectRange(3, 14, 3, 19);
495 EXPECT_TRUE(Verifier.match(
496 "struct A { A(int, int); };\n"
497 "void f(A a);\n"
498 "void g() { f({0, 0}); }",
499 cxxConstructExpr(), Lang_CXX11));
500 }
501
502 TEST(CXXTemporaryObjectExpr, SourceRange) {
503 RangeVerifier<CXXTemporaryObjectExpr> Verifier;
504 Verifier.expectRange(2, 6, 2, 12);
505 EXPECT_TRUE(Verifier.match(
506 "struct A { A(int, int); };\n"
507 "A a( A{0, 0} );",
508 cxxTemporaryObjectExpr(), Lang_CXX11));
509 }
510
511 TEST(CXXUnresolvedConstructExpr, SourceRange) {
512 RangeVerifier<CXXUnresolvedConstructExpr> Verifier;
513 Verifier.expectRange(3, 10, 3, 12);
514 std::vector<std::string> Args;
515 Args.push_back("-fno-delayed-template-parsing");
516 EXPECT_TRUE(Verifier.match(
517 "template <typename U>\n"
518 "U foo() {\n"
519 " return U{};\n"
520 "}",
521 cxxUnresolvedConstructExpr(), Args, Lang_CXX11));
522 }
523
524 TEST(UsingDecl, SourceRange) {
525 RangeVerifier<UsingDecl> Verifier;
526 Verifier.expectRange(2, 22, 2, 25);
527 EXPECT_TRUE(Verifier.match(
528 "class B { protected: int i; };\n"
529 "class D : public B { B::i; };",
530 usingDecl()));
531 }
532
533 TEST(UnresolvedUsingValueDecl, SourceRange) {
534 RangeVerifier<UnresolvedUsingValueDecl> Verifier;
535 Verifier.expectRange(3, 3, 3, 6);
536 EXPECT_TRUE(Verifier.match(
537 "template <typename B>\n"
538 "class D : public B {\n"
539 " B::i;\n"
540 "};",
541 unresolvedUsingValueDecl()));
542 }
543
544 TEST(FriendDecl, FriendNonMemberFunctionLocation) {
545 LocationVerifier<FriendDecl> Verifier;
546 Verifier.expectLocation(2, 13);
547 EXPECT_TRUE(Verifier.match("struct A {\n"
548 "friend void f();\n"
549 "};\n",
550 friendDecl()));
551 }
552
553 TEST(FriendDecl, FriendNonMemberFunctionRange) {
554 RangeVerifier<FriendDecl> Verifier;
555 Verifier.expectRange(2, 1, 2, 15);
556 EXPECT_TRUE(Verifier.match("struct A {\n"
557 "friend void f();\n"
558 "};\n",
559 friendDecl()));
560 }
561
562 TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) {
563 LocationVerifier<FriendDecl> Verifier;
564 Verifier.expectLocation(2, 12);
565 EXPECT_TRUE(Verifier.match("struct A {\n"
566 "friend int f() { return 0; }\n"
567 "};\n",
568 friendDecl()));
569 }
570
571 TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) {
572 RangeVerifier<FriendDecl> Verifier;
573 Verifier.expectRange(2, 1, 2, 28);
574 EXPECT_TRUE(Verifier.match("struct A {\n"
575 "friend int f() { return 0; }\n"
576 "};\n",
577 friendDecl()));
578 }
579
580 TEST(FriendDecl, FriendElaboratedTypeLocation) {
581 LocationVerifier<FriendDecl> Verifier;
582 Verifier.expectLocation(2, 8);
583 EXPECT_TRUE(Verifier.match("struct A {\n"
584 "friend class B;\n"
585 "};\n",
586 friendDecl()));
587 }
588
589 TEST(FriendDecl, FriendElaboratedTypeRange) {
590 RangeVerifier<FriendDecl> Verifier;
591 Verifier.expectRange(2, 1, 2, 14);
592 EXPECT_TRUE(Verifier.match("struct A {\n"
593 "friend class B;\n"
594 "};\n",
595 friendDecl()));
596 }
597
598 TEST(FriendDecl, FriendSimpleTypeLocation) {
599 LocationVerifier<FriendDecl> Verifier;
600 Verifier.expectLocation(3, 8);
601 EXPECT_TRUE(Verifier.match("class B;\n"
602 "struct A {\n"
603 "friend B;\n"
604 "};\n",
605 friendDecl(), Lang_CXX11));
606 }
607
608 TEST(FriendDecl, FriendSimpleTypeRange) {
609 RangeVerifier<FriendDecl> Verifier;
610 Verifier.expectRange(3, 1, 3, 8);
611 EXPECT_TRUE(Verifier.match("class B;\n"
612 "struct A {\n"
613 "friend B;\n"
614 "};\n",
615 friendDecl(), Lang_CXX11));
616 }
617
618 TEST(FriendDecl, FriendTemplateParameterLocation) {
619 LocationVerifier<FriendDecl> Verifier;
620 Verifier.expectLocation(3, 8);
621 EXPECT_TRUE(Verifier.match("template <typename T>\n"
622 "struct A {\n"
623 "friend T;\n"
624 "};\n",
625 friendDecl(), Lang_CXX11));
626 }
627
628 TEST(FriendDecl, FriendTemplateParameterRange) {
629 RangeVerifier<FriendDecl> Verifier;
630 Verifier.expectRange(3, 1, 3, 8);
631 EXPECT_TRUE(Verifier.match("template <typename T>\n"
632 "struct A {\n"
633 "friend T;\n"
634 "};\n",
635 friendDecl(), Lang_CXX11));
636 }
637
638 TEST(FriendDecl, FriendDecltypeLocation) {
639 LocationVerifier<FriendDecl> Verifier;
640 Verifier.expectLocation(4, 8);
641 EXPECT_TRUE(Verifier.match("struct A;\n"
642 "A foo();\n"
643 "struct A {\n"
644 "friend decltype(foo());\n"
645 "};\n",
646 friendDecl(), Lang_CXX11));
647 }
648
649 TEST(FriendDecl, FriendDecltypeRange) {
650 RangeVerifier<FriendDecl> Verifier;
651 Verifier.expectRange(4, 1, 4, 22);
652 EXPECT_TRUE(Verifier.match("struct A;\n"
653 "A foo();\n"
654 "struct A {\n"
655 "friend decltype(foo());\n"
656 "};\n",
657 friendDecl(), Lang_CXX11));
658 }
659
660 TEST(FriendDecl, FriendConstructorDestructorLocation) {
661 const std::string Code = "struct B {\n"
662 "B();\n"
663 "~B();\n"
664 "};\n"
665 "struct A {\n"
666 "friend B::B(), B::~B();\n"
667 "};\n";
668 LocationVerifier<FriendDecl> ConstructorVerifier;
669 ConstructorVerifier.expectLocation(6, 11);
670 EXPECT_TRUE(ConstructorVerifier.match(
671 Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
672 LocationVerifier<FriendDecl> DestructorVerifier;
673 DestructorVerifier.expectLocation(6, 19);
674 EXPECT_TRUE(DestructorVerifier.match(
675 Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
676 }
677
678 TEST(FriendDecl, FriendConstructorDestructorRange) {
679 const std::string Code = "struct B {\n"
680 "B();\n"
681 "~B();\n"
682 "};\n"
683 "struct A {\n"
684 "friend B::B(), B::~B();\n"
685 "};\n";
686 RangeVerifier<FriendDecl> ConstructorVerifier;
687 ConstructorVerifier.expectRange(6, 1, 6, 13);
688 EXPECT_TRUE(ConstructorVerifier.match(
689 Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
690 RangeVerifier<FriendDecl> DestructorVerifier;
691 DestructorVerifier.expectRange(6, 1, 6, 22);
692 EXPECT_TRUE(DestructorVerifier.match(
693 Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
694 }
695
696 TEST(FriendDecl, FriendTemplateFunctionLocation) {
697 LocationVerifier<FriendDecl> Verifier;
698 Verifier.expectLocation(3, 13);
699 EXPECT_TRUE(Verifier.match("struct A {\n"
700 "template <typename T>\n"
701 "friend void f();\n"
702 "};\n",
703 friendDecl()));
704 }
705
706 TEST(FriendDecl, FriendTemplateFunctionRange) {
707 RangeVerifier<FriendDecl> Verifier;
708 Verifier.expectRange(2, 1, 3, 15);
709 EXPECT_TRUE(Verifier.match("struct A {\n"
710 "template <typename T>\n"
711 "friend void f();\n"
712 "};\n",
713 friendDecl()));
714 }
715
716 TEST(FriendDecl, FriendTemplateClassLocation) {
717 LocationVerifier<FriendDecl> Verifier;
718 Verifier.expectLocation(3, 14);
719 EXPECT_TRUE(Verifier.match("struct A {\n"
720 "template <typename T>\n"
721 "friend class B;\n"
722 "};\n",
723 friendDecl()));
724 }
725
726 TEST(FriendDecl, FriendTemplateClassRange) {
727 RangeVerifier<FriendDecl> Verifier;
728 Verifier.expectRange(2, 1, 3, 14);
729 EXPECT_TRUE(Verifier.match("struct A {\n"
730 "template <typename T>\n"
731 "friend class B;\n"
732 "};\n",
733 friendDecl()));
734 }
735
736 TEST(FriendDecl, FriendInlineFunctionLocation) {
737 LocationVerifier<FriendDecl> Verifier;
738 Verifier.expectLocation(2, 19);
739 EXPECT_TRUE(Verifier.match("struct A {\n"
740 "int inline friend f() { return 0; }"
741 "};\n",
742 friendDecl()));
743 }
744
745 TEST(FriendDecl, FriendInlineFunctionRange) {
746 RangeVerifier<FriendDecl> Verifier;
747 Verifier.expectRange(2, 1, 2, 35);
748 EXPECT_TRUE(Verifier.match("struct A {\n"
749 "int inline friend f() { return 0; }"
750 "};\n",
751 friendDecl(), Lang_CXX11));
752 }
753
754 TEST(FriendDecl, InstantiationSourceRange) {
755 RangeVerifier<FriendDecl> Verifier;
756 Verifier.expectRange(4, 3, 4, 35);
757 EXPECT_TRUE(Verifier.match(
758 "template <typename T> class S;\n"
759 "template<class T> void operator+(S<T> x);\n"
760 "template<class T> struct S {\n"
761 " friend void operator+<>(S<T> src);\n"
762 "};\n"
763 "void test(S<double> s) { +s; }",
764 friendDecl(hasParent(cxxRecordDecl(isTemplateInstantiation())))));
765 }
766
767 TEST(ObjCMessageExpr, ParenExprRange) {
768 RangeVerifier<ParenExpr> Verifier;
769 Verifier.expectRange(5, 25, 5, 27);
770 EXPECT_TRUE(Verifier.match("struct A { int a; };\n"
771 "@interface B {}\n"
772 "+ (void) f1: (A)arg;\n"
773 "@end\n"
774 "void f2() { A a; [B f1: (a)]; }\n",
775 traverse(TK_AsIs, parenExpr()), Lang_OBJCXX));
776 }
777
778 TEST(FunctionDecl, FunctionDeclWithThrowSpecification) {
779 RangeVerifier<FunctionDecl> Verifier;
780 Verifier.expectRange(1, 1, 1, 16);
781 EXPECT_TRUE(Verifier.match(
782 "void f() throw();\n",
783 functionDecl()));
784 }
785
786 TEST(FunctionDecl, FunctionDeclWithNoExceptSpecification) {
787 RangeVerifier<FunctionDecl> Verifier;
788 Verifier.expectRange(1, 1, 1, 24);
789 EXPECT_TRUE(Verifier.match("void f() noexcept(false);\n", functionDecl(),
790 Lang_CXX11));
791 }
792
793 class FunctionDeclParametersRangeVerifier : public RangeVerifier<FunctionDecl> {
794 protected:
795 SourceRange getRange(const FunctionDecl &Function) override {
796 return Function.getParametersSourceRange();
797 }
798 };
799
800 TEST(FunctionDeclParameters, FunctionDeclOnlyVariadic) {
801 FunctionDeclParametersRangeVerifier Verifier;
802 Verifier.expectRange(1, 8, 1, 8);
803 EXPECT_TRUE(Verifier.match("void f(...);\n", functionDecl()));
804 }
805
806 TEST(FunctionDeclParameters, FunctionDeclVariadic) {
807 FunctionDeclParametersRangeVerifier Verifier;
808 Verifier.expectRange(1, 8, 1, 15);
809 EXPECT_TRUE(Verifier.match("void f(int a, ...);\n", functionDecl()));
810 }
811
812 TEST(FunctionDeclParameters, FunctionDeclMacroVariadic) {
813 FunctionDeclParametersRangeVerifier Verifier;
814 Verifier.expectRange(2, 8, 1, 18);
815 EXPECT_TRUE(Verifier.match("#define VARIADIC ...\n"
816 "void f(int a, VARIADIC);\n",
817 functionDecl()));
818 }
819
820 TEST(FunctionDeclParameters, FunctionDeclMacroParams) {
821 FunctionDeclParametersRangeVerifier Verifier;
822 Verifier.expectRange(1, 16, 2, 20);
823 EXPECT_TRUE(Verifier.match("#define PARAMS int a, int b\n"
824 "void f(PARAMS, int c);",
825 functionDecl()));
826 }
827
828 TEST(FunctionDeclParameters, FunctionDeclSingleParameter) {
829 FunctionDeclParametersRangeVerifier Verifier;
830 Verifier.expectRange(1, 8, 1, 12);
831 EXPECT_TRUE(Verifier.match("void f(int a);\n", functionDecl()));
832 }
833
834 TEST(FunctionDeclParameters, MemberFunctionDecl) {
835 FunctionDeclParametersRangeVerifier Verifier;
836 Verifier.expectRange(2, 8, 2, 12);
837 EXPECT_TRUE(Verifier.match("class A{\n"
838 "void f(int a);\n"
839 "};",
840 functionDecl()));
841 }
842
843 TEST(FunctionDeclParameters, MemberFunctionDeclVariadic) {
844 FunctionDeclParametersRangeVerifier Verifier;
845 Verifier.expectRange(2, 8, 2, 15);
846 EXPECT_TRUE(Verifier.match("class A{\n"
847 "void f(int a, ...);\n"
848 "};",
849 functionDecl()));
850 }
851
852 TEST(FunctionDeclParameters, StaticFunctionDecl) {
853 FunctionDeclParametersRangeVerifier Verifier;
854 Verifier.expectRange(2, 15, 2, 19);
855 EXPECT_TRUE(Verifier.match("class A{\n"
856 "static void f(int a);\n"
857 "};",
858 functionDecl()));
859 }
860
861 TEST(FunctionDeclParameters, FunctionDeclMultipleParameters) {
862 FunctionDeclParametersRangeVerifier Verifier;
863 Verifier.expectRange(1, 8, 1, 28);
864 EXPECT_TRUE(
865 Verifier.match("void f(int a, int b, char *c);\n", functionDecl()));
866 }
867
868 TEST(FunctionDeclParameters, FunctionDeclWithDefaultValue) {
869 FunctionDeclParametersRangeVerifier Verifier;
870 Verifier.expectRange(1, 8, 1, 16);
871 EXPECT_TRUE(Verifier.match("void f(int a = 5);\n", functionDecl()));
872 }
873
874 TEST(FunctionDeclParameters, FunctionDeclWithVolatile) {
875 FunctionDeclParametersRangeVerifier Verifier;
876 Verifier.expectRange(1, 8, 1, 22);
877 EXPECT_TRUE(Verifier.match("void f(volatile int *i);", functionDecl()));
878 }
879
880 TEST(FunctionDeclParameters, FunctionDeclWithConstParam) {
881 FunctionDeclParametersRangeVerifier Verifier;
882 Verifier.expectRange(1, 8, 1, 19);
883 EXPECT_TRUE(Verifier.match("void f(const int *i);", functionDecl()));
884 }
885
886 TEST(FunctionDeclParameters, FunctionDeclWithConstVolatileParam) {
887 FunctionDeclParametersRangeVerifier Verifier;
888 Verifier.expectRange(1, 8, 1, 28);
889 EXPECT_TRUE(Verifier.match("void f(const volatile int *i);", functionDecl()));
890 }
891
892 TEST(FunctionDeclParameters, FunctionDeclWithParamAttribute) {
893 FunctionDeclParametersRangeVerifier Verifier;
894 Verifier.expectRange(1, 8, 1, 36);
895 EXPECT_TRUE(Verifier.match("void f(__attribute__((unused)) int a) {}",
896 functionDecl()));
897 }
898
899 TEST(CXXMethodDecl, CXXMethodDeclWithThrowSpecification) {
900 RangeVerifier<FunctionDecl> Verifier;
901 Verifier.expectRange(2, 1, 2, 16);
902 EXPECT_TRUE(Verifier.match(
903 "class A {\n"
904 "void f() throw();\n"
905 "};\n",
906 functionDecl()));
907 }
908
909 TEST(CXXMethodDecl, CXXMethodDeclWithNoExceptSpecification) {
910 RangeVerifier<FunctionDecl> Verifier;
911 Verifier.expectRange(2, 1, 2, 24);
912 EXPECT_TRUE(Verifier.match("class A {\n"
913 "void f() noexcept(false);\n"
914 "};\n",
915 functionDecl(), Lang_CXX11));
916 }
917
918 class ExceptionSpecRangeVerifier : public RangeVerifier<TypeLoc> {
919 protected:
920 SourceRange getRange(const TypeLoc &Node) override {
921 auto T =
922 Node.getUnqualifiedLoc().castAs<FunctionProtoTypeLoc>();
923 assert(!T.isNull());
924 return T.getExceptionSpecRange();
925 }
926 };
927
928 class ParmVarExceptionSpecRangeVerifier : public RangeVerifier<ParmVarDecl> {
929 protected:
930 SourceRange getRange(const ParmVarDecl &Node) override {
931 if (const TypeSourceInfo *TSI = Node.getTypeSourceInfo()) {
932 TypeLoc TL = TSI->getTypeLoc();
933 if (TL.getType()->isPointerType()) {
934 TL = TL.getNextTypeLoc().IgnoreParens();
935 if (auto FPTL = TL.getAs<FunctionProtoTypeLoc>()) {
936 return FPTL.getExceptionSpecRange();
937 }
938 }
939 }
940 return SourceRange();
941 }
942 };
943
944 TEST(FunctionDecl, ExceptionSpecifications) {
945 ExceptionSpecRangeVerifier Verifier;
946
947 Verifier.expectRange(1, 10, 1, 16);
948 EXPECT_TRUE(Verifier.match("void f() throw();\n", loc(functionType())));
949
950 Verifier.expectRange(1, 10, 1, 34);
951 EXPECT_TRUE(Verifier.match("void f() throw(void(void) throw());\n",
952 loc(functionType())));
953
954 Verifier.expectRange(1, 10, 1, 19);
955 std::vector<std::string> Args;
956 Args.push_back("-fms-extensions");
957 EXPECT_TRUE(Verifier.match("void f() throw(...);\n", loc(functionType()),
958 Args, Lang_CXX03));
959
960 Verifier.expectRange(1, 10, 1, 10);
961 EXPECT_TRUE(
962 Verifier.match("void f() noexcept;\n", loc(functionType()), Lang_CXX11));
963
964 Verifier.expectRange(1, 10, 1, 24);
965 EXPECT_TRUE(Verifier.match("void f() noexcept(false);\n", loc(functionType()),
966 Lang_CXX11));
967
968 Verifier.expectRange(1, 10, 1, 32);
969 EXPECT_TRUE(Verifier.match("void f() noexcept(noexcept(1+1));\n",
970 loc(functionType()), Lang_CXX11));
971
972 ParmVarExceptionSpecRangeVerifier Verifier2;
973 Verifier2.expectRange(1, 25, 1, 31);
974 EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) throw());\n",
975 parmVarDecl(hasType(pointerType(pointee(
976 parenType(innerType(functionType()))))))));
977
978 Verifier2.expectRange(1, 25, 1, 38);
979 EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) noexcept(true));\n",
980 parmVarDecl(hasType(pointerType(pointee(
981 parenType(innerType(functionType())))))),
982 Lang_CXX11));
983 }
984
985 TEST(Decl, MemberPointerStarLoc) {
986 llvm::Annotations Example(R"cpp(
987 struct X {};
988 int X::$star^* a;
989 )cpp");
990
991 auto AST = tooling::buildASTFromCode(Example.code());
992 SourceManager &SM = AST->getSourceManager();
993 auto &Ctx = AST->getASTContext();
994
995 auto *VD = selectFirst<VarDecl>("vd", match(varDecl().bind("vd"), Ctx));
996 ASSERT_TRUE(VD != nullptr);
997
998 auto TL =
999 VD->getTypeSourceInfo()->getTypeLoc().castAs<MemberPointerTypeLoc>();
1000 ASSERT_EQ(SM.getFileOffset(TL.getStarLoc()), Example.point("star"));
1001 }
1002
1003 } // end namespace