test

[klimek]

Summary

another test

include/clang/ASTMatchers/ASTMatchers.h

   const T *getStmtAs(StringRef ID) const {
     return getNodeAs<T>(StmtBindings, ID);
   }
+  QualType *getType(StringRef ID) const {
+
+  }
   /// @}
 
 private:  return internal::PolymorphicMatcherWithParam0<internal::TrueMatcher>();

 }
 
 /// \brief Matches types.
+///
+/// Examples matches TODO
+/// \code
+/// TODO
+/// \endcode
+const internal::VariadicNodeMatcher<QualType> type;
+
+/// \brief Matches declarations.
 ///
 /// Examples matches \c X, \c C, and the friend declaration inside \c C;
 

include/clang/ASTMatchers/ASTMatchersInternal.h

 template <typename T>
 class BindableMatcher : public Matcher<T> {
 public:
-  BindableMatcher(MatcherInterface<T> *Implementation)
+  explicit BindableMatcher(MatcherInterface<T> *Implementation)
     : Matcher<T>(Implementation) {}
 
+  explicit BindableMatcher(const Matcher<T> &Other)
+    : Matcher<T>(Other) {}
+
   /// \brief Returns a matcher that will bind the matched node on a match.
   ///
   /// The returned matcher is equivalent to this matcher, but will  const Matcher<T> InnertMatcher2;

 };
 
 template<typename T>
+BindableMatcher<T> makeAllOfComposite(
+    ArrayRef<const Matcher<T> *> Matchers) {
+  if (Matchers.empty()) {
+    return BindableMatcher<T>(new TrueMatcher<T>);
+  }
+  Matcher<T> Combined = *Matchers.back();
+  for (int i = Matchers.size() - 2; i >= 0; --i) {
+    Combined = makeMatcher(
+      new AllOfMatcher<T, Matcher<T>, Matcher<T> >(
+        *Matchers[i], Combined));
+  }
+  return BindableMatcher<T>(Combined);
+}
+
+/// \brief Creates a Matcher<T> that matches if
 /// T is dyn_cast'able into InnerT and all inner matchers match.
 ///template<typename T, typename InnerT>
 BindableMatcher<T> makeDynCastAllOfComposite(

     ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
   return BindableMatcher<T>(new DynCastMatcher<T, InnerT>(
     makeAllOfComposite(InnerMatchers)));
-    return BindableMatcher<T>(new DynCastMatcher<T, InnerT>(InnerMatcher));
-  }
-  Matcher<InnerT> InnerMatcher = *InnerMatchers.back();
-  for (int i = InnerMatchers.size() - 2; i >= 0; --i) {
-    InnerMatcher = makeMatcher(
-        new AllOfMatcher<InnerT, Matcher<InnerT>, Matcher<InnerT> >(
-            *InnerMatchers[i], InnerMatcher));
-  }
-  return BindableMatcher<T>(new DynCastMatcher<T, InnerT>(InnerMatcher));
-}
-
+
+
 /// \brief Matches nodes of type T that have at least one descendant node of  VariadicDynCastAllOfMatcher() {}
 };
 

 template <typename T>
 class VariadicNodeMatcher
   : public llvm::VariadicFunction<
+      BindableMatcher<T>, Matcher<T>,
+      makeAllOfComposite<T> > {
+public:
+  VariadicNodeMatcher() {}
+};
+
+} // end namespace internal
+} // end namespace ast_matchers
+} // end namespace clang
 
 
 

unittests/ASTMatchers/ASTMatchersTest.cpp

                       decl(usingDecl())));
 }
 
+TEST(Type, MatchesTypes) {
+  EXPECT_TRUE(notMatches("", type(asString("x")).bind("x")));
+  EXPECT_TRUE(matches("typedef int x; x y;", type(asString("x"))));
+}
+
 TEST(NameableDeclaration, MatchesVariousDecls) {
   DeclarationMatcher NamedX = nameableDeclaration(hasName("X"));
   EXPECT_TRUE(matches("typedef int X;", NamedX));