Remove TypedMatcherOps from VariantValue

[steveire]

Summary

It provides no features or advantage over ASTNodeKind-based handling.

[aaron.ballman]

I did some digging to see why this was added in the first place and it came with the original commit of AST matchers. Thank you for the cleanup, LGTM!

clang/include/clang/ASTMatchers/Dynamic/VariantValue.h

class VariantMatcher {
   public:
     MatcherOps(ASTNodeKind NodeKind) : NodeKind(NodeKind) {}
 
     bool canConstructFrom(const DynTypedMatcher &Matcher,
                           bool &IsExactMatch) const;
 
     /// Convert \p Matcher the destination type and return it as a new
     /// DynTypedMatcher.
-    virtual DynTypedMatcher
-    convertMatcher(const DynTypedMatcher &Matcher) const = 0;
+    DynTypedMatcher convertMatcher(const DynTypedMatcher &Matcher) const;
 
     /// Constructs a variadic typed matcher from \p InnerMatchers.
     /// Will try to convert each inner matcher to the destination type and
     /// return llvm::None if it fails to do so.
     llvm::Optional<DynTypedMatcher>
     constructVariadicOperator(DynTypedMatcher::VariadicOperator Op,
                               ArrayRef<VariantMatcher> InnerMatchers) const;
 
-  protected:
-    ~MatcherOps() = default;
-
   private:
     ASTNodeKind NodeKind;
   };
 
   /// Payload interface to be specialized by each matcher type.
   ///
   /// It follows a similar interface as VariantMatcher itself.
   class Payload {
public:
   ///
   /// For the Single case, it returns true if it can be converted to
   /// \c Matcher<T>.
   /// For the Polymorphic case, it returns true if one, and only one, of the
   /// overloads can be converted to \c Matcher<T>. If there are more than one
   /// that can, the result would be ambiguous and false is returned.
   template <class T>
   bool hasTypedMatcher() const {
+    return hasTypedMatcher(ASTNodeKind::getFromNodeKind<T>());
+  }
+
+  bool hasTypedMatcher(ASTNodeKind NK) const {
     if (!Value) return false;
-    return Value->getTypedMatcher(TypedMatcherOps<T>()).hasValue();
+    return Value->getTypedMatcher(MatcherOps(NK)).hasValue();
   }
 
   /// Determines if the contained matcher can be converted to \p Kind.
   ///
   /// \param Kind the requested destination type.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   conversion.
   bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const {
     if (Value)
       return Value->isConvertibleTo(Kind, Specificity);
     return false;
   }
 
   /// Return this matcher as a \c Matcher<T>.
   ///
   /// Handles the different types (Single, Polymorphic) accordingly.
   /// Asserts that \c hasTypedMatcher<T>() is true.
   template <class T>
   ast_matchers::internal::Matcher<T> getTypedMatcher() const {
     assert(hasTypedMatcher<T>() && "hasTypedMatcher<T>() == false");
-    return Value->getTypedMatcher(TypedMatcherOps<T>())
+    return Value->getTypedMatcher(MatcherOps(ASTNodeKind::getFromNodeKind<T>()))
         ->template convertTo<T>();
   }
 
+  DynTypedMatcher getTypedMatcher(ASTNodeKind NK) const {
+    assert(hasTypedMatcher(NK) && "hasTypedMatcher(NK) == false");
+    return *Value->getTypedMatcher(MatcherOps(NK));
+  }
+
   /// String representation of the type of the value.
   ///
   /// If the underlying matcher is a polymorphic one, the string will show all
   /// the types.
   std::string getTypeAsString() const;
 
 private:
   explicit VariantMatcher(std::shared_ptr<Payload> Value)
       : Value(std::move(Value)) {}
 
-  template <typename T> struct TypedMatcherOps;
 
   class SinglePayload;
   class PolymorphicPayload;
   class VariadicOpPayload;
 
   std::shared_ptr<const Payload> Value;
 };
 
-template <typename T>
-struct VariantMatcher::TypedMatcherOps final : VariantMatcher::MatcherOps {
-  TypedMatcherOps() : MatcherOps(ASTNodeKind::getFromNodeKind<T>()) {}
-  typedef ast_matchers::internal::Matcher<T> MatcherT;
-
-  DynTypedMatcher
-  convertMatcher(const DynTypedMatcher &Matcher) const override {
-    return DynTypedMatcher(Matcher.convertTo<T>());
-  }
-};
-
 /// Variant value class.
 ///
 /// Basically, a tagged union with value type semantics.
 /// It is used by the registry as the return value and argument type for the
 /// matcher factory methods.
 /// It can be constructed from any of the supported types. It supports
 /// copy/assignment.
 ///

clang/lib/ASTMatchers/Dynamic/VariantValue.cpp

 
 bool
 VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
                                              bool &IsExactMatch) const {
   IsExactMatch = Matcher.getSupportedKind().isSame(NodeKind);
   return Matcher.canConvertTo(NodeKind);
 }
 
+DynTypedMatcher VariantMatcher::MatcherOps::convertMatcher(
+    const DynTypedMatcher &Matcher) const {
+  return Matcher.dynCastTo(NodeKind);
+}
+
 llvm::Optional<DynTypedMatcher>
 VariantMatcher::MatcherOps::constructVariadicOperator(
     DynTypedMatcher::VariadicOperator Op,
     ArrayRef<VariantMatcher> InnerMatchers) const {
   std::vector<DynTypedMatcher> DynMatchers;
   for (const auto &InnerMatcher : InnerMatchers) {
     // Abort if any of the inner matchers can't be converted to
     // Matcher<T>.