580 lines
18 KiB
C++
580 lines
18 KiB
C++
//===- unittest/Tooling/RecursiveASTVisitorTest.cpp -----------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "TestVisitor.h"
|
|
|
|
#include <stack>
|
|
|
|
namespace clang {
|
|
|
|
class TypeLocVisitor : public ExpectedLocationVisitor<TypeLocVisitor> {
|
|
public:
|
|
bool VisitTypeLoc(TypeLoc TypeLocation) {
|
|
Match(TypeLocation.getType().getAsString(), TypeLocation.getBeginLoc());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class DeclRefExprVisitor : public ExpectedLocationVisitor<DeclRefExprVisitor> {
|
|
public:
|
|
bool VisitDeclRefExpr(DeclRefExpr *Reference) {
|
|
Match(Reference->getNameInfo().getAsString(), Reference->getLocation());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class VarDeclVisitor : public ExpectedLocationVisitor<VarDeclVisitor> {
|
|
public:
|
|
bool VisitVarDecl(VarDecl *Variable) {
|
|
Match(Variable->getNameAsString(), Variable->getLocStart());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class ParmVarDeclVisitorForImplicitCode :
|
|
public ExpectedLocationVisitor<ParmVarDeclVisitorForImplicitCode> {
|
|
public:
|
|
bool shouldVisitImplicitCode() const { return true; }
|
|
|
|
bool VisitParmVarDecl(ParmVarDecl *ParamVar) {
|
|
Match(ParamVar->getNameAsString(), ParamVar->getLocStart());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class CXXMemberCallVisitor
|
|
: public ExpectedLocationVisitor<CXXMemberCallVisitor> {
|
|
public:
|
|
bool VisitCXXMemberCallExpr(CXXMemberCallExpr *Call) {
|
|
Match(Call->getMethodDecl()->getQualifiedNameAsString(),
|
|
Call->getLocStart());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class NamedDeclVisitor
|
|
: public ExpectedLocationVisitor<NamedDeclVisitor> {
|
|
public:
|
|
bool VisitNamedDecl(NamedDecl *Decl) {
|
|
std::string NameWithTemplateArgs;
|
|
llvm::raw_string_ostream OS(NameWithTemplateArgs);
|
|
Decl->getNameForDiagnostic(OS,
|
|
Decl->getASTContext().getPrintingPolicy(),
|
|
true);
|
|
Match(OS.str(), Decl->getLocation());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class CXXOperatorCallExprTraverser
|
|
: public ExpectedLocationVisitor<CXXOperatorCallExprTraverser> {
|
|
public:
|
|
// Use Traverse, not Visit, to check that data recursion optimization isn't
|
|
// bypassing the call of this function.
|
|
bool TraverseCXXOperatorCallExpr(CXXOperatorCallExpr *CE) {
|
|
Match(getOperatorSpelling(CE->getOperator()), CE->getExprLoc());
|
|
return ExpectedLocationVisitor<CXXOperatorCallExprTraverser>::
|
|
TraverseCXXOperatorCallExpr(CE);
|
|
}
|
|
};
|
|
|
|
class ParenExprVisitor : public ExpectedLocationVisitor<ParenExprVisitor> {
|
|
public:
|
|
bool VisitParenExpr(ParenExpr *Parens) {
|
|
Match("", Parens->getExprLoc());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class LambdaExprVisitor : public ExpectedLocationVisitor<LambdaExprVisitor> {
|
|
public:
|
|
bool VisitLambdaExpr(LambdaExpr *Lambda) {
|
|
PendingBodies.push(Lambda);
|
|
Match("", Lambda->getIntroducerRange().getBegin());
|
|
return true;
|
|
}
|
|
/// For each call to VisitLambdaExpr, we expect a subsequent call (with
|
|
/// proper nesting) to TraverseLambdaBody.
|
|
bool TraverseLambdaBody(LambdaExpr *Lambda) {
|
|
EXPECT_FALSE(PendingBodies.empty());
|
|
EXPECT_EQ(PendingBodies.top(), Lambda);
|
|
PendingBodies.pop();
|
|
return TraverseStmt(Lambda->getBody());
|
|
}
|
|
/// Determine whether TraverseLambdaBody has been called for every call to
|
|
/// VisitLambdaExpr.
|
|
bool allBodiesHaveBeenTraversed() const {
|
|
return PendingBodies.empty();
|
|
}
|
|
private:
|
|
std::stack<LambdaExpr *> PendingBodies;
|
|
};
|
|
|
|
// Matches the (optional) capture-default of a lambda-introducer.
|
|
class LambdaDefaultCaptureVisitor
|
|
: public ExpectedLocationVisitor<LambdaDefaultCaptureVisitor> {
|
|
public:
|
|
bool VisitLambdaExpr(LambdaExpr *Lambda) {
|
|
if (Lambda->getCaptureDefault() != LCD_None) {
|
|
Match("", Lambda->getCaptureDefaultLoc());
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
class TemplateArgumentLocTraverser
|
|
: public ExpectedLocationVisitor<TemplateArgumentLocTraverser> {
|
|
public:
|
|
bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
|
|
std::string ArgStr;
|
|
llvm::raw_string_ostream Stream(ArgStr);
|
|
const TemplateArgument &Arg = ArgLoc.getArgument();
|
|
|
|
Arg.print(Context->getPrintingPolicy(), Stream);
|
|
Match(Stream.str(), ArgLoc.getLocation());
|
|
return ExpectedLocationVisitor<TemplateArgumentLocTraverser>::
|
|
TraverseTemplateArgumentLoc(ArgLoc);
|
|
}
|
|
};
|
|
|
|
class CXXBoolLiteralExprVisitor
|
|
: public ExpectedLocationVisitor<CXXBoolLiteralExprVisitor> {
|
|
public:
|
|
bool VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *BE) {
|
|
if (BE->getValue())
|
|
Match("true", BE->getLocation());
|
|
else
|
|
Match("false", BE->getLocation());
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Test RAV visits parameter variable declaration of the implicit
|
|
// copy assignment operator and implicit copy constructor.
|
|
TEST(RecursiveASTVisitor, VisitsParmVarDeclForImplicitCode) {
|
|
ParmVarDeclVisitorForImplicitCode Visitor;
|
|
// Match parameter variable name of implicit copy assignment operator and
|
|
// implicit copy constructor.
|
|
// This parameter name does not have a valid IdentifierInfo, and shares
|
|
// same SourceLocation with its class declaration, so we match an empty name
|
|
// with the class' source location.
|
|
Visitor.ExpectMatch("", 1, 7);
|
|
Visitor.ExpectMatch("", 3, 7);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"class X {};\n"
|
|
"void foo(X a, X b) {a = b;}\n"
|
|
"class Y {};\n"
|
|
"void bar(Y a) {Y b = a;}"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsBaseClassDeclarations) {
|
|
TypeLocVisitor Visitor;
|
|
Visitor.ExpectMatch("class X", 1, 30);
|
|
EXPECT_TRUE(Visitor.runOver("class X {}; class Y : public X {};"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCXXBaseSpecifiersOfForwardDeclaredClass) {
|
|
TypeLocVisitor Visitor;
|
|
Visitor.ExpectMatch("class X", 3, 18);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"class Y;\n"
|
|
"class X {};\n"
|
|
"class Y : public X {};"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCXXBaseSpecifiersWithIncompleteInnerClass) {
|
|
TypeLocVisitor Visitor;
|
|
Visitor.ExpectMatch("class X", 2, 18);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"class X {};\n"
|
|
"class Y : public X { class Z; };"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCXXBaseSpecifiersOfSelfReferentialType) {
|
|
TypeLocVisitor Visitor;
|
|
Visitor.ExpectMatch("X<class Y>", 2, 18);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<typename T> class X {};\n"
|
|
"class Y : public X<Y> {};"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsBaseClassTemplateArguments) {
|
|
DeclRefExprVisitor Visitor;
|
|
Visitor.ExpectMatch("x", 2, 3);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"void x(); template <void (*T)()> class X {};\nX<x> y;"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCXXForRangeStmtRange) {
|
|
DeclRefExprVisitor Visitor;
|
|
Visitor.ExpectMatch("x", 2, 25);
|
|
Visitor.ExpectMatch("x", 2, 30);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"int x[5];\n"
|
|
"void f() { for (int i : x) { x[0] = 1; } }",
|
|
DeclRefExprVisitor::Lang_CXX11));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCXXForRangeStmtLoopVariable) {
|
|
VarDeclVisitor Visitor;
|
|
Visitor.ExpectMatch("i", 2, 17);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"int x[5];\n"
|
|
"void f() { for (int i : x) {} }",
|
|
VarDeclVisitor::Lang_CXX11));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCallExpr) {
|
|
DeclRefExprVisitor Visitor;
|
|
Visitor.ExpectMatch("x", 1, 22);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"void x(); void y() { x(); }"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCallInTemplateInstantiation) {
|
|
CXXMemberCallVisitor Visitor;
|
|
Visitor.ExpectMatch("Y::x", 3, 3);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"struct Y { void x(); };\n"
|
|
"template<typename T> void y(T t) {\n"
|
|
" t.x();\n"
|
|
"}\n"
|
|
"void foo() { y<Y>(Y()); }"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCallInNestedFunctionTemplateInstantiation) {
|
|
CXXMemberCallVisitor Visitor;
|
|
Visitor.ExpectMatch("Y::x", 4, 5);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"struct Y { void x(); };\n"
|
|
"template<typename T> struct Z {\n"
|
|
" template<typename U> static void f() {\n"
|
|
" T().x();\n"
|
|
" }\n"
|
|
"};\n"
|
|
"void foo() { Z<Y>::f<int>(); }"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCallInNestedClassTemplateInstantiation) {
|
|
CXXMemberCallVisitor Visitor;
|
|
Visitor.ExpectMatch("A::x", 5, 7);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template <typename T1> struct X {\n"
|
|
" template <typename T2> struct Y {\n"
|
|
" void f() {\n"
|
|
" T2 y;\n"
|
|
" y.x();\n"
|
|
" }\n"
|
|
" };\n"
|
|
"};\n"
|
|
"struct A { void x(); };\n"
|
|
"int main() {\n"
|
|
" (new X<A>::Y<A>())->f();\n"
|
|
"}"));
|
|
}
|
|
|
|
/* FIXME: According to Richard Smith this is a bug in the AST.
|
|
TEST(RecursiveASTVisitor, VisitsBaseClassTemplateArgumentsInInstantiation) {
|
|
DeclRefExprVisitor Visitor;
|
|
Visitor.ExpectMatch("x", 3, 43);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template <typename T> void x();\n"
|
|
"template <void (*T)()> class X {};\n"
|
|
"template <typename T> class Y : public X< x<T> > {};\n"
|
|
"Y<int> y;"));
|
|
}
|
|
*/
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCallInPartialTemplateSpecialization) {
|
|
CXXMemberCallVisitor Visitor;
|
|
Visitor.ExpectMatch("A::x", 6, 20);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template <typename T1> struct X {\n"
|
|
" template <typename T2, bool B> struct Y { void g(); };\n"
|
|
"};\n"
|
|
"template <typename T1> template <typename T2>\n"
|
|
"struct X<T1>::Y<T2, true> {\n"
|
|
" void f() { T2 y; y.x(); }\n"
|
|
"};\n"
|
|
"struct A { void x(); };\n"
|
|
"int main() {\n"
|
|
" (new X<A>::Y<A, true>())->f();\n"
|
|
"}\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsExplicitTemplateSpecialization) {
|
|
CXXMemberCallVisitor Visitor;
|
|
Visitor.ExpectMatch("A::f", 4, 5);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"struct A {\n"
|
|
" void f() const {}\n"
|
|
" template<class T> void g(const T& t) const {\n"
|
|
" t.f();\n"
|
|
" }\n"
|
|
"};\n"
|
|
"template void A::g(const A& a) const;\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsPartialTemplateSpecialization) {
|
|
// From cfe-commits/Week-of-Mon-20100830/033998.html
|
|
// Contrary to the approach suggested in that email, we visit all
|
|
// specializations when we visit the primary template. Visiting them when we
|
|
// visit the associated specialization is problematic for specializations of
|
|
// template members of class templates.
|
|
NamedDeclVisitor Visitor;
|
|
Visitor.ExpectMatch("A<bool>", 1, 26);
|
|
Visitor.ExpectMatch("A<char *>", 2, 26);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template <class T> class A {};\n"
|
|
"template <class T> class A<T*> {};\n"
|
|
"A<bool> ab;\n"
|
|
"A<char*> acp;\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsUndefinedClassTemplateSpecialization) {
|
|
NamedDeclVisitor Visitor;
|
|
Visitor.ExpectMatch("A<int>", 1, 29);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<typename T> struct A;\n"
|
|
"A<int> *p;\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsNestedUndefinedClassTemplateSpecialization) {
|
|
NamedDeclVisitor Visitor;
|
|
Visitor.ExpectMatch("A<int>::B<char>", 2, 31);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<typename T> struct A {\n"
|
|
" template<typename U> struct B;\n"
|
|
"};\n"
|
|
"A<int>::B<char> *p;\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsUndefinedFunctionTemplateSpecialization) {
|
|
NamedDeclVisitor Visitor;
|
|
Visitor.ExpectMatch("A<int>", 1, 26);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<typename T> int A();\n"
|
|
"int k = A<int>();\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsNestedUndefinedFunctionTemplateSpecialization) {
|
|
NamedDeclVisitor Visitor;
|
|
Visitor.ExpectMatch("A<int>::B<char>", 2, 35);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<typename T> struct A {\n"
|
|
" template<typename U> static int B();\n"
|
|
"};\n"
|
|
"int k = A<int>::B<char>();\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, NoRecursionInSelfFriend) {
|
|
// From cfe-commits/Week-of-Mon-20100830/033977.html
|
|
NamedDeclVisitor Visitor;
|
|
Visitor.ExpectMatch("vector_iterator<int>", 2, 7);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<typename Container>\n"
|
|
"class vector_iterator {\n"
|
|
" template <typename C> friend class vector_iterator;\n"
|
|
"};\n"
|
|
"vector_iterator<int> it_int;\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, TraversesOverloadedOperator) {
|
|
CXXOperatorCallExprTraverser Visitor;
|
|
Visitor.ExpectMatch("()", 4, 9);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"struct A {\n"
|
|
" int operator()();\n"
|
|
"} a;\n"
|
|
"int k = a();\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsParensDuringDataRecursion) {
|
|
ParenExprVisitor Visitor;
|
|
Visitor.ExpectMatch("", 1, 9);
|
|
EXPECT_TRUE(Visitor.runOver("int k = (4) + 9;\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsClassTemplateNonTypeParmDefaultArgument) {
|
|
CXXBoolLiteralExprVisitor Visitor;
|
|
Visitor.ExpectMatch("true", 2, 19);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<bool B> class X;\n"
|
|
"template<bool B = true> class Y;\n"
|
|
"template<bool B> class Y {};\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsClassTemplateTypeParmDefaultArgument) {
|
|
TypeLocVisitor Visitor;
|
|
Visitor.ExpectMatch("class X", 2, 23);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"class X;\n"
|
|
"template<typename T = X> class Y;\n"
|
|
"template<typename T> class Y {};\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsClassTemplateTemplateParmDefaultArgument) {
|
|
TemplateArgumentLocTraverser Visitor;
|
|
Visitor.ExpectMatch("X", 2, 40);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"template<typename T> class X;\n"
|
|
"template<template <typename> class T = X> class Y;\n"
|
|
"template<template <typename> class T> class Y {};\n"));
|
|
}
|
|
|
|
// A visitor that visits implicit declarations and matches constructors.
|
|
class ImplicitCtorVisitor
|
|
: public ExpectedLocationVisitor<ImplicitCtorVisitor> {
|
|
public:
|
|
bool shouldVisitImplicitCode() const { return true; }
|
|
|
|
bool VisitCXXConstructorDecl(CXXConstructorDecl* Ctor) {
|
|
if (Ctor->isImplicit()) { // Was not written in source code
|
|
if (const CXXRecordDecl* Class = Ctor->getParent()) {
|
|
Match(Class->getName(), Ctor->getLocation());
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
TEST(RecursiveASTVisitor, VisitsImplicitCopyConstructors) {
|
|
ImplicitCtorVisitor Visitor;
|
|
Visitor.ExpectMatch("Simple", 2, 8);
|
|
// Note: Clang lazily instantiates implicit declarations, so we need
|
|
// to use them in order to force them to appear in the AST.
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"struct WithCtor { WithCtor(); }; \n"
|
|
"struct Simple { Simple(); WithCtor w; }; \n"
|
|
"int main() { Simple s; Simple t(s); }\n"));
|
|
}
|
|
|
|
/// \brief A visitor that optionally includes implicit code and matches
|
|
/// CXXConstructExpr.
|
|
///
|
|
/// The name recorded for the match is the name of the class whose constructor
|
|
/// is invoked by the CXXConstructExpr, not the name of the class whose
|
|
/// constructor the CXXConstructExpr is contained in.
|
|
class ConstructExprVisitor
|
|
: public ExpectedLocationVisitor<ConstructExprVisitor> {
|
|
public:
|
|
ConstructExprVisitor() : ShouldVisitImplicitCode(false) {}
|
|
|
|
bool shouldVisitImplicitCode() const { return ShouldVisitImplicitCode; }
|
|
|
|
void setShouldVisitImplicitCode(bool NewValue) {
|
|
ShouldVisitImplicitCode = NewValue;
|
|
}
|
|
|
|
bool VisitCXXConstructExpr(CXXConstructExpr* Expr) {
|
|
if (const CXXConstructorDecl* Ctor = Expr->getConstructor()) {
|
|
if (const CXXRecordDecl* Class = Ctor->getParent()) {
|
|
Match(Class->getName(), Expr->getLocation());
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
bool ShouldVisitImplicitCode;
|
|
};
|
|
|
|
TEST(RecursiveASTVisitor, CanVisitImplicitMemberInitializations) {
|
|
ConstructExprVisitor Visitor;
|
|
Visitor.setShouldVisitImplicitCode(true);
|
|
Visitor.ExpectMatch("WithCtor", 2, 8);
|
|
// Simple has a constructor that implicitly initializes 'w'. Test
|
|
// that a visitor that visits implicit code visits that initialization.
|
|
// Note: Clang lazily instantiates implicit declarations, so we need
|
|
// to use them in order to force them to appear in the AST.
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"struct WithCtor { WithCtor(); }; \n"
|
|
"struct Simple { WithCtor w; }; \n"
|
|
"int main() { Simple s; }\n"));
|
|
}
|
|
|
|
// The same as CanVisitImplicitMemberInitializations, but checking that the
|
|
// visits are omitted when the visitor does not include implicit code.
|
|
TEST(RecursiveASTVisitor, CanSkipImplicitMemberInitializations) {
|
|
ConstructExprVisitor Visitor;
|
|
Visitor.setShouldVisitImplicitCode(false);
|
|
Visitor.DisallowMatch("WithCtor", 2, 8);
|
|
// Simple has a constructor that implicitly initializes 'w'. Test
|
|
// that a visitor that skips implicit code skips that initialization.
|
|
// Note: Clang lazily instantiates implicit declarations, so we need
|
|
// to use them in order to force them to appear in the AST.
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"struct WithCtor { WithCtor(); }; \n"
|
|
"struct Simple { WithCtor w; }; \n"
|
|
"int main() { Simple s; }\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsExtension) {
|
|
DeclRefExprVisitor Visitor;
|
|
Visitor.ExpectMatch("s", 1, 24);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"int s = __extension__ (s);\n"));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsCompoundLiteralType) {
|
|
TypeLocVisitor Visitor;
|
|
Visitor.ExpectMatch("struct S", 1, 26);
|
|
EXPECT_TRUE(Visitor.runOver(
|
|
"int f() { return (struct S { int a; }){.a = 0}.a; }",
|
|
TypeLocVisitor::Lang_C));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, VisitsLambdaExpr) {
|
|
LambdaExprVisitor Visitor;
|
|
Visitor.ExpectMatch("", 1, 12);
|
|
EXPECT_TRUE(Visitor.runOver("void f() { []{ return; }(); }",
|
|
LambdaExprVisitor::Lang_CXX11));
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, TraverseLambdaBodyCanBeOverridden) {
|
|
LambdaExprVisitor Visitor;
|
|
EXPECT_TRUE(Visitor.runOver("void f() { []{ return; }(); }",
|
|
LambdaExprVisitor::Lang_CXX11));
|
|
EXPECT_TRUE(Visitor.allBodiesHaveBeenTraversed());
|
|
}
|
|
|
|
TEST(RecursiveASTVisitor, HasCaptureDefaultLoc) {
|
|
LambdaDefaultCaptureVisitor Visitor;
|
|
Visitor.ExpectMatch("", 1, 20);
|
|
EXPECT_TRUE(Visitor.runOver("void f() { int a; [=]{a;}; }",
|
|
LambdaDefaultCaptureVisitor::Lang_CXX11));
|
|
}
|
|
|
|
// Checks for lambda classes that are not marked as implicitly-generated.
|
|
// (There should be none.)
|
|
class ClassVisitor : public ExpectedLocationVisitor<ClassVisitor> {
|
|
public:
|
|
ClassVisitor() : SawNonImplicitLambdaClass(false) {}
|
|
bool VisitCXXRecordDecl(CXXRecordDecl* record) {
|
|
if (record->isLambda() && !record->isImplicit())
|
|
SawNonImplicitLambdaClass = true;
|
|
return true;
|
|
}
|
|
|
|
bool sawOnlyImplicitLambdaClasses() const {
|
|
return !SawNonImplicitLambdaClass;
|
|
}
|
|
|
|
private:
|
|
bool SawNonImplicitLambdaClass;
|
|
};
|
|
|
|
TEST(RecursiveASTVisitor, LambdaClosureTypesAreImplicit) {
|
|
ClassVisitor Visitor;
|
|
EXPECT_TRUE(Visitor.runOver("auto lambda = []{};",
|
|
ClassVisitor::Lang_CXX11));
|
|
EXPECT_TRUE(Visitor.sawOnlyImplicitLambdaClasses());
|
|
}
|
|
|
|
} // end namespace clang
|