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