//===- unittest/ASTMatchers/Dynamic/RegistryTest.cpp - Registry unit tests -===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===-----------------------------------------------------------------------===// #include "../ASTMatchersTest.h" #include "clang/ASTMatchers/Dynamic/Registry.h" #include "gtest/gtest.h" #include <vector> namespace clang { namespace ast_matchers { namespace dynamic { namespace { using ast_matchers::internal::Matcher; class RegistryTest : public ::testing::Test { public: std::vector<ParserValue> Args() { return std::vector<ParserValue>(); } std::vector<ParserValue> Args(const VariantValue &Arg1) { std::vector<ParserValue> Out(1); Out[0].Value = Arg1; return Out; } std::vector<ParserValue> Args(const VariantValue &Arg1, const VariantValue &Arg2) { std::vector<ParserValue> Out(2); Out[0].Value = Arg1; Out[1].Value = Arg2; return Out; } llvm::Optional<MatcherCtor> lookupMatcherCtor(StringRef MatcherName) { return Registry::lookupMatcherCtor(MatcherName); } VariantMatcher constructMatcher(StringRef MatcherName, Diagnostics *Error = nullptr) { Diagnostics DummyError; if (!Error) Error = &DummyError; llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName); VariantMatcher Out; if (Ctor) Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(), Error); EXPECT_EQ("", DummyError.toStringFull()); return Out; } VariantMatcher constructMatcher(StringRef MatcherName, const VariantValue &Arg1, Diagnostics *Error = nullptr) { Diagnostics DummyError; if (!Error) Error = &DummyError; llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName); VariantMatcher Out; if (Ctor) Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(Arg1), Error); EXPECT_EQ("", DummyError.toStringFull()) << MatcherName; return Out; } VariantMatcher constructMatcher(StringRef MatcherName, const VariantValue &Arg1, const VariantValue &Arg2, Diagnostics *Error = nullptr) { Diagnostics DummyError; if (!Error) Error = &DummyError; llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName); VariantMatcher Out; if (Ctor) Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(Arg1, Arg2), Error); EXPECT_EQ("", DummyError.toStringFull()); return Out; } typedef std::vector<MatcherCompletion> CompVector; CompVector getCompletions() { std::vector<std::pair<MatcherCtor, unsigned> > Context; return Registry::getMatcherCompletions( Registry::getAcceptedCompletionTypes(Context)); } CompVector getCompletions(StringRef MatcherName1, unsigned ArgNo1) { std::vector<std::pair<MatcherCtor, unsigned> > Context; llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName1); if (!Ctor) return CompVector(); Context.push_back(std::make_pair(*Ctor, ArgNo1)); return Registry::getMatcherCompletions( Registry::getAcceptedCompletionTypes(Context)); } CompVector getCompletions(StringRef MatcherName1, unsigned ArgNo1, StringRef MatcherName2, unsigned ArgNo2) { std::vector<std::pair<MatcherCtor, unsigned> > Context; llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName1); if (!Ctor) return CompVector(); Context.push_back(std::make_pair(*Ctor, ArgNo1)); Ctor = lookupMatcherCtor(MatcherName2); if (!Ctor) return CompVector(); Context.push_back(std::make_pair(*Ctor, ArgNo2)); return Registry::getMatcherCompletions( Registry::getAcceptedCompletionTypes(Context)); } bool hasCompletion(const CompVector &Comps, StringRef TypedText, StringRef MatcherDecl = StringRef()) { for (CompVector::const_iterator I = Comps.begin(), E = Comps.end(); I != E; ++I) { if (I->TypedText == TypedText && (MatcherDecl.empty() || I->MatcherDecl == MatcherDecl)) { return true; } } return false; } }; TEST_F(RegistryTest, CanConstructNoArgs) { Matcher<Stmt> IsArrowValue = constructMatcher( "memberExpr", constructMatcher("isArrow")).getTypedMatcher<Stmt>(); Matcher<Stmt> BoolValue = constructMatcher("boolLiteral").getTypedMatcher<Stmt>(); const std::string ClassSnippet = "struct Foo { int x; };\n" "Foo *foo = new Foo;\n" "int i = foo->x;\n"; const std::string BoolSnippet = "bool Foo = true;\n"; EXPECT_TRUE(matches(ClassSnippet, IsArrowValue)); EXPECT_TRUE(matches(BoolSnippet, BoolValue)); EXPECT_FALSE(matches(ClassSnippet, BoolValue)); EXPECT_FALSE(matches(BoolSnippet, IsArrowValue)); } TEST_F(RegistryTest, ConstructWithSimpleArgs) { Matcher<Decl> Value = constructMatcher( "namedDecl", constructMatcher("hasName", std::string("X"))) .getTypedMatcher<Decl>(); EXPECT_TRUE(matches("class X {};", Value)); EXPECT_FALSE(matches("int x;", Value)); Value = functionDecl(constructMatcher("parameterCountIs", 2) .getTypedMatcher<FunctionDecl>()); EXPECT_TRUE(matches("void foo(int,int);", Value)); EXPECT_FALSE(matches("void foo(int);", Value)); } TEST_F(RegistryTest, ConstructWithMatcherArgs) { Matcher<Decl> HasInitializerSimple = constructMatcher( "varDecl", constructMatcher("hasInitializer", constructMatcher("stmt"))) .getTypedMatcher<Decl>(); Matcher<Decl> HasInitializerComplex = constructMatcher( "varDecl", constructMatcher("hasInitializer", constructMatcher("callExpr"))) .getTypedMatcher<Decl>(); std::string code = "int i;"; EXPECT_FALSE(matches(code, HasInitializerSimple)); EXPECT_FALSE(matches(code, HasInitializerComplex)); code = "int i = 1;"; EXPECT_TRUE(matches(code, HasInitializerSimple)); EXPECT_FALSE(matches(code, HasInitializerComplex)); code = "int y(); int i = y();"; EXPECT_TRUE(matches(code, HasInitializerSimple)); EXPECT_TRUE(matches(code, HasInitializerComplex)); Matcher<Decl> HasParameter = functionDecl(constructMatcher( "hasParameter", 1, constructMatcher("hasName", std::string("x"))) .getTypedMatcher<FunctionDecl>()); EXPECT_TRUE(matches("void f(int a, int x);", HasParameter)); EXPECT_FALSE(matches("void f(int x, int a);", HasParameter)); } TEST_F(RegistryTest, OverloadedMatchers) { Matcher<Stmt> CallExpr0 = constructMatcher( "callExpr", constructMatcher("callee", constructMatcher("memberExpr", constructMatcher("isArrow")))) .getTypedMatcher<Stmt>(); Matcher<Stmt> CallExpr1 = constructMatcher( "callExpr", constructMatcher( "callee", constructMatcher("methodDecl", constructMatcher("hasName", std::string("x"))))) .getTypedMatcher<Stmt>(); std::string Code = "class Y { public: void x(); }; void z() { Y y; y.x(); }"; EXPECT_FALSE(matches(Code, CallExpr0)); EXPECT_TRUE(matches(Code, CallExpr1)); Code = "class Z { public: void z() { this->z(); } };"; EXPECT_TRUE(matches(Code, CallExpr0)); EXPECT_FALSE(matches(Code, CallExpr1)); Matcher<Decl> DeclDecl = declaratorDecl(hasTypeLoc( constructMatcher( "loc", constructMatcher("asString", std::string("const double *"))) .getTypedMatcher<TypeLoc>())); Matcher<NestedNameSpecifierLoc> NNSL = constructMatcher( "loc", VariantMatcher::SingleMatcher(nestedNameSpecifier( specifiesType(hasDeclaration(recordDecl(hasName("A"))))))) .getTypedMatcher<NestedNameSpecifierLoc>(); Code = "const double * x = 0;"; EXPECT_TRUE(matches(Code, DeclDecl)); EXPECT_FALSE(matches(Code, NNSL)); Code = "struct A { struct B {}; }; A::B a_b;"; EXPECT_FALSE(matches(Code, DeclDecl)); EXPECT_TRUE(matches(Code, NNSL)); } TEST_F(RegistryTest, PolymorphicMatchers) { const VariantMatcher IsDefinition = constructMatcher("isDefinition"); Matcher<Decl> Var = constructMatcher("varDecl", IsDefinition).getTypedMatcher<Decl>(); Matcher<Decl> Class = constructMatcher("recordDecl", IsDefinition).getTypedMatcher<Decl>(); Matcher<Decl> Func = constructMatcher("functionDecl", IsDefinition).getTypedMatcher<Decl>(); EXPECT_TRUE(matches("int a;", Var)); EXPECT_FALSE(matches("extern int a;", Var)); EXPECT_TRUE(matches("class A {};", Class)); EXPECT_FALSE(matches("class A;", Class)); EXPECT_TRUE(matches("void f(){};", Func)); EXPECT_FALSE(matches("void f();", Func)); Matcher<Decl> Anything = constructMatcher("anything").getTypedMatcher<Decl>(); Matcher<Decl> RecordDecl = constructMatcher( "recordDecl", constructMatcher("hasName", std::string("Foo")), VariantMatcher::SingleMatcher(Anything)).getTypedMatcher<Decl>(); EXPECT_TRUE(matches("int Foo;", Anything)); EXPECT_TRUE(matches("class Foo {};", Anything)); EXPECT_TRUE(matches("void Foo(){};", Anything)); EXPECT_FALSE(matches("int Foo;", RecordDecl)); EXPECT_TRUE(matches("class Foo {};", RecordDecl)); EXPECT_FALSE(matches("void Foo(){};", RecordDecl)); Matcher<Stmt> ConstructExpr = constructMatcher( "constructExpr", constructMatcher( "hasDeclaration", constructMatcher( "methodDecl", constructMatcher( "ofClass", constructMatcher("hasName", std::string("Foo")))))) .getTypedMatcher<Stmt>(); EXPECT_FALSE(matches("class Foo { public: Foo(); };", ConstructExpr)); EXPECT_TRUE( matches("class Foo { public: Foo(); }; Foo foo = Foo();", ConstructExpr)); } TEST_F(RegistryTest, TemplateArgument) { Matcher<Decl> HasTemplateArgument = constructMatcher( "classTemplateSpecializationDecl", constructMatcher( "hasAnyTemplateArgument", constructMatcher("refersToType", constructMatcher("asString", std::string("int"))))) .getTypedMatcher<Decl>(); EXPECT_TRUE(matches("template<typename T> class A {}; A<int> a;", HasTemplateArgument)); EXPECT_FALSE(matches("template<typename T> class A {}; A<char> a;", HasTemplateArgument)); } TEST_F(RegistryTest, TypeTraversal) { Matcher<Type> M = constructMatcher( "pointerType", constructMatcher("pointee", constructMatcher("isConstQualified"), constructMatcher("isInteger"))).getTypedMatcher<Type>(); EXPECT_FALSE(matches("int *a;", M)); EXPECT_TRUE(matches("int const *b;", M)); M = constructMatcher( "arrayType", constructMatcher("hasElementType", constructMatcher("builtinType"))) .getTypedMatcher<Type>(); EXPECT_FALSE(matches("struct A{}; A a[7];;", M)); EXPECT_TRUE(matches("int b[7];", M)); } TEST_F(RegistryTest, CXXCtorInitializer) { Matcher<Decl> CtorDecl = constructMatcher( "constructorDecl", constructMatcher( "hasAnyConstructorInitializer", constructMatcher("forField", constructMatcher("hasName", std::string("foo"))))) .getTypedMatcher<Decl>(); EXPECT_TRUE(matches("struct Foo { Foo() : foo(1) {} int foo; };", CtorDecl)); EXPECT_FALSE(matches("struct Foo { Foo() {} int foo; };", CtorDecl)); EXPECT_FALSE(matches("struct Foo { Foo() : bar(1) {} int bar; };", CtorDecl)); } TEST_F(RegistryTest, Adaptative) { Matcher<Decl> D = constructMatcher( "recordDecl", constructMatcher( "has", constructMatcher("recordDecl", constructMatcher("hasName", std::string("X"))))) .getTypedMatcher<Decl>(); EXPECT_TRUE(matches("class X {};", D)); EXPECT_TRUE(matches("class Y { class X {}; };", D)); EXPECT_FALSE(matches("class Y { class Z {}; };", D)); Matcher<Stmt> S = constructMatcher( "forStmt", constructMatcher( "hasDescendant", constructMatcher("varDecl", constructMatcher("hasName", std::string("X"))))) .getTypedMatcher<Stmt>(); EXPECT_TRUE(matches("void foo() { for(int X;;); }", S)); EXPECT_TRUE(matches("void foo() { for(;;) { int X; } }", S)); EXPECT_FALSE(matches("void foo() { for(;;); }", S)); EXPECT_FALSE(matches("void foo() { if (int X = 0){} }", S)); S = constructMatcher( "compoundStmt", constructMatcher("hasParent", constructMatcher("ifStmt"))) .getTypedMatcher<Stmt>(); EXPECT_TRUE(matches("void foo() { if (true) { int x = 42; } }", S)); EXPECT_FALSE(matches("void foo() { if (true) return; }", S)); } TEST_F(RegistryTest, VariadicOp) { Matcher<Decl> D = constructMatcher( "anyOf", constructMatcher("recordDecl", constructMatcher("hasName", std::string("Foo"))), constructMatcher("functionDecl", constructMatcher("hasName", std::string("foo")))) .getTypedMatcher<Decl>(); EXPECT_TRUE(matches("void foo(){}", D)); EXPECT_TRUE(matches("struct Foo{};", D)); EXPECT_FALSE(matches("int i = 0;", D)); D = constructMatcher( "allOf", constructMatcher("recordDecl"), constructMatcher( "namedDecl", constructMatcher("anyOf", constructMatcher("hasName", std::string("Foo")), constructMatcher("hasName", std::string("Bar"))))) .getTypedMatcher<Decl>(); EXPECT_FALSE(matches("void foo(){}", D)); EXPECT_TRUE(matches("struct Foo{};", D)); EXPECT_FALSE(matches("int i = 0;", D)); EXPECT_TRUE(matches("class Bar{};", D)); EXPECT_FALSE(matches("class OtherBar{};", D)); D = recordDecl( has(fieldDecl(hasName("Foo"))), constructMatcher( "unless", constructMatcher("namedDecl", constructMatcher("hasName", std::string("Bar")))) .getTypedMatcher<Decl>()); EXPECT_FALSE(matches("class Bar{ int Foo; };", D)); EXPECT_TRUE(matches("class OtherBar{ int Foo; };", D)); D = constructMatcher( "namedDecl", constructMatcher("hasName", std::string("Foo")), constructMatcher("unless", constructMatcher("recordDecl"))) .getTypedMatcher<Decl>(); EXPECT_TRUE(matches("void Foo(){}", D)); EXPECT_TRUE(notMatches("struct Foo {};", D)); } TEST_F(RegistryTest, Errors) { // Incorrect argument count. std::unique_ptr<Diagnostics> Error(new Diagnostics()); EXPECT_TRUE(constructMatcher("hasInitializer", Error.get()).isNull()); EXPECT_EQ("Incorrect argument count. (Expected = 1) != (Actual = 0)", Error->toString()); Error.reset(new Diagnostics()); EXPECT_TRUE(constructMatcher("isArrow", std::string(), Error.get()).isNull()); EXPECT_EQ("Incorrect argument count. (Expected = 0) != (Actual = 1)", Error->toString()); Error.reset(new Diagnostics()); EXPECT_TRUE(constructMatcher("anyOf", Error.get()).isNull()); EXPECT_EQ("Incorrect argument count. (Expected = (2, )) != (Actual = 0)", Error->toString()); Error.reset(new Diagnostics()); EXPECT_TRUE(constructMatcher("unless", std::string(), std::string(), Error.get()).isNull()); EXPECT_EQ("Incorrect argument count. (Expected = (1, 1)) != (Actual = 2)", Error->toString()); // Bad argument type Error.reset(new Diagnostics()); EXPECT_TRUE(constructMatcher("ofClass", std::string(), Error.get()).isNull()); EXPECT_EQ("Incorrect type for arg 1. (Expected = Matcher<CXXRecordDecl>) != " "(Actual = String)", Error->toString()); Error.reset(new Diagnostics()); EXPECT_TRUE(constructMatcher("recordDecl", constructMatcher("recordDecl"), constructMatcher("parameterCountIs", 3), Error.get()).isNull()); EXPECT_EQ("Incorrect type for arg 2. (Expected = Matcher<CXXRecordDecl>) != " "(Actual = Matcher<FunctionDecl>)", Error->toString()); // Bad argument type with variadic. Error.reset(new Diagnostics()); EXPECT_TRUE(constructMatcher("anyOf", std::string(), std::string(), Error.get()).isNull()); EXPECT_EQ( "Incorrect type for arg 1. (Expected = Matcher<>) != (Actual = String)", Error->toString()); Error.reset(new Diagnostics()); EXPECT_TRUE(constructMatcher( "recordDecl", constructMatcher("allOf", constructMatcher("isDerivedFrom", std::string("FOO")), constructMatcher("isArrow")), Error.get()).isNull()); EXPECT_EQ("Incorrect type for arg 1. " "(Expected = Matcher<CXXRecordDecl>) != " "(Actual = Matcher<CXXRecordDecl>&Matcher<MemberExpr>)", Error->toString()); } TEST_F(RegistryTest, Completion) { CompVector Comps = getCompletions(); // Overloaded EXPECT_TRUE(hasCompletion( Comps, "hasParent(", "Matcher<Decl|Stmt> hasParent(Matcher<Decl|Stmt>)")); // Variadic. EXPECT_TRUE(hasCompletion(Comps, "whileStmt(", "Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)")); // Polymorphic. EXPECT_TRUE(hasCompletion( Comps, "hasDescendant(", "Matcher<NestedNameSpecifier|NestedNameSpecifierLoc|QualType|...> " "hasDescendant(Matcher<CXXCtorInitializer|NestedNameSpecifier|" "NestedNameSpecifierLoc|...>)")); CompVector WhileComps = getCompletions("whileStmt", 0); EXPECT_TRUE(hasCompletion(WhileComps, "hasBody(", "Matcher<WhileStmt> hasBody(Matcher<Stmt>)")); EXPECT_TRUE(hasCompletion(WhileComps, "hasParent(", "Matcher<Stmt> hasParent(Matcher<Decl|Stmt>)")); EXPECT_TRUE( hasCompletion(WhileComps, "allOf(", "Matcher<T> allOf(Matcher<T>...)")); EXPECT_FALSE(hasCompletion(WhileComps, "whileStmt(")); EXPECT_FALSE(hasCompletion(WhileComps, "ifStmt(")); CompVector AllOfWhileComps = getCompletions("allOf", 0, "whileStmt", 0); ASSERT_EQ(AllOfWhileComps.size(), WhileComps.size()); EXPECT_TRUE(std::equal(WhileComps.begin(), WhileComps.end(), AllOfWhileComps.begin())); CompVector DeclWhileComps = getCompletions("decl", 0, "whileStmt", 0); EXPECT_EQ(0u, DeclWhileComps.size()); CompVector NamedDeclComps = getCompletions("namedDecl", 0); EXPECT_TRUE( hasCompletion(NamedDeclComps, "isPublic()", "Matcher<Decl> isPublic()")); EXPECT_TRUE(hasCompletion(NamedDeclComps, "hasName(\"", "Matcher<NamedDecl> hasName(string)")); // Heterogeneous overloads. Comps = getCompletions("classTemplateSpecializationDecl", 0); EXPECT_TRUE(hasCompletion( Comps, "isSameOrDerivedFrom(", "Matcher<CXXRecordDecl> isSameOrDerivedFrom(string|Matcher<NamedDecl>)")); } TEST_F(RegistryTest, HasArgs) { Matcher<Decl> Value = constructMatcher( "decl", constructMatcher("hasAttr", std::string("attr::WarnUnused"))) .getTypedMatcher<Decl>(); EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};", Value)); EXPECT_FALSE(matches("struct X {};", Value)); } } // end anonymous namespace } // end namespace dynamic } // end namespace ast_matchers } // end namespace clang