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 "clang/ASTMatchers/ASTMatchFinder.h" 21 #include "clang/ASTMatchers/ASTMatchers.h" 22 #include "clang/Tooling/Tooling.h" 23 #include "gtest/gtest.h" 24 #include "MatchVerifier.h" 25 26 namespace clang { 27 namespace ast_matchers { 28 29 // FIXME: Pull the *Verifier tests into their own test file. 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 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 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 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 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 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; 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 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; 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: 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 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 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: 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 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(CXXTemporaryObjectExpr, SourceRange) { 215 RangeVerifier<CXXTemporaryObjectExpr> Verifier; 216 Verifier.expectRange(2, 6, 2, 12); 217 EXPECT_TRUE(Verifier.match( 218 "struct A { A(int, int); };\n" 219 "A a( A{0, 0} );", 220 temporaryObjectExpr(), Lang_CXX11)); 221 } 222 223 TEST(CXXUnresolvedConstructExpr, SourceRange) { 224 RangeVerifier<CXXUnresolvedConstructExpr> Verifier; 225 Verifier.expectRange(3, 10, 3, 12); 226 std::vector<std::string> Args; 227 Args.push_back("-fno-delayed-template-parsing"); 228 EXPECT_TRUE(Verifier.match( 229 "template <typename U>\n" 230 "U foo() {\n" 231 " return U{};\n" 232 "}", 233 unresolvedConstructExpr(), Args, Lang_CXX11)); 234 } 235 236 TEST(UsingDecl, SourceRange) { 237 RangeVerifier<UsingDecl> Verifier; 238 Verifier.expectRange(2, 22, 2, 25); 239 EXPECT_TRUE(Verifier.match( 240 "class B { protected: int i; };\n" 241 "class D : public B { B::i; };", 242 usingDecl())); 243 } 244 245 TEST(UnresolvedUsingValueDecl, SourceRange) { 246 RangeVerifier<UnresolvedUsingValueDecl> Verifier; 247 Verifier.expectRange(3, 3, 3, 6); 248 EXPECT_TRUE(Verifier.match( 249 "template <typename B>\n" 250 "class D : public B {\n" 251 " B::i;\n" 252 "};", 253 unresolvedUsingValueDecl())); 254 } 255 256 TEST(FriendDecl, InstantiationSourceRange) { 257 RangeVerifier<FriendDecl> Verifier; 258 Verifier.expectRange(4, 3, 4, 35); 259 EXPECT_TRUE(Verifier.match( 260 "template <typename T> class S;\n" 261 "template<class T> void operator+(S<T> x);\n" 262 "template<class T> struct S {\n" 263 " friend void operator+<>(S<T> src);\n" 264 "};\n" 265 "void test(S<double> s) { +s; }", 266 friendDecl(hasParent(recordDecl(isTemplateInstantiation()))))); 267 } 268 269 } // end namespace ast_matchers 270 } // end namespace clang 271