[AST] Move operations enum to a definition file.

[etienneb]

Summary

This patch moves the enum definitions to a definition (.def) file.

These modifications provide way to list enumerators of a given type.

As an example, this allow parsing of "kinds" in the dynamic matchers.
see: http://reviews.llvm.org/D19871
The dynamic matcher "ofKind" also required this patch to be fixed.

[etienneb]

rebase over AST modifications

[etienneb]

remove incorrect patch upload (sorry)

[aaron.ballman]

Generally, I think this looks good. It will definitely help with AST matchers. Richard, do you have any problems with this approach?

include/clang/AST/OperationKinds.def

15 ↗

(On Diff #57045)

Do we use @file doxygen comments usually? I'm not certain if I've never seen them, or if I'm just unobservant.

[etienneb]

include/clang/AST/OperationKinds.def

15 ↗

(On Diff #57045)

I can't tell if it's largely used.

I based my modifications on 'include/clang/Basic/OperatorKinds.def'

https://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/OperatorKinds.def

And there are doxygen comments.

[rsmith]

In D20207#428486, @aaron.ballman wrote:

Generally, I think this looks good. It will definitely help with AST matchers. Richard, do you have any problems with this approach?

Not at all. This would be a nice improvement even if it didn't also provide value to the dynamic matchers.

include/clang/ASTMatchers/ASTMatchers.h

AST_POLYMORPHIC_MATCHER_P(hasSourceExpression,
                                                           OpaqueValueExpr),
                           internal::Matcher<Expr>, InnerMatcher) {
   const Expr *const SubExpression =
       internal::GetSourceExpressionMatcher<NodeType>::get(Node);
   return (SubExpression != nullptr &&
           InnerMatcher.matches(*SubExpression, Finder, Builder));
 }
 
+/// \brief Matches casts that has a given cast kind.
+///
+/// Example: matches the implicit cast around \c 0
+/// (matcher = castExpr(hasCastKind(CK_NullToPointer)))
+/// \code
+///   int *p = 0;
+/// \endcode
+AST_MATCHER_P(CastExpr, hasCastKind, CastKind, Kind) {
+  return Node.getCastKind() == Kind;
+}
+
 /// \brief Matches casts whose destination type matches a given matcher.
 ///
 /// (Note: Clang's AST refers to other conversions as "casts" too, and calls
 /// actual casts "explicit" casts.)
 AST_MATCHER_P(ExplicitCastExpr, hasDestinationType,
               internal::Matcher<QualType>, InnerMatcher) {
   const QualType NodeType = Node.getTypeAsWritten();
   return InnerMatcher.matches(NodeType, Finder, Builder);

lib/ASTMatchers/Dynamic/Marshallers.h

public:
   static attr::Kind get(const VariantValue &Value) {
     return getAttrKind(Value.getString());
   }
   static ArgKind getKind() {
     return ArgKind(ArgKind::AK_String);
   }
 };
 
+template <> struct ArgTypeTraits<clang::CastKind> {
+private:
+  static clang::CastKind getCastKind(llvm::StringRef AttrKind) {
+    return llvm::StringSwitch<clang::CastKind>(AttrKind)
+#define CAST_OPERATION(Name) .Case( #Name, CK_##Name)
+#include "clang/AST/OperationKinds.def"
+        .Default(CK_Invalid);
+  }
+
+public:
+  static bool is(const VariantValue &Value) {
+    return Value.isString() &&  
+      getCastKind(Value.getString()) != CK_Invalid;
+  }
+  static clang::CastKind get(const VariantValue &Value) {
+    return getCastKind(Value.getString());
+  }
+  static ArgKind getKind() {
+    return ArgKind(ArgKind::AK_String);
+  }
+};
+
 /// \brief Matcher descriptor interface.
 ///
 /// Provides a \c create() method that constructs the matcher from the provided
 /// arguments, and various other methods for type introspection.
 class MatcherDescriptor {
 public:
   virtual ~MatcherDescriptor() {}
   virtual VariantMatcher create(SourceRange NameRange,

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasArgument);
   REGISTER_MATCHER(hasArgumentOfType);
   REGISTER_MATCHER(hasAttr);
   REGISTER_MATCHER(hasAutomaticStorageDuration);
   REGISTER_MATCHER(hasBase);
   REGISTER_MATCHER(hasBody);
   REGISTER_MATCHER(hasCanonicalType);
   REGISTER_MATCHER(hasCaseConstant);
+  REGISTER_MATCHER(hasCastKind);
   REGISTER_MATCHER(hasCondition);
   REGISTER_MATCHER(hasConditionVariableStatement);
   REGISTER_MATCHER(hasDecayedType);
   REGISTER_MATCHER(hasDeclaration);
   REGISTER_MATCHER(hasDeclContext);
   REGISTER_MATCHER(hasDeducedType);
   REGISTER_MATCHER(hasDescendant);
   REGISTER_MATCHER(hasDestinationType);

unittests/ASTMatchers/ASTMatchersTest.cpp

 
 TEST(CastExpression, DoesNotMatchNonCasts) {
   EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
   EXPECT_TRUE(notMatches("char c, &q = c;", castExpr()));
   EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
   EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
 }
 
+TEST(CastExpression, HasCastKind) {
+  EXPECT_TRUE(matches("char *p = 0;",
+              castExpr(hasCastKind(CK_NullToPointer))));
+  EXPECT_TRUE(notMatches("char *p = 0;",
+              castExpr(hasCastKind(CK_DerivedToBase))));
+}
+
 TEST(ReinterpretCast, MatchesSimpleCase) {
   EXPECT_TRUE(matches("char* p = reinterpret_cast<char*>(&p);",
                       cxxReinterpretCastExpr()));
 }
 
 TEST(ReinterpretCast, DoesNotMatchOtherCasts) {
   EXPECT_TRUE(notMatches("char* p = (char*)(&p);", cxxReinterpretCastExpr()));
   EXPECT_TRUE(notMatches("char q, *p = const_cast<char*>(&q);",