Make it possible to store a ASTNodeKind in VariantValue

[aaron.ballman]

I assume the test coverage for this change is from existing tests that are being updated as part of another patch? Or is there test coverage missing for this change?

[steveire]

Update

[aaron.ballman]

LGTM!

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

public:
   ~VariantValue();
   VariantValue &operator=(const VariantValue &Other);
 
   /// Specific constructors for each supported type.
   VariantValue(bool Boolean);
   VariantValue(double Double);
   VariantValue(unsigned Unsigned);
   VariantValue(StringRef String);
+  VariantValue(ASTNodeKind NodeKind);
   VariantValue(const VariantMatcher &Matchers);
 
   /// Constructs an \c unsigned value (disambiguation from bool).
   VariantValue(int Signed) : VariantValue(static_cast<unsigned>(Signed)) {}
 
   /// Returns true iff this is not an empty value.
   explicit operator bool() const { return hasValue(); }
   bool hasValue() const { return Type != VT_Nothing; }
public:
   unsigned getUnsigned() const;
   void setUnsigned(unsigned Unsigned);
 
   /// String value functions.
   bool isString() const;
   const std::string &getString() const;
   void setString(StringRef String);
 
+  bool isNodeKind() const;
+  const ASTNodeKind &getNodeKind() const;
+  void setNodeKind(ASTNodeKind NodeKind);
+
   /// Matcher value functions.
   bool isMatcher() const;
   const VariantMatcher &getMatcher() const;
   void setMatcher(const VariantMatcher &Matcher);
 
   /// Determines if the contained value can be converted to \p Kind.
   ///
   /// \param Kind the requested destination type.
private:
 
   /// All supported value types.
   enum ValueType {
     VT_Nothing,
     VT_Boolean,
     VT_Double,
     VT_Unsigned,
     VT_String,
-    VT_Matcher
+    VT_Matcher,
+    VT_NodeKind
   };
 
   /// All supported value types.
   union AllValues {
     unsigned Unsigned;
     double Double;
     bool Boolean;
     std::string *String;
     VariantMatcher *Matcher;
+    ASTNodeKind *NodeKind;
   };
 
   ValueType Type;
   AllValues Value;
 };
 
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif  // LLVM_CLANG_AST_MATCHERS_DYNAMIC_VARIANT_VALUE_H

clang/lib/ASTMatchers/Dynamic/VariantValue.cpp

 VariantValue::VariantValue(unsigned Unsigned) : Type(VT_Nothing) {
   setUnsigned(Unsigned);
 }
 
 VariantValue::VariantValue(StringRef String) : Type(VT_Nothing) {
   setString(String);
 }
 
+VariantValue::VariantValue(ASTNodeKind NodeKind) : Type(VT_Nothing) {
+  setNodeKind(NodeKind);
+}
+
 VariantValue::VariantValue(const VariantMatcher &Matcher) : Type(VT_Nothing) {
   setMatcher(Matcher);
 }
 
 VariantValue::~VariantValue() { reset(); }
 
 VariantValue &VariantValue::operator=(const VariantValue &Other) {
   if (this == &Other) return *this;
   reset();
   switch (Other.Type) {
   case VT_Boolean:
     setBoolean(Other.getBoolean());
     break;
   case VT_Double:
     setDouble(Other.getDouble());
     break;
   case VT_Unsigned:
     setUnsigned(Other.getUnsigned());
     break;
   case VT_String:
     setString(Other.getString());
     break;
+  case VT_NodeKind:
+    setNodeKind(Other.getNodeKind());
+    break;
   case VT_Matcher:
     setMatcher(Other.getMatcher());
     break;
   case VT_Nothing:
     Type = VT_Nothing;
     break;
   }
   return *this;
 }
 
 void VariantValue::reset() {
   switch (Type) {
   case VT_String:
     delete Value.String;
     break;
   case VT_Matcher:
     delete Value.Matcher;
     break;
+  case VT_NodeKind:
+    delete Value.NodeKind;
+    break;
   // Cases that do nothing.
   case VT_Boolean:
   case VT_Double:
   case VT_Unsigned:
   case VT_Nothing:
     break;
   }
   Type = VT_Nothing;

 }
 
 void VariantValue::setString(StringRef NewValue) {
   reset();
   Type = VT_String;
   Value.String = new std::string(NewValue);
 }
 
+bool VariantValue::isNodeKind() const { return Type == VT_NodeKind; }
+
+const ASTNodeKind &VariantValue::getNodeKind() const {
+  assert(isNodeKind());
+  return *Value.NodeKind;
+}
+
+void VariantValue::setNodeKind(ASTNodeKind NewValue) {
+  reset();
+  Type = VT_NodeKind;
+  Value.NodeKind = new ASTNodeKind(NewValue);
+}
+
 bool VariantValue::isMatcher() const {
   return Type == VT_Matcher;
 }
 
 const VariantMatcher &VariantValue::getMatcher() const {
   assert(isMatcher());
   return *Value.Matcher;
 }

 
 std::string VariantValue::getTypeAsString() const {
   switch (Type) {
   case VT_String: return "String";
   case VT_Matcher: return getMatcher().getTypeAsString();
   case VT_Boolean: return "Boolean";
   case VT_Double: return "Double";
   case VT_Unsigned: return "Unsigned";
+  case VT_NodeKind:
+    return getNodeKind().asStringRef().str();
   case VT_Nothing: return "Nothing";
   }
   llvm_unreachable("Invalid Type");
 }
 
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang

clang/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp

EXPECT_FALSE(matches(
                     .getTypedMatcher<Decl>()));
   EXPECT_FALSE(
       matches("int foo() { return 1 + 1; }",
               VariantValue(VariantMatcher::SingleMatcher(declRefExpr()))
                   .getMatcher()
                   .getTypedMatcher<Stmt>()));
 }
 
+TEST(VariantValueTest, NodeKind) {
+  VariantValue Value = ASTNodeKind::getFromNodeKind<Stmt>();
+  EXPECT_TRUE(Value.isNodeKind());
+  EXPECT_TRUE(Value.getNodeKind().isSame(ASTNodeKind::getFromNodeKind<Stmt>()));
+
+  Value = ASTNodeKind::getFromNodeKind<CXXMethodDecl>();
+  EXPECT_TRUE(Value.isNodeKind());
+  EXPECT_TRUE(Value.getNodeKind().isSame(
+      ASTNodeKind::getFromNodeKind<CXXMethodDecl>()));
+
+  Value.setNodeKind(ASTNodeKind::getFromNodeKind<PointerType>());
+  EXPECT_TRUE(Value.isNodeKind());
+  EXPECT_TRUE(
+      Value.getNodeKind().isSame(ASTNodeKind::getFromNodeKind<PointerType>()));
+
+  Value = 42;
+  EXPECT_TRUE(!Value.isNodeKind());
+}
+
 } // end anonymous namespace
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang