Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 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" |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 20 | #include "MatchVerifier.h" |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 21 | #include "clang/ASTMatchers/ASTMatchFinder.h" |
Chandler Carruth | 1050e8b | 2012-12-04 09:45:34 +0000 | [diff] [blame] | 22 | #include "clang/ASTMatchers/ASTMatchers.h" |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 23 | #include "clang/Tooling/Tooling.h" |
| 24 | #include "gtest/gtest.h" |
| 25 | |
| 26 | namespace clang { |
| 27 | namespace ast_matchers { |
| 28 | |
Manuel Klimek | 4d0e9f5 | 2013-01-31 13:10:40 +0000 | [diff] [blame] | 29 | // FIXME: Pull the *Verifier tests into their own test file. |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 30 | |
| 31 | TEST(MatchVerifier, ParseError) { |
| 32 | LocationVerifier<VarDecl> Verifier; |
| 33 | Verifier.expectLocation(1, 1); |
| 34 | EXPECT_FALSE(Verifier.match("int i", varDecl())); |
| 35 | } |
| 36 | |
| 37 | TEST(MatchVerifier, NoMatch) { |
| 38 | LocationVerifier<VarDecl> Verifier; |
| 39 | Verifier.expectLocation(1, 1); |
| 40 | EXPECT_FALSE(Verifier.match("int i;", recordDecl())); |
| 41 | } |
| 42 | |
| 43 | TEST(MatchVerifier, WrongType) { |
| 44 | LocationVerifier<RecordDecl> Verifier; |
| 45 | Verifier.expectLocation(1, 1); |
| 46 | EXPECT_FALSE(Verifier.match("int i;", varDecl())); |
| 47 | } |
| 48 | |
| 49 | TEST(LocationVerifier, WrongLocation) { |
| 50 | LocationVerifier<VarDecl> Verifier; |
| 51 | Verifier.expectLocation(1, 1); |
| 52 | EXPECT_FALSE(Verifier.match("int i;", varDecl())); |
| 53 | } |
| 54 | |
| 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: |
Pirama Arumuga Nainar | 33337ca | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 63 | SourceRange getRange(const LabelStmt &Node) override { |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 64 | return Node.getDecl()->getSourceRange(); |
| 65 | } |
| 66 | }; |
| 67 | |
| 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 | |
| 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 | |
| 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 | |
| 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 | |
David Blaikie | 5a78985 | 2012-11-07 17:17:07 +0000 | [diff] [blame] | 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 | |
David Blaikie | c2fc67e | 2012-11-08 22:53:48 +0000 | [diff] [blame] | 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 | |
Abramo Bagnara | 13fd684 | 2012-11-08 13:52:58 +0000 | [diff] [blame] | 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; }", |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 109 | memberExpr()));
|
| 110 | }
|
| 111 |
|
| 112 | class MemberExprArrowLocVerifier : public RangeVerifier<MemberExpr> {
|
Pirama Arumuga Nainar | 33337ca | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 113 | protected: |
| 114 | SourceRange getRange(const MemberExpr &Node) override { |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 115 | return Node.getOperatorLoc();
|
| 116 | }
|
| 117 | };
|
| 118 |
|
| 119 | TEST(MemberExpr, ArrowRange) {
|
| 120 | MemberExprArrowLocVerifier Verifier;
|
| 121 | Verifier.expectRange(2, 19, 2, 19);
|
| 122 | EXPECT_TRUE(Verifier.match("struct S { int x; };\n"
|
| 123 | "void foo(S *s) { s->x = 0; }",
|
| 124 | memberExpr()));
|
| 125 | }
|
| 126 |
|
| 127 | TEST(MemberExpr, MacroArrowRange) {
|
| 128 | MemberExprArrowLocVerifier Verifier;
|
| 129 | Verifier.expectRange(1, 24, 1, 24);
|
| 130 | EXPECT_TRUE(Verifier.match("#define MEMBER(a, b) (a->b)\n"
|
| 131 | "struct S { int x; };\n"
|
| 132 | "void foo(S *s) { MEMBER(s, x) = 0; }",
|
| 133 | memberExpr()));
|
| 134 | }
|
| 135 |
|
| 136 | TEST(MemberExpr, ImplicitArrowRange) {
|
| 137 | MemberExprArrowLocVerifier Verifier;
|
| 138 | Verifier.expectRange(0, 0, 0, 0);
|
| 139 | EXPECT_TRUE(Verifier.match("struct S { int x; void Test(); };\n"
|
| 140 | "void S::Test() { x = 1; }",
|
| 141 | memberExpr()));
|
| 142 | }
|
| 143 |
|
| 144 | TEST(VarDecl, VMTypeFixedVarDeclRange) {
|
| 145 | RangeVerifier<VarDecl> Verifier;
|
| 146 | Verifier.expectRange(1, 1, 1, 23);
|
Abramo Bagnara | 4c5750e | 2012-11-08 14:44:42 +0000 | [diff] [blame] | 147 | EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];", |
| 148 | varDecl(), Lang_C89)); |
| 149 | } |
| 150 | |
| 151 | TEST(CXXConstructorDecl, NoRetFunTypeLocRange) { |
| 152 | RangeVerifier<CXXConstructorDecl> Verifier; |
| 153 | Verifier.expectRange(1, 11, 1, 13); |
| 154 | EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl())); |
| 155 | } |
| 156 | |
Pirama Arumuga Nainar | 3ea9e33 | 2015-04-08 08:57:32 -0700 | [diff] [blame] | 157 | TEST(CXXConstructorDecl, DefaultedCtorLocRange) { |
| 158 | RangeVerifier<CXXConstructorDecl> Verifier; |
| 159 | Verifier.expectRange(1, 11, 1, 23); |
| 160 | EXPECT_TRUE(Verifier.match("class C { C() = default; };", functionDecl())); |
| 161 | } |
| 162 | |
| 163 | TEST(CXXConstructorDecl, DeletedCtorLocRange) { |
| 164 | RangeVerifier<CXXConstructorDecl> Verifier; |
| 165 | Verifier.expectRange(1, 11, 1, 22); |
| 166 | EXPECT_TRUE(Verifier.match("class C { C() = delete; };", functionDecl())); |
| 167 | } |
| 168 | |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 169 | TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) { |
| 170 | RangeVerifier<CompoundLiteralExpr> Verifier; |
| 171 | Verifier.expectRange(2, 11, 2, 22); |
| 172 | EXPECT_TRUE(Verifier.match( |
| 173 | "typedef int int2 __attribute__((ext_vector_type(2)));\n" |
| 174 | "int2 i2 = (int2){1, 2};", compoundLiteralExpr())); |
| 175 | } |
| 176 | |
| 177 | TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) { |
| 178 | RangeVerifier<CompoundLiteralExpr> Verifier; |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 179 | Verifier.expectRange(2, 20, 2, 31); |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 180 | EXPECT_TRUE(Verifier.match( |
| 181 | "typedef int int2 __attribute__((ext_vector_type(2)));\n" |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 182 | "constant int2 i2 = (int2)(1, 2);", |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 183 | compoundLiteralExpr(), Lang_OpenCL)); |
| 184 | } |
| 185 | |
| 186 | TEST(InitListExpr, VectorLiteralListBraceRange) { |
| 187 | RangeVerifier<InitListExpr> Verifier; |
| 188 | Verifier.expectRange(2, 17, 2, 22); |
| 189 | EXPECT_TRUE(Verifier.match( |
| 190 | "typedef int int2 __attribute__((ext_vector_type(2)));\n" |
| 191 | "int2 i2 = (int2){1, 2};", initListExpr())); |
| 192 | } |
| 193 | |
| 194 | TEST(InitListExpr, VectorLiteralInitListParens) { |
| 195 | RangeVerifier<InitListExpr> Verifier; |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 196 | Verifier.expectRange(2, 26, 2, 31); |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 197 | EXPECT_TRUE(Verifier.match( |
| 198 | "typedef int int2 __attribute__((ext_vector_type(2)));\n" |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 199 | "constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL)); |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 200 | } |
| 201 | |
Manuel Klimek | 7e6e515 | 2013-06-07 11:27:57 +0000 | [diff] [blame] | 202 | class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> { |
| 203 | protected: |
Pirama Arumuga Nainar | 33337ca | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 204 | SourceRange getRange(const TypeLoc &Node) override { |
Manuel Klimek | 7e6e515 | 2013-06-07 11:27:57 +0000 | [diff] [blame] | 205 | TemplateSpecializationTypeLoc T = |
Eli Friedman | 44ee0a7 | 2013-06-07 20:31:48 +0000 | [diff] [blame] | 206 | Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>(); |
Manuel Klimek | 7e6e515 | 2013-06-07 11:27:57 +0000 | [diff] [blame] | 207 | assert(!T.isNull()); |
| 208 | return SourceRange(T.getLAngleLoc(), T.getRAngleLoc()); |
| 209 | } |
| 210 | }; |
| 211 | |
| 212 | TEST(TemplateSpecializationTypeLoc, AngleBracketLocations) { |
| 213 | TemplateAngleBracketLocRangeVerifier Verifier; |
| 214 | Verifier.expectRange(2, 8, 2, 10); |
| 215 | EXPECT_TRUE(Verifier.match( |
| 216 | "template<typename T> struct A {}; struct B{}; void f(\n" |
| 217 | "const A<B>&);", |
| 218 | loc(templateSpecializationType()))); |
| 219 | } |
| 220 | |
Eli Friedman | 6e40c95 | 2013-06-17 22:35:10 +0000 | [diff] [blame] | 221 | TEST(CXXNewExpr, TypeParenRange) { |
| 222 | RangeVerifier<CXXNewExpr> Verifier; |
| 223 | Verifier.expectRange(1, 10, 1, 18); |
| 224 | EXPECT_TRUE(Verifier.match("int* a = new (int);", newExpr())); |
| 225 | } |
| 226 | |
Enea Zaffanella | 2d77634 | 2013-07-06 18:54:58 +0000 | [diff] [blame] | 227 | class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> { |
| 228 | protected: |
Pirama Arumuga Nainar | 33337ca | 2015-05-06 11:48:57 -0700 | [diff] [blame] | 229 | SourceRange getRange(const TypeLoc &Node) override { |
Enea Zaffanella | 2d77634 | 2013-07-06 18:54:58 +0000 | [diff] [blame] | 230 | UnaryTransformTypeLoc T = |
| 231 | Node.getUnqualifiedLoc().castAs<UnaryTransformTypeLoc>(); |
| 232 | assert(!T.isNull()); |
| 233 | return SourceRange(T.getLParenLoc(), T.getRParenLoc()); |
| 234 | } |
| 235 | }; |
| 236 | |
| 237 | TEST(UnaryTransformTypeLoc, ParensRange) { |
| 238 | UnaryTransformTypeLocParensRangeVerifier Verifier; |
| 239 | Verifier.expectRange(3, 26, 3, 28); |
| 240 | EXPECT_TRUE(Verifier.match( |
| 241 | "template <typename T>\n" |
| 242 | "struct S {\n" |
| 243 | "typedef __underlying_type(T) type;\n" |
| 244 | "};", |
| 245 | loc(unaryTransformType()))); |
| 246 | } |
| 247 | |
Enea Zaffanella | bd9cbd2 | 2013-07-07 06:41:54 +0000 | [diff] [blame] | 248 | TEST(CXXFunctionalCastExpr, SourceRange) { |
| 249 | RangeVerifier<CXXFunctionalCastExpr> Verifier; |
| 250 | Verifier.expectRange(2, 10, 2, 14); |
| 251 | EXPECT_TRUE(Verifier.match( |
| 252 | "int foo() {\n" |
| 253 | " return int{};\n" |
| 254 | "}", |
| 255 | functionalCastExpr(), Lang_CXX11)); |
| 256 | } |
| 257 | |
Stephen Hines | 651f13c | 2014-04-23 16:59:28 -0700 | [diff] [blame] | 258 | TEST(CXXConstructExpr, SourceRange) { |
| 259 | RangeVerifier<CXXConstructExpr> Verifier; |
| 260 | Verifier.expectRange(3, 14, 3, 19); |
| 261 | EXPECT_TRUE(Verifier.match( |
| 262 | "struct A { A(int, int); };\n" |
| 263 | "void f(A a);\n" |
| 264 | "void g() { f({0, 0}); }", |
| 265 | constructExpr(), Lang_CXX11)); |
| 266 | } |
| 267 | |
Enea Zaffanella | 1245a54 | 2013-09-07 05:49:53 +0000 | [diff] [blame] | 268 | TEST(CXXTemporaryObjectExpr, SourceRange) { |
| 269 | RangeVerifier<CXXTemporaryObjectExpr> Verifier; |
| 270 | Verifier.expectRange(2, 6, 2, 12); |
| 271 | EXPECT_TRUE(Verifier.match( |
| 272 | "struct A { A(int, int); };\n" |
| 273 | "A a( A{0, 0} );", |
| 274 | temporaryObjectExpr(), Lang_CXX11)); |
| 275 | } |
| 276 | |
Enea Zaffanella | bd9cbd2 | 2013-07-07 06:41:54 +0000 | [diff] [blame] | 277 | TEST(CXXUnresolvedConstructExpr, SourceRange) { |
| 278 | RangeVerifier<CXXUnresolvedConstructExpr> Verifier; |
| 279 | Verifier.expectRange(3, 10, 3, 12); |
Enea Zaffanella | 51da142 | 2013-07-08 14:50:30 +0000 | [diff] [blame] | 280 | std::vector<std::string> Args; |
| 281 | Args.push_back("-fno-delayed-template-parsing"); |
Enea Zaffanella | bd9cbd2 | 2013-07-07 06:41:54 +0000 | [diff] [blame] | 282 | EXPECT_TRUE(Verifier.match( |
| 283 | "template <typename U>\n" |
| 284 | "U foo() {\n" |
| 285 | " return U{};\n" |
| 286 | "}", |
Enea Zaffanella | 51da142 | 2013-07-08 14:50:30 +0000 | [diff] [blame] | 287 | unresolvedConstructExpr(), Args, Lang_CXX11)); |
Enea Zaffanella | bd9cbd2 | 2013-07-07 06:41:54 +0000 | [diff] [blame] | 288 | } |
| 289 | |
Enea Zaffanella | d4de59d | 2013-07-17 17:28:56 +0000 | [diff] [blame] | 290 | TEST(UsingDecl, SourceRange) { |
| 291 | RangeVerifier<UsingDecl> Verifier; |
| 292 | Verifier.expectRange(2, 22, 2, 25); |
| 293 | EXPECT_TRUE(Verifier.match( |
| 294 | "class B { protected: int i; };\n" |
| 295 | "class D : public B { B::i; };", |
| 296 | usingDecl())); |
| 297 | } |
| 298 | |
| 299 | TEST(UnresolvedUsingValueDecl, SourceRange) { |
| 300 | RangeVerifier<UnresolvedUsingValueDecl> Verifier; |
| 301 | Verifier.expectRange(3, 3, 3, 6); |
| 302 | EXPECT_TRUE(Verifier.match( |
| 303 | "template <typename B>\n" |
| 304 | "class D : public B {\n" |
| 305 | " B::i;\n" |
| 306 | "};", |
| 307 | unresolvedUsingValueDecl())); |
| 308 | } |
| 309 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 310 | TEST(FriendDecl, FriendNonMemberFunctionLocation) { |
Stephen Hines | c568f1e | 2014-07-21 00:47:37 -0700 | [diff] [blame] | 311 | LocationVerifier<FriendDecl> Verifier; |
| 312 | Verifier.expectLocation(2, 13); |
| 313 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 314 | "friend void f();\n" |
| 315 | "};\n", |
| 316 | friendDecl())); |
| 317 | } |
| 318 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 319 | TEST(FriendDecl, FriendNonMemberFunctionRange) { |
Stephen Hines | c568f1e | 2014-07-21 00:47:37 -0700 | [diff] [blame] | 320 | RangeVerifier<FriendDecl> Verifier; |
| 321 | Verifier.expectRange(2, 1, 2, 15); |
| 322 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 323 | "friend void f();\n" |
| 324 | "};\n", |
| 325 | friendDecl())); |
| 326 | } |
| 327 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 328 | TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) { |
| 329 | LocationVerifier<FriendDecl> Verifier; |
| 330 | Verifier.expectLocation(2, 12); |
| 331 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 332 | "friend int f() { return 0; }\n" |
| 333 | "};\n", |
| 334 | friendDecl())); |
| 335 | } |
| 336 | |
| 337 | TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) { |
| 338 | RangeVerifier<FriendDecl> Verifier; |
| 339 | Verifier.expectRange(2, 1, 2, 28); |
| 340 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 341 | "friend int f() { return 0; }\n" |
| 342 | "};\n", |
| 343 | friendDecl())); |
| 344 | } |
| 345 | |
| 346 | TEST(FriendDecl, FriendElaboratedTypeLocation) { |
Stephen Hines | c568f1e | 2014-07-21 00:47:37 -0700 | [diff] [blame] | 347 | LocationVerifier<FriendDecl> Verifier; |
| 348 | Verifier.expectLocation(2, 8); |
| 349 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 350 | "friend class B;\n" |
| 351 | "};\n", |
| 352 | friendDecl())); |
| 353 | } |
| 354 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 355 | TEST(FriendDecl, FriendElaboratedTypeRange) { |
Stephen Hines | c568f1e | 2014-07-21 00:47:37 -0700 | [diff] [blame] | 356 | RangeVerifier<FriendDecl> Verifier; |
| 357 | Verifier.expectRange(2, 1, 2, 14); |
| 358 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 359 | "friend class B;\n" |
| 360 | "};\n", |
| 361 | friendDecl())); |
| 362 | } |
| 363 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 364 | TEST(FriendDecl, FriendSimpleTypeLocation) { |
| 365 | LocationVerifier<FriendDecl> Verifier; |
| 366 | Verifier.expectLocation(3, 8); |
| 367 | EXPECT_TRUE(Verifier.match("class B;\n" |
| 368 | "struct A {\n" |
| 369 | "friend B;\n" |
| 370 | "};\n", |
| 371 | friendDecl(), Lang_CXX11)); |
| 372 | } |
| 373 | |
| 374 | TEST(FriendDecl, FriendSimpleTypeRange) { |
| 375 | RangeVerifier<FriendDecl> Verifier; |
| 376 | Verifier.expectRange(3, 1, 3, 8); |
| 377 | EXPECT_TRUE(Verifier.match("class B;\n" |
| 378 | "struct A {\n" |
| 379 | "friend B;\n" |
| 380 | "};\n", |
| 381 | friendDecl(), Lang_CXX11)); |
| 382 | } |
| 383 | |
Stephen Hines | c568f1e | 2014-07-21 00:47:37 -0700 | [diff] [blame] | 384 | TEST(FriendDecl, FriendTemplateParameterLocation) { |
| 385 | LocationVerifier<FriendDecl> Verifier; |
| 386 | Verifier.expectLocation(3, 8); |
| 387 | EXPECT_TRUE(Verifier.match("template <typename T>\n" |
| 388 | "struct A {\n" |
| 389 | "friend T;\n" |
| 390 | "};\n", |
| 391 | friendDecl(), Lang_CXX11)); |
| 392 | } |
| 393 | |
| 394 | TEST(FriendDecl, FriendTemplateParameterRange) { |
| 395 | RangeVerifier<FriendDecl> Verifier; |
| 396 | Verifier.expectRange(3, 1, 3, 8); |
| 397 | EXPECT_TRUE(Verifier.match("template <typename T>\n" |
| 398 | "struct A {\n" |
| 399 | "friend T;\n" |
| 400 | "};\n", |
| 401 | friendDecl(), Lang_CXX11)); |
| 402 | } |
| 403 | |
| 404 | TEST(FriendDecl, FriendDecltypeLocation) { |
| 405 | LocationVerifier<FriendDecl> Verifier; |
| 406 | Verifier.expectLocation(4, 8); |
| 407 | EXPECT_TRUE(Verifier.match("struct A;\n" |
| 408 | "A foo();\n" |
| 409 | "struct A {\n" |
| 410 | "friend decltype(foo());\n" |
| 411 | "};\n", |
| 412 | friendDecl(), Lang_CXX11)); |
| 413 | } |
| 414 | |
| 415 | TEST(FriendDecl, FriendDecltypeRange) { |
| 416 | RangeVerifier<FriendDecl> Verifier; |
| 417 | Verifier.expectRange(4, 1, 4, 8); |
| 418 | EXPECT_TRUE(Verifier.match("struct A;\n" |
| 419 | "A foo();\n" |
| 420 | "struct A {\n" |
| 421 | "friend decltype(foo());\n" |
| 422 | "};\n", |
| 423 | friendDecl(), Lang_CXX11)); |
| 424 | } |
| 425 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 426 | TEST(FriendDecl, FriendConstructorDestructorLocation) { |
| 427 | const std::string Code = "struct B {\n" |
| 428 | "B();\n" |
| 429 | "~B();\n" |
| 430 | "};\n" |
| 431 | "struct A {\n" |
| 432 | "friend B::B(), B::~B();\n" |
| 433 | "};\n"; |
| 434 | LocationVerifier<FriendDecl> ConstructorVerifier; |
| 435 | ConstructorVerifier.expectLocation(6, 11); |
| 436 | EXPECT_TRUE(ConstructorVerifier.match( |
| 437 | Code, friendDecl(has(constructorDecl(ofClass(hasName("B"))))))); |
| 438 | LocationVerifier<FriendDecl> DestructorVerifier; |
| 439 | DestructorVerifier.expectLocation(6, 19); |
| 440 | EXPECT_TRUE(DestructorVerifier.match( |
| 441 | Code, friendDecl(has(destructorDecl(ofClass(hasName("B"))))))); |
| 442 | } |
| 443 | |
| 444 | TEST(FriendDecl, FriendConstructorDestructorRange) { |
| 445 | const std::string Code = "struct B {\n" |
| 446 | "B();\n" |
| 447 | "~B();\n" |
| 448 | "};\n" |
| 449 | "struct A {\n" |
| 450 | "friend B::B(), B::~B();\n" |
| 451 | "};\n"; |
| 452 | RangeVerifier<FriendDecl> ConstructorVerifier; |
| 453 | ConstructorVerifier.expectRange(6, 1, 6, 13); |
| 454 | EXPECT_TRUE(ConstructorVerifier.match( |
| 455 | Code, friendDecl(has(constructorDecl(ofClass(hasName("B"))))))); |
| 456 | RangeVerifier<FriendDecl> DestructorVerifier; |
| 457 | DestructorVerifier.expectRange(6, 1, 6, 22); |
| 458 | EXPECT_TRUE(DestructorVerifier.match( |
| 459 | Code, friendDecl(has(destructorDecl(ofClass(hasName("B"))))))); |
| 460 | } |
| 461 | |
| 462 | TEST(FriendDecl, FriendTemplateFunctionLocation) { |
| 463 | LocationVerifier<FriendDecl> Verifier; |
| 464 | Verifier.expectLocation(3, 13); |
| 465 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 466 | "template <typename T>\n" |
| 467 | "friend void f();\n" |
| 468 | "};\n", |
| 469 | friendDecl())); |
| 470 | } |
| 471 | |
| 472 | TEST(FriendDecl, FriendTemplateFunctionRange) { |
| 473 | RangeVerifier<FriendDecl> Verifier; |
| 474 | Verifier.expectRange(2, 1, 3, 15); |
| 475 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 476 | "template <typename T>\n" |
| 477 | "friend void f();\n" |
| 478 | "};\n", |
| 479 | friendDecl())); |
| 480 | } |
| 481 | |
| 482 | TEST(FriendDecl, FriendTemplateClassLocation) { |
| 483 | LocationVerifier<FriendDecl> Verifier; |
| 484 | Verifier.expectLocation(3, 14); |
| 485 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 486 | "template <typename T>\n" |
| 487 | "friend class B;\n" |
| 488 | "};\n", |
| 489 | friendDecl())); |
| 490 | } |
| 491 | |
| 492 | TEST(FriendDecl, FriendTemplateClassRange) { |
| 493 | RangeVerifier<FriendDecl> Verifier; |
| 494 | Verifier.expectRange(2, 1, 3, 14); |
| 495 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 496 | "template <typename T>\n" |
| 497 | "friend class B;\n" |
| 498 | "};\n", |
| 499 | friendDecl())); |
| 500 | } |
| 501 | |
| 502 | TEST(FriendDecl, FriendInlineFunctionLocation) { |
| 503 | LocationVerifier<FriendDecl> Verifier; |
| 504 | Verifier.expectLocation(2, 19); |
| 505 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 506 | "int inline friend f() { return 0; }" |
| 507 | "};\n", |
| 508 | friendDecl())); |
| 509 | } |
| 510 | |
| 511 | TEST(FriendDecl, FriendInlineFunctionRange) { |
| 512 | RangeVerifier<FriendDecl> Verifier; |
| 513 | Verifier.expectRange(2, 1, 2, 35); |
| 514 | EXPECT_TRUE(Verifier.match("struct A {\n" |
| 515 | "int inline friend f() { return 0; }" |
| 516 | "};\n", |
| 517 | friendDecl(), Lang_CXX11)); |
| 518 | } |
| 519 | |
Enea Zaffanella | de9ed71 | 2013-07-19 18:02:36 +0000 | [diff] [blame] | 520 | TEST(FriendDecl, InstantiationSourceRange) { |
| 521 | RangeVerifier<FriendDecl> Verifier; |
| 522 | Verifier.expectRange(4, 3, 4, 35); |
| 523 | EXPECT_TRUE(Verifier.match( |
| 524 | "template <typename T> class S;\n" |
| 525 | "template<class T> void operator+(S<T> x);\n" |
| 526 | "template<class T> struct S {\n" |
| 527 | " friend void operator+<>(S<T> src);\n" |
| 528 | "};\n" |
| 529 | "void test(S<double> s) { +s; }", |
| 530 | friendDecl(hasParent(recordDecl(isTemplateInstantiation()))))); |
| 531 | } |
| 532 | |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 533 | TEST(ObjCMessageExpr, CXXConstructExprRange) { |
| 534 | RangeVerifier<CXXConstructExpr> Verifier; |
| 535 | Verifier.expectRange(5, 25, 5, 27); |
| 536 | EXPECT_TRUE(Verifier.match( |
| 537 | "struct A { int a; };\n" |
| 538 | "@interface B {}\n" |
| 539 | "+ (void) f1: (A)arg;\n" |
| 540 | "@end\n" |
| 541 | "void f2() { A a; [B f1: (a)]; }\n", |
| 542 | constructExpr(), Lang_OBJCXX)); |
| 543 | } |
| 544 | |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 545 | } // end namespace ast_matchers |
| 546 | } // end namespace clang |