1 //===- unittest/AST/SourceLocationTest.cpp - AST source loc unit tests ----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains tests for SourceLocation and SourceRange fields
11 // in AST nodes.
12 //
13 // FIXME: In the long-term, when we test more than source locations, we may
14 // want to have a unit test file for an AST node (or group of related nodes),
15 // rather than a unit test file for source locations for all AST nodes.
16 //
17 //===----------------------------------------------------------------------===//
18
19 #include "clang/AST/ASTContext.h"
20 #include "MatchVerifier.h"
21 #include "clang/ASTMatchers/ASTMatchFinder.h"
22 #include "clang/ASTMatchers/ASTMatchers.h"
23 #include "clang/Tooling/Tooling.h"
24 #include "gtest/gtest.h"
25
26 namespace clang {
27 namespace ast_matchers {
28
29 // FIXME: Pull the *Verifier tests into their own test file.
30
TEST(MatchVerifier,ParseError)31 TEST(MatchVerifier, ParseError) {
32 LocationVerifier<VarDecl> Verifier;
33 Verifier.expectLocation(1, 1);
34 EXPECT_FALSE(Verifier.match("int i", varDecl()));
35 }
36
TEST(MatchVerifier,NoMatch)37 TEST(MatchVerifier, NoMatch) {
38 LocationVerifier<VarDecl> Verifier;
39 Verifier.expectLocation(1, 1);
40 EXPECT_FALSE(Verifier.match("int i;", recordDecl()));
41 }
42
TEST(MatchVerifier,WrongType)43 TEST(MatchVerifier, WrongType) {
44 LocationVerifier<RecordDecl> Verifier;
45 Verifier.expectLocation(1, 1);
46 EXPECT_FALSE(Verifier.match("int i;", varDecl()));
47 }
48
TEST(LocationVerifier,WrongLocation)49 TEST(LocationVerifier, WrongLocation) {
50 LocationVerifier<VarDecl> Verifier;
51 Verifier.expectLocation(1, 1);
52 EXPECT_FALSE(Verifier.match("int i;", varDecl()));
53 }
54
TEST(RangeVerifier,WrongRange)55 TEST(RangeVerifier, WrongRange) {
56 RangeVerifier<VarDecl> Verifier;
57 Verifier.expectRange(1, 1, 1, 1);
58 EXPECT_FALSE(Verifier.match("int i;", varDecl()));
59 }
60
61 class LabelDeclRangeVerifier : public RangeVerifier<LabelStmt> {
62 protected:
getRange(const LabelStmt & Node)63 virtual SourceRange getRange(const LabelStmt &Node) {
64 return Node.getDecl()->getSourceRange();
65 }
66 };
67
TEST(LabelDecl,Range)68 TEST(LabelDecl, Range) {
69 LabelDeclRangeVerifier Verifier;
70 Verifier.expectRange(1, 12, 1, 12);
71 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
72 }
73
TEST(LabelStmt,Range)74 TEST(LabelStmt, Range) {
75 RangeVerifier<LabelStmt> Verifier;
76 Verifier.expectRange(1, 12, 1, 15);
77 EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
78 }
79
TEST(ParmVarDecl,KNRLocation)80 TEST(ParmVarDecl, KNRLocation) {
81 LocationVerifier<ParmVarDecl> Verifier;
82 Verifier.expectLocation(1, 8);
83 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
84 }
85
TEST(ParmVarDecl,KNRRange)86 TEST(ParmVarDecl, KNRRange) {
87 RangeVerifier<ParmVarDecl> Verifier;
88 Verifier.expectRange(1, 8, 1, 8);
89 EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
90 }
91
TEST(CXXNewExpr,ArrayRange)92 TEST(CXXNewExpr, ArrayRange) {
93 RangeVerifier<CXXNewExpr> Verifier;
94 Verifier.expectRange(1, 12, 1, 22);
95 EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", newExpr()));
96 }
97
TEST(CXXNewExpr,ParenRange)98 TEST(CXXNewExpr, ParenRange) {
99 RangeVerifier<CXXNewExpr> Verifier;
100 Verifier.expectRange(1, 12, 1, 20);
101 EXPECT_TRUE(Verifier.match("void f() { new int(); }", newExpr()));
102 }
103
TEST(MemberExpr,ImplicitMemberRange)104 TEST(MemberExpr, ImplicitMemberRange) {
105 RangeVerifier<MemberExpr> Verifier;
106 Verifier.expectRange(2, 30, 2, 30);
107 EXPECT_TRUE(Verifier.match("struct S { operator int() const; };\n"
108 "int foo(const S& s) { return s; }",
109 memberExpr()));
110 }
111
TEST(VarDecl,VMTypeFixedVarDeclRange)112 TEST(VarDecl, VMTypeFixedVarDeclRange) {
113 RangeVerifier<VarDecl> Verifier;
114 Verifier.expectRange(1, 1, 1, 23);
115 EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];",
116 varDecl(), Lang_C89));
117 }
118
TEST(CXXConstructorDecl,NoRetFunTypeLocRange)119 TEST(CXXConstructorDecl, NoRetFunTypeLocRange) {
120 RangeVerifier<CXXConstructorDecl> Verifier;
121 Verifier.expectRange(1, 11, 1, 13);
122 EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl()));
123 }
124
TEST(CompoundLiteralExpr,CompoundVectorLiteralRange)125 TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) {
126 RangeVerifier<CompoundLiteralExpr> Verifier;
127 Verifier.expectRange(2, 11, 2, 22);
128 EXPECT_TRUE(Verifier.match(
129 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
130 "int2 i2 = (int2){1, 2};", compoundLiteralExpr()));
131 }
132
TEST(CompoundLiteralExpr,ParensCompoundVectorLiteralRange)133 TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) {
134 RangeVerifier<CompoundLiteralExpr> Verifier;
135 Verifier.expectRange(2, 20, 2, 31);
136 EXPECT_TRUE(Verifier.match(
137 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
138 "constant int2 i2 = (int2)(1, 2);",
139 compoundLiteralExpr(), Lang_OpenCL));
140 }
141
TEST(InitListExpr,VectorLiteralListBraceRange)142 TEST(InitListExpr, VectorLiteralListBraceRange) {
143 RangeVerifier<InitListExpr> Verifier;
144 Verifier.expectRange(2, 17, 2, 22);
145 EXPECT_TRUE(Verifier.match(
146 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
147 "int2 i2 = (int2){1, 2};", initListExpr()));
148 }
149
TEST(InitListExpr,VectorLiteralInitListParens)150 TEST(InitListExpr, VectorLiteralInitListParens) {
151 RangeVerifier<InitListExpr> Verifier;
152 Verifier.expectRange(2, 26, 2, 31);
153 EXPECT_TRUE(Verifier.match(
154 "typedef int int2 __attribute__((ext_vector_type(2)));\n"
155 "constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL));
156 }
157
158 class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> {
159 protected:
getRange(const TypeLoc & Node)160 virtual SourceRange getRange(const TypeLoc &Node) {
161 TemplateSpecializationTypeLoc T =
162 Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>();
163 assert(!T.isNull());
164 return SourceRange(T.getLAngleLoc(), T.getRAngleLoc());
165 }
166 };
167
TEST(TemplateSpecializationTypeLoc,AngleBracketLocations)168 TEST(TemplateSpecializationTypeLoc, AngleBracketLocations) {
169 TemplateAngleBracketLocRangeVerifier Verifier;
170 Verifier.expectRange(2, 8, 2, 10);
171 EXPECT_TRUE(Verifier.match(
172 "template<typename T> struct A {}; struct B{}; void f(\n"
173 "const A<B>&);",
174 loc(templateSpecializationType())));
175 }
176
TEST(CXXNewExpr,TypeParenRange)177 TEST(CXXNewExpr, TypeParenRange) {
178 RangeVerifier<CXXNewExpr> Verifier;
179 Verifier.expectRange(1, 10, 1, 18);
180 EXPECT_TRUE(Verifier.match("int* a = new (int);", newExpr()));
181 }
182
183 class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> {
184 protected:
getRange(const TypeLoc & Node)185 virtual SourceRange getRange(const TypeLoc &Node) {
186 UnaryTransformTypeLoc T =
187 Node.getUnqualifiedLoc().castAs<UnaryTransformTypeLoc>();
188 assert(!T.isNull());
189 return SourceRange(T.getLParenLoc(), T.getRParenLoc());
190 }
191 };
192
TEST(UnaryTransformTypeLoc,ParensRange)193 TEST(UnaryTransformTypeLoc, ParensRange) {
194 UnaryTransformTypeLocParensRangeVerifier Verifier;
195 Verifier.expectRange(3, 26, 3, 28);
196 EXPECT_TRUE(Verifier.match(
197 "template <typename T>\n"
198 "struct S {\n"
199 "typedef __underlying_type(T) type;\n"
200 "};",
201 loc(unaryTransformType())));
202 }
203
TEST(CXXFunctionalCastExpr,SourceRange)204 TEST(CXXFunctionalCastExpr, SourceRange) {
205 RangeVerifier<CXXFunctionalCastExpr> Verifier;
206 Verifier.expectRange(2, 10, 2, 14);
207 EXPECT_TRUE(Verifier.match(
208 "int foo() {\n"
209 " return int{};\n"
210 "}",
211 functionalCastExpr(), Lang_CXX11));
212 }
213
TEST(CXXConstructExpr,SourceRange)214 TEST(CXXConstructExpr, SourceRange) {
215 RangeVerifier<CXXConstructExpr> Verifier;
216 Verifier.expectRange(3, 14, 3, 19);
217 EXPECT_TRUE(Verifier.match(
218 "struct A { A(int, int); };\n"
219 "void f(A a);\n"
220 "void g() { f({0, 0}); }",
221 constructExpr(), Lang_CXX11));
222 }
223
TEST(CXXTemporaryObjectExpr,SourceRange)224 TEST(CXXTemporaryObjectExpr, SourceRange) {
225 RangeVerifier<CXXTemporaryObjectExpr> Verifier;
226 Verifier.expectRange(2, 6, 2, 12);
227 EXPECT_TRUE(Verifier.match(
228 "struct A { A(int, int); };\n"
229 "A a( A{0, 0} );",
230 temporaryObjectExpr(), Lang_CXX11));
231 }
232
TEST(CXXUnresolvedConstructExpr,SourceRange)233 TEST(CXXUnresolvedConstructExpr, SourceRange) {
234 RangeVerifier<CXXUnresolvedConstructExpr> Verifier;
235 Verifier.expectRange(3, 10, 3, 12);
236 std::vector<std::string> Args;
237 Args.push_back("-fno-delayed-template-parsing");
238 EXPECT_TRUE(Verifier.match(
239 "template <typename U>\n"
240 "U foo() {\n"
241 " return U{};\n"
242 "}",
243 unresolvedConstructExpr(), Args, Lang_CXX11));
244 }
245
TEST(UsingDecl,SourceRange)246 TEST(UsingDecl, SourceRange) {
247 RangeVerifier<UsingDecl> Verifier;
248 Verifier.expectRange(2, 22, 2, 25);
249 EXPECT_TRUE(Verifier.match(
250 "class B { protected: int i; };\n"
251 "class D : public B { B::i; };",
252 usingDecl()));
253 }
254
TEST(UnresolvedUsingValueDecl,SourceRange)255 TEST(UnresolvedUsingValueDecl, SourceRange) {
256 RangeVerifier<UnresolvedUsingValueDecl> Verifier;
257 Verifier.expectRange(3, 3, 3, 6);
258 EXPECT_TRUE(Verifier.match(
259 "template <typename B>\n"
260 "class D : public B {\n"
261 " B::i;\n"
262 "};",
263 unresolvedUsingValueDecl()));
264 }
265
TEST(FriendDecl,FriendNonMemberFunctionLocation)266 TEST(FriendDecl, FriendNonMemberFunctionLocation) {
267 LocationVerifier<FriendDecl> Verifier;
268 Verifier.expectLocation(2, 13);
269 EXPECT_TRUE(Verifier.match("struct A {\n"
270 "friend void f();\n"
271 "};\n",
272 friendDecl()));
273 }
274
TEST(FriendDecl,FriendNonMemberFunctionRange)275 TEST(FriendDecl, FriendNonMemberFunctionRange) {
276 RangeVerifier<FriendDecl> Verifier;
277 Verifier.expectRange(2, 1, 2, 15);
278 EXPECT_TRUE(Verifier.match("struct A {\n"
279 "friend void f();\n"
280 "};\n",
281 friendDecl()));
282 }
283
TEST(FriendDecl,FriendNonMemberFunctionDefinitionLocation)284 TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) {
285 LocationVerifier<FriendDecl> Verifier;
286 Verifier.expectLocation(2, 12);
287 EXPECT_TRUE(Verifier.match("struct A {\n"
288 "friend int f() { return 0; }\n"
289 "};\n",
290 friendDecl()));
291 }
292
TEST(FriendDecl,FriendNonMemberFunctionDefinitionRange)293 TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) {
294 RangeVerifier<FriendDecl> Verifier;
295 Verifier.expectRange(2, 1, 2, 28);
296 EXPECT_TRUE(Verifier.match("struct A {\n"
297 "friend int f() { return 0; }\n"
298 "};\n",
299 friendDecl()));
300 }
301
TEST(FriendDecl,FriendElaboratedTypeLocation)302 TEST(FriendDecl, FriendElaboratedTypeLocation) {
303 LocationVerifier<FriendDecl> Verifier;
304 Verifier.expectLocation(2, 8);
305 EXPECT_TRUE(Verifier.match("struct A {\n"
306 "friend class B;\n"
307 "};\n",
308 friendDecl()));
309 }
310
TEST(FriendDecl,FriendElaboratedTypeRange)311 TEST(FriendDecl, FriendElaboratedTypeRange) {
312 RangeVerifier<FriendDecl> Verifier;
313 Verifier.expectRange(2, 1, 2, 14);
314 EXPECT_TRUE(Verifier.match("struct A {\n"
315 "friend class B;\n"
316 "};\n",
317 friendDecl()));
318 }
319
TEST(FriendDecl,FriendSimpleTypeLocation)320 TEST(FriendDecl, FriendSimpleTypeLocation) {
321 LocationVerifier<FriendDecl> Verifier;
322 Verifier.expectLocation(3, 8);
323 EXPECT_TRUE(Verifier.match("class B;\n"
324 "struct A {\n"
325 "friend B;\n"
326 "};\n",
327 friendDecl(), Lang_CXX11));
328 }
329
TEST(FriendDecl,FriendSimpleTypeRange)330 TEST(FriendDecl, FriendSimpleTypeRange) {
331 RangeVerifier<FriendDecl> Verifier;
332 Verifier.expectRange(3, 1, 3, 8);
333 EXPECT_TRUE(Verifier.match("class B;\n"
334 "struct A {\n"
335 "friend B;\n"
336 "};\n",
337 friendDecl(), Lang_CXX11));
338 }
339
TEST(FriendDecl,FriendTemplateParameterLocation)340 TEST(FriendDecl, FriendTemplateParameterLocation) {
341 LocationVerifier<FriendDecl> Verifier;
342 Verifier.expectLocation(3, 8);
343 EXPECT_TRUE(Verifier.match("template <typename T>\n"
344 "struct A {\n"
345 "friend T;\n"
346 "};\n",
347 friendDecl(), Lang_CXX11));
348 }
349
TEST(FriendDecl,FriendTemplateParameterRange)350 TEST(FriendDecl, FriendTemplateParameterRange) {
351 RangeVerifier<FriendDecl> Verifier;
352 Verifier.expectRange(3, 1, 3, 8);
353 EXPECT_TRUE(Verifier.match("template <typename T>\n"
354 "struct A {\n"
355 "friend T;\n"
356 "};\n",
357 friendDecl(), Lang_CXX11));
358 }
359
TEST(FriendDecl,FriendDecltypeLocation)360 TEST(FriendDecl, FriendDecltypeLocation) {
361 LocationVerifier<FriendDecl> Verifier;
362 Verifier.expectLocation(4, 8);
363 EXPECT_TRUE(Verifier.match("struct A;\n"
364 "A foo();\n"
365 "struct A {\n"
366 "friend decltype(foo());\n"
367 "};\n",
368 friendDecl(), Lang_CXX11));
369 }
370
TEST(FriendDecl,FriendDecltypeRange)371 TEST(FriendDecl, FriendDecltypeRange) {
372 RangeVerifier<FriendDecl> Verifier;
373 Verifier.expectRange(4, 1, 4, 8);
374 EXPECT_TRUE(Verifier.match("struct A;\n"
375 "A foo();\n"
376 "struct A {\n"
377 "friend decltype(foo());\n"
378 "};\n",
379 friendDecl(), Lang_CXX11));
380 }
381
TEST(FriendDecl,FriendConstructorDestructorLocation)382 TEST(FriendDecl, FriendConstructorDestructorLocation) {
383 const std::string Code = "struct B {\n"
384 "B();\n"
385 "~B();\n"
386 "};\n"
387 "struct A {\n"
388 "friend B::B(), B::~B();\n"
389 "};\n";
390 LocationVerifier<FriendDecl> ConstructorVerifier;
391 ConstructorVerifier.expectLocation(6, 11);
392 EXPECT_TRUE(ConstructorVerifier.match(
393 Code, friendDecl(has(constructorDecl(ofClass(hasName("B")))))));
394 LocationVerifier<FriendDecl> DestructorVerifier;
395 DestructorVerifier.expectLocation(6, 19);
396 EXPECT_TRUE(DestructorVerifier.match(
397 Code, friendDecl(has(destructorDecl(ofClass(hasName("B")))))));
398 }
399
TEST(FriendDecl,FriendConstructorDestructorRange)400 TEST(FriendDecl, FriendConstructorDestructorRange) {
401 const std::string Code = "struct B {\n"
402 "B();\n"
403 "~B();\n"
404 "};\n"
405 "struct A {\n"
406 "friend B::B(), B::~B();\n"
407 "};\n";
408 RangeVerifier<FriendDecl> ConstructorVerifier;
409 ConstructorVerifier.expectRange(6, 1, 6, 13);
410 EXPECT_TRUE(ConstructorVerifier.match(
411 Code, friendDecl(has(constructorDecl(ofClass(hasName("B")))))));
412 RangeVerifier<FriendDecl> DestructorVerifier;
413 DestructorVerifier.expectRange(6, 1, 6, 22);
414 EXPECT_TRUE(DestructorVerifier.match(
415 Code, friendDecl(has(destructorDecl(ofClass(hasName("B")))))));
416 }
417
TEST(FriendDecl,FriendTemplateFunctionLocation)418 TEST(FriendDecl, FriendTemplateFunctionLocation) {
419 LocationVerifier<FriendDecl> Verifier;
420 Verifier.expectLocation(3, 13);
421 EXPECT_TRUE(Verifier.match("struct A {\n"
422 "template <typename T>\n"
423 "friend void f();\n"
424 "};\n",
425 friendDecl()));
426 }
427
TEST(FriendDecl,FriendTemplateFunctionRange)428 TEST(FriendDecl, FriendTemplateFunctionRange) {
429 RangeVerifier<FriendDecl> Verifier;
430 Verifier.expectRange(2, 1, 3, 15);
431 EXPECT_TRUE(Verifier.match("struct A {\n"
432 "template <typename T>\n"
433 "friend void f();\n"
434 "};\n",
435 friendDecl()));
436 }
437
TEST(FriendDecl,FriendTemplateClassLocation)438 TEST(FriendDecl, FriendTemplateClassLocation) {
439 LocationVerifier<FriendDecl> Verifier;
440 Verifier.expectLocation(3, 14);
441 EXPECT_TRUE(Verifier.match("struct A {\n"
442 "template <typename T>\n"
443 "friend class B;\n"
444 "};\n",
445 friendDecl()));
446 }
447
TEST(FriendDecl,FriendTemplateClassRange)448 TEST(FriendDecl, FriendTemplateClassRange) {
449 RangeVerifier<FriendDecl> Verifier;
450 Verifier.expectRange(2, 1, 3, 14);
451 EXPECT_TRUE(Verifier.match("struct A {\n"
452 "template <typename T>\n"
453 "friend class B;\n"
454 "};\n",
455 friendDecl()));
456 }
457
TEST(FriendDecl,FriendInlineFunctionLocation)458 TEST(FriendDecl, FriendInlineFunctionLocation) {
459 LocationVerifier<FriendDecl> Verifier;
460 Verifier.expectLocation(2, 19);
461 EXPECT_TRUE(Verifier.match("struct A {\n"
462 "int inline friend f() { return 0; }"
463 "};\n",
464 friendDecl()));
465 }
466
TEST(FriendDecl,FriendInlineFunctionRange)467 TEST(FriendDecl, FriendInlineFunctionRange) {
468 RangeVerifier<FriendDecl> Verifier;
469 Verifier.expectRange(2, 1, 2, 35);
470 EXPECT_TRUE(Verifier.match("struct A {\n"
471 "int inline friend f() { return 0; }"
472 "};\n",
473 friendDecl(), Lang_CXX11));
474 }
475
TEST(FriendDecl,InstantiationSourceRange)476 TEST(FriendDecl, InstantiationSourceRange) {
477 RangeVerifier<FriendDecl> Verifier;
478 Verifier.expectRange(4, 3, 4, 35);
479 EXPECT_TRUE(Verifier.match(
480 "template <typename T> class S;\n"
481 "template<class T> void operator+(S<T> x);\n"
482 "template<class T> struct S {\n"
483 " friend void operator+<>(S<T> src);\n"
484 "};\n"
485 "void test(S<double> s) { +s; }",
486 friendDecl(hasParent(recordDecl(isTemplateInstantiation())))));
487 }
488
TEST(ObjCMessageExpr,CXXConstructExprRange)489 TEST(ObjCMessageExpr, CXXConstructExprRange) {
490 RangeVerifier<CXXConstructExpr> Verifier;
491 Verifier.expectRange(5, 25, 5, 27);
492 EXPECT_TRUE(Verifier.match(
493 "struct A { int a; };\n"
494 "@interface B {}\n"
495 "+ (void) f1: (A)arg;\n"
496 "@end\n"
497 "void f2() { A a; [B f1: (a)]; }\n",
498 constructExpr(), Lang_OBJCXX));
499 }
500
501 } // end namespace ast_matchers
502 } // end namespace clang
503