4 files changed, 41 insertions, 52 deletions

diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.h b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
index 0df9c8cd60d..ae0c300d094 100644
--- a/clang/lib/ASTMatchers/Dynamic/Marshallers.h
+++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
@@ -167,15 +167,13 @@ private:
 /// out of the polymorphic object.
 template <class PolyMatcher>
 static void mergePolyMatchers(const PolyMatcher &Poly,
-                              std::vector<const DynTypedMatcher *> &Out,
+                              std::vector<DynTypedMatcher> &Out,
                               ast_matchers::internal::EmptyTypeList) {}
 
 template <class PolyMatcher, class TypeList>
 static void mergePolyMatchers(const PolyMatcher &Poly,
-                              std::vector<const DynTypedMatcher *> &Out,
-                              TypeList) {
-  Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly)
-                    .clone());
+                              std::vector<DynTypedMatcher> &Out, TypeList) {
+  Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
   mergePolyMatchers(Poly, Out, typename TypeList::tail());
 }
 
@@ -193,10 +191,9 @@ template <typename T>
 static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
                                                typename T::ReturnTypes * =
                                                    NULL) {
-  std::vector<const DynTypedMatcher *> Matchers;
+  std::vector<DynTypedMatcher> Matchers;
   mergePolyMatchers(PolyMatcher, Matchers, typename T::ReturnTypes());
   VariantMatcher Out = VariantMatcher::PolymorphicMatcher(Matchers);
-  llvm::DeleteContainerPointers(Matchers);
   return Out;
 }
 
diff --git a/clang/lib/ASTMatchers/Dynamic/Parser.cpp b/clang/lib/ASTMatchers/Dynamic/Parser.cpp
index 37e6c10478c..df9596e9b93 100644
--- a/clang/lib/ASTMatchers/Dynamic/Parser.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Parser.cpp
@@ -390,29 +390,29 @@ bool Parser::parseExpression(StringRef Code, Sema *S,
   return true;
 }
 
-DynTypedMatcher *Parser::parseMatcherExpression(StringRef Code,
-                                                Diagnostics *Error) {
+llvm::Optional<DynTypedMatcher>
+Parser::parseMatcherExpression(StringRef Code, Diagnostics *Error) {
   RegistrySema S;
   return parseMatcherExpression(Code, &S, Error);
 }
 
-DynTypedMatcher *Parser::parseMatcherExpression(StringRef Code,
-                                                Parser::Sema *S,
-                                                Diagnostics *Error) {
+llvm::Optional<DynTypedMatcher>
+Parser::parseMatcherExpression(StringRef Code, Parser::Sema *S,
+                               Diagnostics *Error) {
   VariantValue Value;
   if (!parseExpression(Code, S, &Value, Error))
-    return NULL;
+    return llvm::Optional<DynTypedMatcher>();
   if (!Value.isMatcher()) {
     Error->addError(SourceRange(), Error->ET_ParserNotAMatcher);
-    return NULL;
+    return llvm::Optional<DynTypedMatcher>();
   }
-  const DynTypedMatcher *Result;
-  if (!Value.getMatcher().getSingleMatcher(Result)) {
+  llvm::Optional<DynTypedMatcher> Result =
+      Value.getMatcher().getSingleMatcher();
+  if (!Result.hasValue()) {
     Error->addError(SourceRange(), Error->ET_ParserOverloadedType)
         << Value.getTypeAsString();
-    return NULL;
   }
-  return Result->clone();
+  return Result;
 }
 
 }  // namespace dynamic
diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
index 3f8e7d4cd9d..3a17038d985 100644
--- a/clang/lib/ASTMatchers/Dynamic/Registry.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
@@ -329,10 +329,10 @@ VariantMatcher Registry::constructBoundMatcher(StringRef MatcherName,
   VariantMatcher Out = constructMatcher(MatcherName, NameRange, Args, Error);
   if (Out.isNull()) return Out;
 
-  const DynTypedMatcher *Result;
-  if (Out.getSingleMatcher(Result)) {
-    OwningPtr<DynTypedMatcher> Bound(Result->tryBind(BindID));
-    if (Bound) {
+  llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
+  if (Result.hasValue()) {
+    llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
+    if (Bound.hasValue()) {
       return VariantMatcher::SingleMatcher(*Bound);
     }
   }
diff --git a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
index c350d78aa14..3e49e1b8ef0 100644
--- a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
@@ -26,44 +26,37 @@ VariantMatcher::Payload::~Payload() {}
 
 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
 public:
-  SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher.clone()) {}
+  SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
 
-  virtual bool getSingleMatcher(const DynTypedMatcher *&Out) const {
-    Out = Matcher.get();
-    return true;
+  virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const {
+    return Matcher;
   }
 
   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:
-  OwningPtr<const DynTypedMatcher> Matcher;
+  const DynTypedMatcher Matcher;
 };
 
 class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload {
 public:
-  PolymorphicPayload(ArrayRef<const DynTypedMatcher *> MatchersIn) {
-    for (size_t i = 0, e = MatchersIn.size(); i != e; ++i) {
-      Matchers.push_back(MatchersIn[i]->clone());
-    }
-  }
+  PolymorphicPayload(ArrayRef<DynTypedMatcher> MatchersIn)
+      : Matchers(MatchersIn) {}
 
-  virtual ~PolymorphicPayload() {
-    llvm::DeleteContainerPointers(Matchers);
-  }
+  virtual ~PolymorphicPayload() {}
 
-  virtual bool getSingleMatcher(const DynTypedMatcher *&Out) const {
+  virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const {
     if (Matchers.size() != 1)
-      return false;
-    Out = Matchers[0];
-    return true;
+      return llvm::Optional<DynTypedMatcher>();
+    return Matchers[0];
   }
 
   virtual std::string getTypeAsString() const {
@@ -71,7 +64,7 @@ public:
     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();
   }
@@ -79,17 +72,17 @@ public:
   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);
   }
 
-  std::vector<const DynTypedMatcher *> Matchers;
+  const std::vector<DynTypedMatcher> Matchers;
 };
 
 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
@@ -98,8 +91,8 @@ public:
                     ArrayRef<VariantMatcher> Args)
       : Func(Func), Args(Args) {}
 
-  virtual bool getSingleMatcher(const DynTypedMatcher *&Out) const {
-    return false;
+  virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const {
+    return llvm::Optional<DynTypedMatcher>();
   }
 
   virtual std::string getTypeAsString() const {
@@ -128,7 +121,7 @@ VariantMatcher VariantMatcher::SingleMatcher(const DynTypedMatcher &Matcher) {
 }
 
 VariantMatcher
-VariantMatcher::PolymorphicMatcher(ArrayRef<const DynTypedMatcher *> Matchers) {
+VariantMatcher::PolymorphicMatcher(ArrayRef<DynTypedMatcher> Matchers) {
   return VariantMatcher(new PolymorphicPayload(Matchers));
 }
 
@@ -138,9 +131,8 @@ VariantMatcher VariantMatcher::VariadicOperatorMatcher(
   return VariantMatcher(new VariadicOpPayload(Func, Args));
 }
 
-bool VariantMatcher::getSingleMatcher(const DynTypedMatcher *&Out) const {
-  if (Value) return Value->getSingleMatcher(Out);
-  return false;
+llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
+  return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
 }
 
 void VariantMatcher::reset() { Value.reset(); }