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" |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 20 | #include "clang/ASTMatchers/ASTMatchFinder.h" |
Chandler Carruth | 1050e8b | 2012-12-04 09:45:34 +0000 | [diff] [blame] | 21 | #include "clang/ASTMatchers/ASTMatchers.h" |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 22 | #include "clang/Tooling/Tooling.h" |
| 23 | #include "gtest/gtest.h" |
Manuel Klimek | 4d0e9f5 | 2013-01-31 13:10:40 +0000 | [diff] [blame] | 24 | #include "MatchVerifier.h" |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 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: |
| 63 | virtual SourceRange getRange(const LabelStmt &Node) { |
| 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; }", |
| 109 | memberExpr())); |
| 110 | } |
| 111 | |
Abramo Bagnara | 4c5750e | 2012-11-08 14:44:42 +0000 | [diff] [blame] | 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 | |
| 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 | |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 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 | |
| 133 | TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) { |
| 134 | RangeVerifier<CompoundLiteralExpr> Verifier; |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 135 | Verifier.expectRange(2, 20, 2, 31); |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 136 | EXPECT_TRUE(Verifier.match( |
| 137 | "typedef int int2 __attribute__((ext_vector_type(2)));\n" |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 138 | "constant int2 i2 = (int2)(1, 2);", |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 139 | compoundLiteralExpr(), Lang_OpenCL)); |
| 140 | } |
| 141 | |
| 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 | |
| 150 | TEST(InitListExpr, VectorLiteralInitListParens) { |
| 151 | RangeVerifier<InitListExpr> Verifier; |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 152 | Verifier.expectRange(2, 26, 2, 31); |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 153 | EXPECT_TRUE(Verifier.match( |
| 154 | "typedef int int2 __attribute__((ext_vector_type(2)));\n" |
Tanya Lattner | 8aa86d1 | 2013-04-05 20:14:50 +0000 | [diff] [blame] | 155 | "constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL)); |
Richard Smith | afbcab8 | 2013-02-05 05:55:57 +0000 | [diff] [blame] | 156 | } |
| 157 | |
Manuel Klimek | 7e6e515 | 2013-06-07 11:27:57 +0000 | [diff] [blame] | 158 | class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> { |
| 159 | protected: |
| 160 | virtual SourceRange getRange(const TypeLoc &Node) { |
| 161 | TemplateSpecializationTypeLoc T = |
Eli Friedman | 44ee0a7 | 2013-06-07 20:31:48 +0000 | [diff] [blame] | 162 | Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>(); |
Manuel Klimek | 7e6e515 | 2013-06-07 11:27:57 +0000 | [diff] [blame] | 163 | assert(!T.isNull()); |
| 164 | return SourceRange(T.getLAngleLoc(), T.getRAngleLoc()); |
| 165 | } |
| 166 | }; |
| 167 | |
| 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 | |
Eli Friedman | 6e40c95 | 2013-06-17 22:35:10 +0000 | [diff] [blame] | 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 | |
Enea Zaffanella | 2d77634 | 2013-07-06 18:54:58 +0000 | [diff] [blame] | 183 | class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> { |
| 184 | protected: |
| 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 | |
| 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 | |
Enea Zaffanella | bd9cbd2 | 2013-07-07 06:41:54 +0000 | [diff] [blame^] | 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 | |
| 214 | TEST(CXXUnresolvedConstructExpr, SourceRange) { |
| 215 | RangeVerifier<CXXUnresolvedConstructExpr> Verifier; |
| 216 | Verifier.expectRange(3, 10, 3, 12); |
| 217 | EXPECT_TRUE(Verifier.match( |
| 218 | "template <typename U>\n" |
| 219 | "U foo() {\n" |
| 220 | " return U{};\n" |
| 221 | "}", |
| 222 | unresolvedConstructExpr(), Lang_CXX11)); |
| 223 | } |
| 224 | |
Manuel Klimek | 975a949 | 2012-11-06 17:31:40 +0000 | [diff] [blame] | 225 | } // end namespace ast_matchers |
| 226 | } // end namespace clang |