Revert "Add support for eachOf/allOf/anyOf variadic matchers in the dynamic layer."

Summary:
This reverts commit 3b082a3c72324aa3363b5184731740534c6b9a2b.

It breaks the build in c++11 mode.

Reviewers: klimek

CC: cfe-commits, revane

Differential Revision: http://llvm-reviews.chandlerc.com/D1533

llvm-svn: 189368

3 files changed, 19 insertions, 84 deletions

diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.h b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
index 902fdc364b4..94b95b10d56 100644
--- a/clang/lib/ASTMatchers/Dynamic/Marshallers.h
+++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
@@ -348,36 +348,6 @@ private:
   std::vector<MatcherCreateCallback *> Overloads;
 };
 
-/// \brief Variadic operator marshaller function.
-class VariadicOperatorMatcherCreateCallback : public MatcherCreateCallback {
-public:
-  typedef ast_matchers::internal::VariadicOperatorFunction VarFunc;
-  VariadicOperatorMatcherCreateCallback(VarFunc Func, StringRef MatcherName)
-      : Func(Func), MatcherName(MatcherName) {}
-
-  virtual VariantMatcher run(const SourceRange &NameRange,
-                             ArrayRef<ParserValue> Args,
-                             Diagnostics *Error) const {
-    std::vector<VariantMatcher> InnerArgs;
-    for (size_t i = 0, e = Args.size(); i != e; ++i) {
-      const ParserValue &Arg = Args[i];
-      const VariantValue &Value = Arg.Value;
-      if (!Value.isMatcher()) {
-        Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
-            << (i + 1) << "Matcher<>" << Value.getTypeAsString();
-        return VariantMatcher();
-      }
-      InnerArgs.push_back(Value.getMatcher());
-    }
-    return VariantMatcher::VariadicOperatorMatcher(Func, InnerArgs);
-  }
-
-private:
-  const VarFunc Func;
-  const StringRef MatcherName;
-};
-
-
 /// Helper functions to select the appropriate marshaller functions.
 /// They detect the number of arguments, arguments types and return type.
 
@@ -440,13 +410,6 @@ AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>::collect(
   collect(typename FromTypeList::tail());
 }
 
-/// \brief Variadic operator overload.
-MatcherCreateCallback *makeMatcherAutoMarshall(
-    ast_matchers::internal::VariadicOperatorMatcherFunc Func,
-    StringRef MatcherName) {
-  return new VariadicOperatorMatcherCreateCallback(Func.Func, MatcherName);
-}
-
 }  // namespace internal
 }  // namespace dynamic
 }  // namespace ast_matchers
diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
index 3f8e7d4cd9d..55763b0efec 100644
--- a/clang/lib/ASTMatchers/Dynamic/Registry.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
@@ -77,6 +77,9 @@ RegistryMaps::RegistryMaps() {
   //
   // Polymorphic + argument overload:
   // unless
+  // eachOf
+  // anyOf
+  // allOf
   // findAll
   //
   // Other:
@@ -96,8 +99,6 @@ RegistryMaps::RegistryMaps() {
 
   REGISTER_MATCHER(accessSpecDecl);
   REGISTER_MATCHER(alignOfExpr);
-  REGISTER_MATCHER(allOf);
-  REGISTER_MATCHER(anyOf);
   REGISTER_MATCHER(anything);
   REGISTER_MATCHER(argumentCountIs);
   REGISTER_MATCHER(arraySubscriptExpr);
@@ -140,7 +141,6 @@ RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(destructorDecl);
   REGISTER_MATCHER(doStmt);
   REGISTER_MATCHER(dynamicCastExpr);
-  REGISTER_MATCHER(eachOf);
   REGISTER_MATCHER(elaboratedType);
   REGISTER_MATCHER(enumConstantDecl);
   REGISTER_MATCHER(enumDecl);
diff --git a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
index c350d78aa14..87aca7da853 100644
--- a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
@@ -38,9 +38,13 @@ public:
         .str();
   }
 
-  virtual void makeTypedMatcher(MatcherOps &Ops) const {
-    if (Ops.canConstructFrom(*Matcher))
-      Ops.constructFrom(*Matcher);
+  virtual bool hasTypedMatcher(const MatcherOps &Ops) const {
+    return Ops.canConstructFrom(*Matcher);
+  }
+
+  virtual const DynTypedMatcher *getTypedMatcher(const MatcherOps &Ops) const {
+    assert(hasTypedMatcher(Ops));
+    return Matcher.get();
   }
 
 private:
@@ -76,49 +80,23 @@ public:
     return (Twine("Matcher<") + Inner + ">").str();
   }
 
-  virtual void makeTypedMatcher(MatcherOps &Ops) const {
-    const DynTypedMatcher *Found = NULL;
+  virtual bool hasTypedMatcher(const MatcherOps &Ops) const {
+    return getTypedMatcher(Ops) != NULL;
+  }
+
+  virtual const DynTypedMatcher *getTypedMatcher(const MatcherOps &Ops) const {
+    const DynTypedMatcher* Found = NULL;
     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
       if (Ops.canConstructFrom(*Matchers[i])) {
-        if (Found)
-          return;
+        if (Found) return NULL;
         Found = Matchers[i];
       }
     }
-    if (Found)
-      Ops.constructFrom(*Found);
-  }
-
-  std::vector<const DynTypedMatcher *> Matchers;
-};
-
-class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
-public:
-  VariadicOpPayload(ast_matchers::internal::VariadicOperatorFunction Func,
-                    ArrayRef<VariantMatcher> Args)
-      : Func(Func), Args(Args) {}
-
-  virtual bool getSingleMatcher(const DynTypedMatcher *&Out) const {
-    return false;
-  }
-
-  virtual std::string getTypeAsString() const {
-    std::string Inner;
-    for (size_t i = 0, e = Args.size(); i != e; ++i) {
-      if (i != 0)
-        Inner += "&";
-      Inner += Args[i].getTypeAsString();
-    }
-    return Inner;
-  }
-
-  virtual void makeTypedMatcher(MatcherOps &Ops) const {
-    Ops.constructVariadicOperator(Func, Args);
+    return Found;
   }
 
 private:
-  const ast_matchers::internal::VariadicOperatorFunction Func;
-  const std::vector<VariantMatcher> Args;
+  std::vector<const DynTypedMatcher *> Matchers;
 };
 
 VariantMatcher::VariantMatcher() {}
@@ -132,12 +110,6 @@ VariantMatcher::PolymorphicMatcher(ArrayRef<const DynTypedMatcher *> Matchers) {
   return VariantMatcher(new PolymorphicPayload(Matchers));
 }
 
-VariantMatcher VariantMatcher::VariadicOperatorMatcher(
-    ast_matchers::internal::VariadicOperatorFunction Func,
-    ArrayRef<VariantMatcher> Args) {
-  return VariantMatcher(new VariadicOpPayload(Func, Args));
-}
-
 bool VariantMatcher::getSingleMatcher(const DynTypedMatcher *&Out) const {
   if (Value) return Value->getSingleMatcher(Out);
   return false;