Updated to Clang 3.5a.
Change-Id: I8127eb568f674c2e72635b639a3295381fe8af82
diff --git a/unittests/ASTMatchers/Dynamic/CMakeLists.txt b/unittests/ASTMatchers/Dynamic/CMakeLists.txt
index eb9fa54..8b95a7b 100644
--- a/unittests/ASTMatchers/Dynamic/CMakeLists.txt
+++ b/unittests/ASTMatchers/Dynamic/CMakeLists.txt
@@ -1,7 +1,16 @@
+set(LLVM_LINK_COMPONENTS
+ Support
+ )
+
add_clang_unittest(DynamicASTMatchersTests
VariantValueTest.cpp
ParserTest.cpp
RegistryTest.cpp)
target_link_libraries(DynamicASTMatchersTests
- gtest gtest_main clangASTMatchers clangDynamicASTMatchers clangTooling)
+ clangAST
+ clangASTMatchers
+ clangDynamicASTMatchers
+ clangFrontend
+ clangTooling
+ )
diff --git a/unittests/ASTMatchers/Dynamic/ParserTest.cpp b/unittests/ASTMatchers/Dynamic/ParserTest.cpp
index f19ec51..cdf4f92 100644
--- a/unittests/ASTMatchers/Dynamic/ParserTest.cpp
+++ b/unittests/ASTMatchers/Dynamic/ParserTest.cpp
@@ -7,14 +7,14 @@
//
//===-------------------------------------------------------------------===//
-#include <string>
-#include <vector>
-
#include "../ASTMatchersTest.h"
#include "clang/ASTMatchers/Dynamic/Parser.h"
#include "clang/ASTMatchers/Dynamic/Registry.h"
-#include "gtest/gtest.h"
+#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringMap.h"
+#include "gtest/gtest.h"
+#include <string>
+#include <vector>
namespace clang {
namespace ast_matchers {
@@ -39,15 +39,24 @@
Errors.push_back(Error.toStringFull());
}
- VariantMatcher actOnMatcherExpression(StringRef MatcherName,
+ llvm::Optional<MatcherCtor> lookupMatcherCtor(StringRef MatcherName,
+ const SourceRange &NameRange,
+ Diagnostics *Error) {
+ const ExpectedMatchersTy::value_type *Matcher =
+ &*ExpectedMatchers.find(MatcherName);
+ return reinterpret_cast<MatcherCtor>(Matcher);
+ }
+
+ VariantMatcher actOnMatcherExpression(MatcherCtor Ctor,
const SourceRange &NameRange,
StringRef BindID,
ArrayRef<ParserValue> Args,
Diagnostics *Error) {
- MatcherInfo ToStore = { MatcherName, NameRange, Args, BindID };
+ const ExpectedMatchersTy::value_type *Matcher =
+ reinterpret_cast<const ExpectedMatchersTy::value_type *>(Ctor);
+ MatcherInfo ToStore = { Matcher->first, NameRange, Args, BindID };
Matchers.push_back(ToStore);
- return VariantMatcher::SingleMatcher(
- ExpectedMatchers.find(MatcherName)->second);
+ return VariantMatcher::SingleMatcher(Matcher->second);
}
struct MatcherInfo {
@@ -60,8 +69,9 @@
std::vector<std::string> Errors;
std::vector<VariantValue> Values;
std::vector<MatcherInfo> Matchers;
- std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
- ExpectedMatchers;
+ typedef std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
+ ExpectedMatchersTy;
+ ExpectedMatchersTy ExpectedMatchers;
};
TEST(ParserTest, ParseUnsigned) {
@@ -194,16 +204,19 @@
"1:5: Error parsing matcher. Found token <123> while looking for '('.",
ParseWithError("Foo 123"));
EXPECT_EQ(
+ "1:1: Matcher not found: Foo\n"
"1:9: Error parsing matcher. Found token <123> while looking for ','.",
ParseWithError("Foo(\"A\" 123)"));
EXPECT_EQ(
+ "1:1: Matcher not found: Foo\n"
"1:4: Error parsing matcher. Found end-of-code while looking for ')'.",
ParseWithError("Foo("));
EXPECT_EQ("1:1: End of code found while looking for token.",
ParseWithError(""));
EXPECT_EQ("Input value is not a matcher expression.",
ParseMatcherWithError("\"A\""));
- EXPECT_EQ("1:1: Error parsing argument 1 for matcher Foo.\n"
+ EXPECT_EQ("1:1: Matcher not found: Foo\n"
+ "1:1: Error parsing argument 1 for matcher Foo.\n"
"1:5: Invalid token <(> found when looking for a value.",
ParseWithError("Foo(("));
EXPECT_EQ("1:7: Expected end of code.", ParseWithError("expr()a"));
@@ -232,6 +245,20 @@
ParseWithError("callee(\"A\")"));
}
+TEST(ParserTest, Completion) {
+ std::vector<MatcherCompletion> Comps =
+ Parser::completeExpression("while", 5);
+ ASSERT_EQ(1u, Comps.size());
+ EXPECT_EQ("Stmt(", Comps[0].TypedText);
+ EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
+ Comps[0].MatcherDecl);
+
+ Comps = Parser::completeExpression("whileStmt().", 12);
+ ASSERT_EQ(1u, Comps.size());
+ EXPECT_EQ("bind(\"", Comps[0].TypedText);
+ EXPECT_EQ("bind", Comps[0].MatcherDecl);
+}
+
} // end anonymous namespace
} // end namespace dynamic
} // end namespace ast_matchers
diff --git a/unittests/ASTMatchers/Dynamic/RegistryTest.cpp b/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
index e716484..150f8c9 100644
--- a/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
+++ b/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
@@ -7,11 +7,10 @@
//
//===-----------------------------------------------------------------------===//
-#include <vector>
-
#include "../ASTMatchersTest.h"
#include "clang/ASTMatchers/Dynamic/Registry.h"
#include "gtest/gtest.h"
+#include <vector>
namespace clang {
namespace ast_matchers {
@@ -36,12 +35,24 @@
return Out;
}
+ llvm::Optional<MatcherCtor> lookupMatcherCtor(StringRef MatcherName,
+ Diagnostics *Error = 0) {
+ Diagnostics DummyError;
+ if (!Error) Error = &DummyError;
+ llvm::Optional<MatcherCtor> Ctor =
+ Registry::lookupMatcherCtor(MatcherName, SourceRange(), Error);
+ EXPECT_EQ("", DummyError.toStringFull());
+ return Ctor;
+ }
+
VariantMatcher constructMatcher(StringRef MatcherName,
Diagnostics *Error = NULL) {
Diagnostics DummyError;
if (!Error) Error = &DummyError;
- const VariantMatcher Out =
- Registry::constructMatcher(MatcherName, SourceRange(), Args(), Error);
+ llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName, Error);
+ VariantMatcher Out;
+ if (Ctor)
+ Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(), Error);
EXPECT_EQ("", DummyError.toStringFull());
return Out;
}
@@ -51,9 +62,11 @@
Diagnostics *Error = NULL) {
Diagnostics DummyError;
if (!Error) Error = &DummyError;
- const VariantMatcher Out = Registry::constructMatcher(
- MatcherName, SourceRange(), Args(Arg1), Error);
- EXPECT_EQ("", DummyError.toStringFull());
+ llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName, Error);
+ VariantMatcher Out;
+ if (Ctor)
+ Out = Registry::constructMatcher(*Ctor, SourceRange(), Args(Arg1), Error);
+ EXPECT_EQ("", DummyError.toStringFull()) << MatcherName;
return Out;
}
@@ -63,11 +76,58 @@
Diagnostics *Error = NULL) {
Diagnostics DummyError;
if (!Error) Error = &DummyError;
- const VariantMatcher Out = Registry::constructMatcher(
- MatcherName, SourceRange(), Args(Arg1, Arg2), Error);
+ llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName, Error);
+ 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() {
+ return Registry::getCompletions(
+ llvm::ArrayRef<std::pair<MatcherCtor, unsigned> >());
+ }
+
+ 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::getCompletions(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::getCompletions(Context);
+ }
+
+ bool hasCompletion(const CompVector &Comps, StringRef TypedText,
+ StringRef MatcherDecl = StringRef(), unsigned *Index = 0) {
+ for (CompVector::const_iterator I = Comps.begin(), E = Comps.end(); I != E;
+ ++I) {
+ if (I->TypedText == TypedText &&
+ (MatcherDecl.empty() || I->MatcherDecl == MatcherDecl)) {
+ if (Index)
+ *Index = I - Comps.begin();
+ return true;
+ }
+ }
+ return false;
+ }
};
TEST_F(RegistryTest, CanConstructNoArgs) {
@@ -151,6 +211,25 @@
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) {
@@ -295,11 +374,22 @@
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));
}
TEST_F(RegistryTest, Errors) {
// Incorrect argument count.
- OwningPtr<Diagnostics> Error(new Diagnostics());
+ 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());
@@ -307,6 +397,15 @@
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());
@@ -324,7 +423,8 @@
// Bad argument type with variadic.
Error.reset(new Diagnostics());
- EXPECT_TRUE(constructMatcher("anyOf", std::string(), Error.get()).isNull());
+ EXPECT_TRUE(constructMatcher("anyOf", std::string(), std::string(),
+ Error.get()).isNull());
EXPECT_EQ(
"Incorrect type for arg 1. (Expected = Matcher<>) != (Actual = String)",
Error->toString());
@@ -341,6 +441,47 @@
Error->toString());
}
+TEST_F(RegistryTest, Completion) {
+ CompVector Comps = getCompletions();
+ EXPECT_TRUE(hasCompletion(
+ Comps, "hasParent(", "Matcher<Decl|Stmt> hasParent(Matcher<Decl|Stmt>)"));
+ EXPECT_TRUE(hasCompletion(Comps, "whileStmt(",
+ "Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)"));
+
+ CompVector WhileComps = getCompletions("whileStmt", 0);
+
+ unsigned HasBodyIndex, HasParentIndex, AllOfIndex;
+ EXPECT_TRUE(hasCompletion(WhileComps, "hasBody(",
+ "Matcher<WhileStmt> hasBody(Matcher<Stmt>)",
+ &HasBodyIndex));
+ EXPECT_TRUE(hasCompletion(WhileComps, "hasParent(",
+ "Matcher<Stmt> hasParent(Matcher<Decl|Stmt>)",
+ &HasParentIndex));
+ EXPECT_TRUE(hasCompletion(WhileComps, "allOf(",
+ "Matcher<T> allOf(Matcher<T>...)", &AllOfIndex));
+ EXPECT_GT(HasParentIndex, HasBodyIndex);
+ EXPECT_GT(AllOfIndex, HasParentIndex);
+
+ 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)"));
+}
+
} // end anonymous namespace
} // end namespace dynamic
} // end namespace ast_matchers
diff --git a/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp b/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
index d2b8a58..e62a464 100644
--- a/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
+++ b/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
@@ -117,7 +117,7 @@
EXPECT_FALSE(VariantValue(VariantMatcher::SingleMatcher(varDecl()))
.getMatcher()
.hasTypedMatcher<Stmt>());
-#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST && !defined(_MSC_VER)
+#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
// Trying to get the wrong matcher fails an assertion in Matcher<T>. We don't
// do this test when building with MSVC because its debug C runtime prints the
// assertion failure message as a wide string, which gtest doesn't understand.