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