commit c30bf45115860b8de8628295f0d9cd86998841de
author Reid Kleckner <reid@kleckner.net> Mon Oct 21 22:26:36 2013 +0000
committer Reid Kleckner <reid@kleckner.net> Mon Oct 21 22:26:36 2013 +0000
tree 80a7503c50c91adbed2aa3e0961db76f38a35e12
parent 35f51bb5b8bfdca02552be9f2769641ccca6cff8

Revert "Refactor DynTypedMatcher into a value type class, just like Matcher<T>."

This reverts commit r193100.

It was failing to compile with MSVC 2012 while instantiating
llvm::Optional<DynTypedMatcher>.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@193123 91177308-0d34-0410-b5e6-96231b3b80d8

lib/ASTMatchers/Dynamic/VariantValue.cpp

diff --git a/lib/ASTMatchers/Dynamic/VariantValue.cpp b/lib/ASTMatchers/Dynamic/VariantValue.cpp
index 3e49e1b..c350d78 100644
--- a/lib/ASTMatchers/Dynamic/VariantValue.cpp
+++ b/lib/ASTMatchers/Dynamic/VariantValue.cpp
@@ -26,37 +26,44 @@
 
 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
 public:
-  SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
+  SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher.clone()) {}
 
-  virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const {
-    return Matcher;
+  virtual bool getSingleMatcher(const DynTypedMatcher *&Out) const {
+    Out = Matcher.get();
+    return true;
   }
 
   virtual std::string getTypeAsString() const {
-    return (Twine("Matcher<") + Matcher.getSupportedKind().asStringRef() + ">")
+    return (Twine("Matcher<") + Matcher->getSupportedKind().asStringRef() + ">")
         .str();
   }
 
   virtual void makeTypedMatcher(MatcherOps &Ops) const {
-    if (Ops.canConstructFrom(Matcher))
-      Ops.constructFrom(Matcher);
+    if (Ops.canConstructFrom(*Matcher))
+      Ops.constructFrom(*Matcher);
   }
 
 private:
-  const DynTypedMatcher Matcher;
+  OwningPtr<const DynTypedMatcher> Matcher;
 };
 
 class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload {
 public:
-  PolymorphicPayload(ArrayRef<DynTypedMatcher> MatchersIn)
-      : Matchers(MatchersIn) {}
+  PolymorphicPayload(ArrayRef<const DynTypedMatcher *> MatchersIn) {
+    for (size_t i = 0, e = MatchersIn.size(); i != e; ++i) {
+      Matchers.push_back(MatchersIn[i]->clone());
+    }
+  }
 
-  virtual ~PolymorphicPayload() {}
+  virtual ~PolymorphicPayload() {
+    llvm::DeleteContainerPointers(Matchers);
+  }
 
-  virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const {
+  virtual bool getSingleMatcher(const DynTypedMatcher *&Out) const {
     if (Matchers.size() != 1)
-      return llvm::Optional<DynTypedMatcher>();
-    return Matchers[0];
+      return false;
+    Out = Matchers[0];
+    return true;
   }
 
   virtual std::string getTypeAsString() const {
@@ -64,7 +71,7 @@
     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
       if (i != 0)
         Inner += "|";
-      Inner += Matchers[i].getSupportedKind().asStringRef();
+      Inner += Matchers[i]->getSupportedKind().asStringRef();
     }
     return (Twine("Matcher<") + Inner + ">").str();
   }
@@ -72,17 +79,17 @@
   virtual void makeTypedMatcher(MatcherOps &Ops) const {
     const DynTypedMatcher *Found = NULL;
     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
-      if (Ops.canConstructFrom(Matchers[i])) {
+      if (Ops.canConstructFrom(*Matchers[i])) {
         if (Found)
           return;
-        Found = &Matchers[i];
+        Found = Matchers[i];
       }
     }
     if (Found)
       Ops.constructFrom(*Found);
   }
 
-  const std::vector<DynTypedMatcher> Matchers;
+  std::vector<const DynTypedMatcher *> Matchers;
 };
 
 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
@@ -91,8 +98,8 @@
                     ArrayRef<VariantMatcher> Args)
       : Func(Func), Args(Args) {}
 
-  virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const {
-    return llvm::Optional<DynTypedMatcher>();
+  virtual bool getSingleMatcher(const DynTypedMatcher *&Out) const {
+    return false;
   }
 
   virtual std::string getTypeAsString() const {
@@ -121,7 +128,7 @@
 }
 
 VariantMatcher
-VariantMatcher::PolymorphicMatcher(ArrayRef<DynTypedMatcher> Matchers) {
+VariantMatcher::PolymorphicMatcher(ArrayRef<const DynTypedMatcher *> Matchers) {
   return VariantMatcher(new PolymorphicPayload(Matchers));
 }
 
@@ -131,8 +138,9 @@
   return VariantMatcher(new VariadicOpPayload(Func, Args));
 }
 
-llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
-  return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
+bool VariantMatcher::getSingleMatcher(const DynTypedMatcher *&Out) const {
+  if (Value) return Value->getSingleMatcher(Out);
+  return false;
 }
 
 void VariantMatcher::reset() { Value.reset(); }