mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-25 14:28:54 -04:00
a3220ce6a3
Summary: We do not currently track the source locations for exception specifications such that their source range can be queried through the AST. This leads to trying to write more complex code to determine the source range for uses like FixItHints (see D18575 for an example). In addition to use within tools like clang-tidy, I think this information may become more important to track as exception specifications become more integrated into the type system. Patch by Don Hinton. Reviewers: rsmith Subscribers: malcolm.parsons, sbarzowski, alexfh, hintonda, cfe-commits Differential Revision: https://reviews.llvm.org/D20428 llvm-svn: 291771
742 lines
24 KiB
C++
742 lines
24 KiB
C++
//===- unittest/AST/SourceLocationTest.cpp - AST source loc unit tests ----===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains tests for SourceLocation and SourceRange fields
|
|
// in AST nodes.
|
|
//
|
|
// FIXME: In the long-term, when we test more than source locations, we may
|
|
// want to have a unit test file for an AST node (or group of related nodes),
|
|
// rather than a unit test file for source locations for all AST nodes.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "MatchVerifier.h"
|
|
#include "clang/ASTMatchers/ASTMatchFinder.h"
|
|
#include "clang/ASTMatchers/ASTMatchers.h"
|
|
#include "clang/Tooling/Tooling.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
namespace clang {
|
|
namespace ast_matchers {
|
|
|
|
// FIXME: Pull the *Verifier tests into their own test file.
|
|
|
|
TEST(MatchVerifier, ParseError) {
|
|
LocationVerifier<VarDecl> Verifier;
|
|
Verifier.expectLocation(1, 1);
|
|
EXPECT_FALSE(Verifier.match("int i", varDecl()));
|
|
}
|
|
|
|
TEST(MatchVerifier, NoMatch) {
|
|
LocationVerifier<VarDecl> Verifier;
|
|
Verifier.expectLocation(1, 1);
|
|
EXPECT_FALSE(Verifier.match("int i;", recordDecl()));
|
|
}
|
|
|
|
TEST(MatchVerifier, WrongType) {
|
|
LocationVerifier<RecordDecl> Verifier;
|
|
Verifier.expectLocation(1, 1);
|
|
EXPECT_FALSE(Verifier.match("int i;", varDecl()));
|
|
}
|
|
|
|
TEST(LocationVerifier, WrongLocation) {
|
|
LocationVerifier<VarDecl> Verifier;
|
|
Verifier.expectLocation(1, 1);
|
|
EXPECT_FALSE(Verifier.match("int i;", varDecl()));
|
|
}
|
|
|
|
TEST(RangeVerifier, WrongRange) {
|
|
RangeVerifier<VarDecl> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 1);
|
|
EXPECT_FALSE(Verifier.match("int i;", varDecl()));
|
|
}
|
|
|
|
class LabelDeclRangeVerifier : public RangeVerifier<LabelStmt> {
|
|
protected:
|
|
SourceRange getRange(const LabelStmt &Node) override {
|
|
return Node.getDecl()->getSourceRange();
|
|
}
|
|
};
|
|
|
|
TEST(LabelDecl, Range) {
|
|
LabelDeclRangeVerifier Verifier;
|
|
Verifier.expectRange(1, 12, 1, 12);
|
|
EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
|
|
}
|
|
|
|
TEST(LabelStmt, Range) {
|
|
RangeVerifier<LabelStmt> Verifier;
|
|
Verifier.expectRange(1, 12, 1, 15);
|
|
EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
|
|
}
|
|
|
|
TEST(ParmVarDecl, KNRLocation) {
|
|
LocationVerifier<ParmVarDecl> Verifier;
|
|
Verifier.expectLocation(1, 8);
|
|
EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
|
|
}
|
|
|
|
TEST(ParmVarDecl, KNRRange) {
|
|
RangeVerifier<ParmVarDecl> Verifier;
|
|
Verifier.expectRange(1, 8, 1, 8);
|
|
EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
|
|
}
|
|
|
|
TEST(CXXNewExpr, ArrayRange) {
|
|
RangeVerifier<CXXNewExpr> Verifier;
|
|
Verifier.expectRange(1, 12, 1, 22);
|
|
EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", cxxNewExpr()));
|
|
}
|
|
|
|
TEST(CXXNewExpr, ParenRange) {
|
|
RangeVerifier<CXXNewExpr> Verifier;
|
|
Verifier.expectRange(1, 12, 1, 20);
|
|
EXPECT_TRUE(Verifier.match("void f() { new int(); }", cxxNewExpr()));
|
|
}
|
|
|
|
TEST(MemberExpr, ImplicitMemberRange) {
|
|
RangeVerifier<MemberExpr> Verifier;
|
|
Verifier.expectRange(2, 30, 2, 30);
|
|
EXPECT_TRUE(Verifier.match("struct S { operator int() const; };\n"
|
|
"int foo(const S& s) { return s; }",
|
|
memberExpr()));
|
|
}
|
|
|
|
class MemberExprArrowLocVerifier : public RangeVerifier<MemberExpr> {
|
|
protected:
|
|
SourceRange getRange(const MemberExpr &Node) override {
|
|
return Node.getOperatorLoc();
|
|
}
|
|
};
|
|
|
|
TEST(MemberExpr, ArrowRange) {
|
|
MemberExprArrowLocVerifier Verifier;
|
|
Verifier.expectRange(2, 19, 2, 19);
|
|
EXPECT_TRUE(Verifier.match("struct S { int x; };\n"
|
|
"void foo(S *s) { s->x = 0; }",
|
|
memberExpr()));
|
|
}
|
|
|
|
TEST(MemberExpr, MacroArrowRange) {
|
|
MemberExprArrowLocVerifier Verifier;
|
|
Verifier.expectRange(1, 24, 1, 24);
|
|
EXPECT_TRUE(Verifier.match("#define MEMBER(a, b) (a->b)\n"
|
|
"struct S { int x; };\n"
|
|
"void foo(S *s) { MEMBER(s, x) = 0; }",
|
|
memberExpr()));
|
|
}
|
|
|
|
TEST(MemberExpr, ImplicitArrowRange) {
|
|
MemberExprArrowLocVerifier Verifier;
|
|
Verifier.expectRange(0, 0, 0, 0);
|
|
EXPECT_TRUE(Verifier.match("struct S { int x; void Test(); };\n"
|
|
"void S::Test() { x = 1; }",
|
|
memberExpr()));
|
|
}
|
|
|
|
TEST(VarDecl, VMTypeFixedVarDeclRange) {
|
|
RangeVerifier<VarDecl> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 23);
|
|
EXPECT_TRUE(Verifier.match("int a[(int)(void*)1234];",
|
|
varDecl(), Lang_C89));
|
|
}
|
|
|
|
TEST(TypeLoc, IntRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 1);
|
|
EXPECT_TRUE(Verifier.match("int a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 1);
|
|
EXPECT_TRUE(Verifier.match("long a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongDoubleRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 6);
|
|
EXPECT_TRUE(Verifier.match("long double a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, DoubleLongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 8);
|
|
EXPECT_TRUE(Verifier.match("double long a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongIntRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 6);
|
|
EXPECT_TRUE(Verifier.match("long int a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, IntLongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 5);
|
|
EXPECT_TRUE(Verifier.match("int long a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, UnsignedIntRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 10);
|
|
EXPECT_TRUE(Verifier.match("unsigned int a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, IntUnsignedRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 5);
|
|
EXPECT_TRUE(Verifier.match("int unsigned a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongLongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 6);
|
|
EXPECT_TRUE(Verifier.match("long long a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, UnsignedLongLongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 15);
|
|
EXPECT_TRUE(Verifier.match("unsigned long long a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongUnsignedLongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 15);
|
|
EXPECT_TRUE(Verifier.match("long unsigned long a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongLongUnsignedRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 11);
|
|
EXPECT_TRUE(Verifier.match("long long unsigned a;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, ConstLongLongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 7, 1, 12);
|
|
EXPECT_TRUE(Verifier.match("const long long a = 0;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongConstLongRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 12);
|
|
EXPECT_TRUE(Verifier.match("long const long a = 0;", typeLoc()));
|
|
}
|
|
|
|
TEST(TypeLoc, LongLongConstRange) {
|
|
RangeVerifier<TypeLoc> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 6);
|
|
EXPECT_TRUE(Verifier.match("long long const a = 0;", typeLoc()));
|
|
}
|
|
|
|
TEST(CXXConstructorDecl, NoRetFunTypeLocRange) {
|
|
RangeVerifier<CXXConstructorDecl> Verifier;
|
|
Verifier.expectRange(1, 11, 1, 13);
|
|
EXPECT_TRUE(Verifier.match("class C { C(); };", functionDecl()));
|
|
}
|
|
|
|
TEST(CXXConstructorDecl, DefaultedCtorLocRange) {
|
|
RangeVerifier<CXXConstructorDecl> Verifier;
|
|
Verifier.expectRange(1, 11, 1, 23);
|
|
EXPECT_TRUE(Verifier.match("class C { C() = default; };", functionDecl()));
|
|
}
|
|
|
|
TEST(CXXConstructorDecl, DeletedCtorLocRange) {
|
|
RangeVerifier<CXXConstructorDecl> Verifier;
|
|
Verifier.expectRange(1, 11, 1, 22);
|
|
EXPECT_TRUE(Verifier.match("class C { C() = delete; };", functionDecl()));
|
|
}
|
|
|
|
TEST(CompoundLiteralExpr, CompoundVectorLiteralRange) {
|
|
RangeVerifier<CompoundLiteralExpr> Verifier;
|
|
Verifier.expectRange(2, 11, 2, 22);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"typedef int int2 __attribute__((ext_vector_type(2)));\n"
|
|
"int2 i2 = (int2){1, 2};", compoundLiteralExpr()));
|
|
}
|
|
|
|
TEST(CompoundLiteralExpr, ParensCompoundVectorLiteralRange) {
|
|
RangeVerifier<CompoundLiteralExpr> Verifier;
|
|
Verifier.expectRange(2, 20, 2, 31);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"typedef int int2 __attribute__((ext_vector_type(2)));\n"
|
|
"constant int2 i2 = (int2)(1, 2);",
|
|
compoundLiteralExpr(), Lang_OpenCL));
|
|
}
|
|
|
|
TEST(InitListExpr, VectorLiteralListBraceRange) {
|
|
RangeVerifier<InitListExpr> Verifier;
|
|
Verifier.expectRange(2, 17, 2, 22);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"typedef int int2 __attribute__((ext_vector_type(2)));\n"
|
|
"int2 i2 = (int2){1, 2};", initListExpr()));
|
|
}
|
|
|
|
TEST(InitListExpr, VectorLiteralInitListParens) {
|
|
RangeVerifier<InitListExpr> Verifier;
|
|
Verifier.expectRange(2, 26, 2, 31);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"typedef int int2 __attribute__((ext_vector_type(2)));\n"
|
|
"constant int2 i2 = (int2)(1, 2);", initListExpr(), Lang_OpenCL));
|
|
}
|
|
|
|
class TemplateAngleBracketLocRangeVerifier : public RangeVerifier<TypeLoc> {
|
|
protected:
|
|
SourceRange getRange(const TypeLoc &Node) override {
|
|
TemplateSpecializationTypeLoc T =
|
|
Node.getUnqualifiedLoc().castAs<TemplateSpecializationTypeLoc>();
|
|
assert(!T.isNull());
|
|
return SourceRange(T.getLAngleLoc(), T.getRAngleLoc());
|
|
}
|
|
};
|
|
|
|
TEST(TemplateSpecializationTypeLoc, AngleBracketLocations) {
|
|
TemplateAngleBracketLocRangeVerifier Verifier;
|
|
Verifier.expectRange(2, 8, 2, 10);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"template<typename T> struct A {}; struct B{}; void f(\n"
|
|
"const A<B>&);",
|
|
loc(templateSpecializationType())));
|
|
}
|
|
|
|
TEST(CXXNewExpr, TypeParenRange) {
|
|
RangeVerifier<CXXNewExpr> Verifier;
|
|
Verifier.expectRange(1, 10, 1, 18);
|
|
EXPECT_TRUE(Verifier.match("int* a = new (int);", cxxNewExpr()));
|
|
}
|
|
|
|
class UnaryTransformTypeLocParensRangeVerifier : public RangeVerifier<TypeLoc> {
|
|
protected:
|
|
SourceRange getRange(const TypeLoc &Node) override {
|
|
UnaryTransformTypeLoc T =
|
|
Node.getUnqualifiedLoc().castAs<UnaryTransformTypeLoc>();
|
|
assert(!T.isNull());
|
|
return SourceRange(T.getLParenLoc(), T.getRParenLoc());
|
|
}
|
|
};
|
|
|
|
TEST(UnaryTransformTypeLoc, ParensRange) {
|
|
UnaryTransformTypeLocParensRangeVerifier Verifier;
|
|
Verifier.expectRange(3, 26, 3, 28);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"template <typename T>\n"
|
|
"struct S {\n"
|
|
"typedef __underlying_type(T) type;\n"
|
|
"};",
|
|
loc(unaryTransformType())));
|
|
}
|
|
|
|
TEST(CXXFunctionalCastExpr, SourceRange) {
|
|
RangeVerifier<CXXFunctionalCastExpr> Verifier;
|
|
Verifier.expectRange(2, 10, 2, 14);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"int foo() {\n"
|
|
" return int{};\n"
|
|
"}",
|
|
cxxFunctionalCastExpr(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(CXXConstructExpr, SourceRange) {
|
|
RangeVerifier<CXXConstructExpr> Verifier;
|
|
Verifier.expectRange(3, 14, 3, 19);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"struct A { A(int, int); };\n"
|
|
"void f(A a);\n"
|
|
"void g() { f({0, 0}); }",
|
|
cxxConstructExpr(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(CXXTemporaryObjectExpr, SourceRange) {
|
|
RangeVerifier<CXXTemporaryObjectExpr> Verifier;
|
|
Verifier.expectRange(2, 6, 2, 12);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"struct A { A(int, int); };\n"
|
|
"A a( A{0, 0} );",
|
|
cxxTemporaryObjectExpr(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(CXXUnresolvedConstructExpr, SourceRange) {
|
|
RangeVerifier<CXXUnresolvedConstructExpr> Verifier;
|
|
Verifier.expectRange(3, 10, 3, 12);
|
|
std::vector<std::string> Args;
|
|
Args.push_back("-fno-delayed-template-parsing");
|
|
EXPECT_TRUE(Verifier.match(
|
|
"template <typename U>\n"
|
|
"U foo() {\n"
|
|
" return U{};\n"
|
|
"}",
|
|
cxxUnresolvedConstructExpr(), Args, Lang_CXX11));
|
|
}
|
|
|
|
TEST(UsingDecl, SourceRange) {
|
|
RangeVerifier<UsingDecl> Verifier;
|
|
Verifier.expectRange(2, 22, 2, 25);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"class B { protected: int i; };\n"
|
|
"class D : public B { B::i; };",
|
|
usingDecl()));
|
|
}
|
|
|
|
TEST(UnresolvedUsingValueDecl, SourceRange) {
|
|
RangeVerifier<UnresolvedUsingValueDecl> Verifier;
|
|
Verifier.expectRange(3, 3, 3, 6);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"template <typename B>\n"
|
|
"class D : public B {\n"
|
|
" B::i;\n"
|
|
"};",
|
|
unresolvedUsingValueDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendNonMemberFunctionLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(2, 13);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"friend void f();\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendNonMemberFunctionRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 2, 15);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"friend void f();\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendNonMemberFunctionDefinitionLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(2, 12);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"friend int f() { return 0; }\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendNonMemberFunctionDefinitionRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 2, 28);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"friend int f() { return 0; }\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendElaboratedTypeLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(2, 8);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"friend class B;\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendElaboratedTypeRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 2, 14);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"friend class B;\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendSimpleTypeLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(3, 8);
|
|
EXPECT_TRUE(Verifier.match("class B;\n"
|
|
"struct A {\n"
|
|
"friend B;\n"
|
|
"};\n",
|
|
friendDecl(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendSimpleTypeRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(3, 1, 3, 8);
|
|
EXPECT_TRUE(Verifier.match("class B;\n"
|
|
"struct A {\n"
|
|
"friend B;\n"
|
|
"};\n",
|
|
friendDecl(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendTemplateParameterLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(3, 8);
|
|
EXPECT_TRUE(Verifier.match("template <typename T>\n"
|
|
"struct A {\n"
|
|
"friend T;\n"
|
|
"};\n",
|
|
friendDecl(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendTemplateParameterRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(3, 1, 3, 8);
|
|
EXPECT_TRUE(Verifier.match("template <typename T>\n"
|
|
"struct A {\n"
|
|
"friend T;\n"
|
|
"};\n",
|
|
friendDecl(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendDecltypeLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(4, 8);
|
|
EXPECT_TRUE(Verifier.match("struct A;\n"
|
|
"A foo();\n"
|
|
"struct A {\n"
|
|
"friend decltype(foo());\n"
|
|
"};\n",
|
|
friendDecl(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendDecltypeRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(4, 1, 4, 8);
|
|
EXPECT_TRUE(Verifier.match("struct A;\n"
|
|
"A foo();\n"
|
|
"struct A {\n"
|
|
"friend decltype(foo());\n"
|
|
"};\n",
|
|
friendDecl(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendConstructorDestructorLocation) {
|
|
const std::string Code = "struct B {\n"
|
|
"B();\n"
|
|
"~B();\n"
|
|
"};\n"
|
|
"struct A {\n"
|
|
"friend B::B(), B::~B();\n"
|
|
"};\n";
|
|
LocationVerifier<FriendDecl> ConstructorVerifier;
|
|
ConstructorVerifier.expectLocation(6, 11);
|
|
EXPECT_TRUE(ConstructorVerifier.match(
|
|
Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
|
|
LocationVerifier<FriendDecl> DestructorVerifier;
|
|
DestructorVerifier.expectLocation(6, 19);
|
|
EXPECT_TRUE(DestructorVerifier.match(
|
|
Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendConstructorDestructorRange) {
|
|
const std::string Code = "struct B {\n"
|
|
"B();\n"
|
|
"~B();\n"
|
|
"};\n"
|
|
"struct A {\n"
|
|
"friend B::B(), B::~B();\n"
|
|
"};\n";
|
|
RangeVerifier<FriendDecl> ConstructorVerifier;
|
|
ConstructorVerifier.expectRange(6, 1, 6, 13);
|
|
EXPECT_TRUE(ConstructorVerifier.match(
|
|
Code, friendDecl(has(cxxConstructorDecl(ofClass(hasName("B")))))));
|
|
RangeVerifier<FriendDecl> DestructorVerifier;
|
|
DestructorVerifier.expectRange(6, 1, 6, 22);
|
|
EXPECT_TRUE(DestructorVerifier.match(
|
|
Code, friendDecl(has(cxxDestructorDecl(ofClass(hasName("B")))))));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendTemplateFunctionLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(3, 13);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"template <typename T>\n"
|
|
"friend void f();\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendTemplateFunctionRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 3, 15);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"template <typename T>\n"
|
|
"friend void f();\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendTemplateClassLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(3, 14);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"template <typename T>\n"
|
|
"friend class B;\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendTemplateClassRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 3, 14);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"template <typename T>\n"
|
|
"friend class B;\n"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendInlineFunctionLocation) {
|
|
LocationVerifier<FriendDecl> Verifier;
|
|
Verifier.expectLocation(2, 19);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"int inline friend f() { return 0; }"
|
|
"};\n",
|
|
friendDecl()));
|
|
}
|
|
|
|
TEST(FriendDecl, FriendInlineFunctionRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 2, 35);
|
|
EXPECT_TRUE(Verifier.match("struct A {\n"
|
|
"int inline friend f() { return 0; }"
|
|
"};\n",
|
|
friendDecl(), Lang_CXX11));
|
|
}
|
|
|
|
TEST(FriendDecl, InstantiationSourceRange) {
|
|
RangeVerifier<FriendDecl> Verifier;
|
|
Verifier.expectRange(4, 3, 4, 35);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"template <typename T> class S;\n"
|
|
"template<class T> void operator+(S<T> x);\n"
|
|
"template<class T> struct S {\n"
|
|
" friend void operator+<>(S<T> src);\n"
|
|
"};\n"
|
|
"void test(S<double> s) { +s; }",
|
|
friendDecl(hasParent(cxxRecordDecl(isTemplateInstantiation())))));
|
|
}
|
|
|
|
TEST(ObjCMessageExpr, CXXConstructExprRange) {
|
|
RangeVerifier<CXXConstructExpr> Verifier;
|
|
Verifier.expectRange(5, 25, 5, 27);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"struct A { int a; };\n"
|
|
"@interface B {}\n"
|
|
"+ (void) f1: (A)arg;\n"
|
|
"@end\n"
|
|
"void f2() { A a; [B f1: (a)]; }\n",
|
|
cxxConstructExpr(), Lang_OBJCXX));
|
|
}
|
|
|
|
TEST(FunctionDecl, FunctionDeclWithThrowSpecification) {
|
|
RangeVerifier<FunctionDecl> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 16);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"void f() throw();\n",
|
|
functionDecl()));
|
|
}
|
|
|
|
TEST(FunctionDecl, FunctionDeclWithNoExceptSpecification) {
|
|
RangeVerifier<FunctionDecl> Verifier;
|
|
Verifier.expectRange(1, 1, 1, 24);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"void f() noexcept(false);\n",
|
|
functionDecl(),
|
|
Language::Lang_CXX11));
|
|
}
|
|
|
|
TEST(CXXMethodDecl, CXXMethodDeclWithThrowSpecification) {
|
|
RangeVerifier<FunctionDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 2, 16);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"class A {\n"
|
|
"void f() throw();\n"
|
|
"};\n",
|
|
functionDecl()));
|
|
}
|
|
|
|
TEST(CXXMethodDecl, CXXMethodDeclWithNoExceptSpecification) {
|
|
RangeVerifier<FunctionDecl> Verifier;
|
|
Verifier.expectRange(2, 1, 2, 24);
|
|
EXPECT_TRUE(Verifier.match(
|
|
"class A {\n"
|
|
"void f() noexcept(false);\n"
|
|
"};\n",
|
|
functionDecl(),
|
|
Language::Lang_CXX11));
|
|
}
|
|
|
|
class ExceptionSpecRangeVerifier : public RangeVerifier<TypeLoc> {
|
|
protected:
|
|
SourceRange getRange(const TypeLoc &Node) override {
|
|
auto T =
|
|
Node.getUnqualifiedLoc().castAs<FunctionProtoTypeLoc>();
|
|
assert(!T.isNull());
|
|
return T.getExceptionSpecRange();
|
|
}
|
|
};
|
|
|
|
class ParmVarExceptionSpecRangeVerifier : public RangeVerifier<ParmVarDecl> {
|
|
protected:
|
|
SourceRange getRange(const ParmVarDecl &Node) override {
|
|
if (const TypeSourceInfo *TSI = Node.getTypeSourceInfo()) {
|
|
TypeLoc TL = TSI->getTypeLoc();
|
|
if (TL.getType()->isPointerType()) {
|
|
TL = TL.getNextTypeLoc().IgnoreParens();
|
|
if (auto FPTL = TL.getAs<FunctionProtoTypeLoc>()) {
|
|
return FPTL.getExceptionSpecRange();
|
|
}
|
|
}
|
|
}
|
|
return SourceRange();
|
|
}
|
|
};
|
|
|
|
TEST(FunctionDecl, ExceptionSpecifications) {
|
|
ExceptionSpecRangeVerifier Verifier;
|
|
|
|
Verifier.expectRange(1, 10, 1, 16);
|
|
EXPECT_TRUE(Verifier.match("void f() throw();\n", loc(functionType())));
|
|
|
|
Verifier.expectRange(1, 10, 1, 34);
|
|
EXPECT_TRUE(Verifier.match("void f() throw(void(void) throw());\n",
|
|
loc(functionType())));
|
|
|
|
Verifier.expectRange(1, 10, 1, 19);
|
|
std::vector<std::string> Args;
|
|
Args.push_back("-fms-extensions");
|
|
EXPECT_TRUE(Verifier.match("void f() throw(...);\n", loc(functionType()),
|
|
Args, Language::Lang_CXX));
|
|
|
|
Verifier.expectRange(1, 10, 1, 10);
|
|
EXPECT_TRUE(Verifier.match("void f() noexcept;\n", loc(functionType()),
|
|
Language::Lang_CXX11));
|
|
|
|
Verifier.expectRange(1, 10, 1, 24);
|
|
EXPECT_TRUE(Verifier.match("void f() noexcept(false);\n", loc(functionType()),
|
|
Language::Lang_CXX11));
|
|
|
|
Verifier.expectRange(1, 10, 1, 32);
|
|
EXPECT_TRUE(Verifier.match("void f() noexcept(noexcept(1+1));\n",
|
|
loc(functionType()), Language::Lang_CXX11));
|
|
|
|
ParmVarExceptionSpecRangeVerifier Verifier2;
|
|
Verifier2.expectRange(1, 25, 1, 31);
|
|
EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) throw());\n",
|
|
parmVarDecl(hasType(pointerType(pointee(
|
|
parenType(innerType(functionType()))))))));
|
|
|
|
Verifier2.expectRange(1, 25, 1, 38);
|
|
EXPECT_TRUE(Verifier2.match("void g(void (*fp)(void) noexcept(true));\n",
|
|
parmVarDecl(hasType(pointerType(pointee(
|
|
parenType(innerType(functionType())))))),
|
|
Language::Lang_CXX11));
|
|
}
|
|
|
|
} // end namespace ast_matchers
|
|
} // end namespace clang
|