[ASTMatchers] Add support for dynamic matching of ofKind narrowing matcher

[njames93]

Summary

Adds support for using the ofKind in clang-query and other dynamic matcher use cases

[aaron.ballman]

Thank you for this! It basically LG, but can you also add a dynamic matcher unit test for this functionality?

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

102–106

Did clang-format produce this formatting?

107

Elide braces

clang/lib/ASTMatchers/Dynamic/Marshallers.h

222

Typetraits - > Type traits
Also, missing a full stop at the end of the comment.

[njames93]

Added test cases and address nits

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

102–106

when I ran git-clang-format I dont think it did, but when i went to upload the patch i got this in the pre-upload linting

--- /home/nathan/src/llvm-project/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp 2020-04-09 12:12:28.810339833 +0100
+++ /tmp/6p7zxlltj4g8wgcc/9888-onMes8   2020-04-09 12:44:11.187257096 +0100
@@ -99,11 +99,11 @@
 llvm::Optional<std::string>
 clang::ast_matchers::dynamic::internal::ArgTypeTraits<
     clang::UnaryExprOrTypeTrait>::getBestGuess(const VariantValue &Value) {
-  static constexpr llvm::StringRef Allowed[] = {"UETT_SizeOf",
-                                                "UETT_AlignOf",
-                                                "UETT_VecStep",
-                                                "UETT_OpenMPRequiredSimdAlign",
-                                                "UETT_PreferredAlignOf",};
+  static constexpr llvm::StringRef Allowed[] = {
+      "UETT_SizeOf",           "UETT_AlignOf",
+      "UETT_VecStep",          "UETT_OpenMPRequiredSimdAlign",
+      "UETT_PreferredAlignOf",
+  };

[aaron.ballman]

LGTM, thank you!

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

102–106

I think the pre-upload linting is wrong (I can't find many instances of lists that look like that in LLVM anyway, but I know of plenty of instances of the other style). Not a huge deal though.

[njames93]

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

102–106

I tried to manually invoke clang-format on it (using trunk) and it suggested the same format

clang/lib/ASTMatchers/Dynamic/Marshallers.h

 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "clang/ASTMatchers/Dynamic/Diagnostics.h"
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "clang/Basic/AttrKinds.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/OpenMPKinds.h"
+#include "clang/Basic/TypeTraits.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Twine.h"
 #include <cassert>
static OpenMPClauseKind get(const VariantValue &Value) {
     return *getClauseKind(Value.getString());
   }
 
   static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
 
   static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
 };
 
+template <> struct ArgTypeTraits<UnaryExprOrTypeTrait> {
+private:
+  static Optional<UnaryExprOrTypeTrait>
+  getUnaryOrTypeTraitKind(llvm::StringRef ClauseKind) {
+    // FIXME: Type traits should probably be in a `.def` to make less error
+    // prone.
+    return llvm::StringSwitch<Optional<UnaryExprOrTypeTrait>>(ClauseKind)
+        .Case("UETT_SizeOf", UETT_SizeOf)
+        .Case("UETT_AlignOf", UETT_AlignOf)
+        .Case("UETT_VecStep", UETT_VecStep)
+        .Case("UETT_OpenMPRequiredSimdAlign", UETT_OpenMPRequiredSimdAlign)
+        .Case("UETT_PreferredAlignOf", UETT_PreferredAlignOf)
+        .Default(llvm::None);
+  }
+
+public:
+  static bool is(const VariantValue &Value) {
+    return Value.isString() && getUnaryOrTypeTraitKind(Value.getString());
+  }
+
+  static UnaryExprOrTypeTrait get(const VariantValue &Value) {
+    return *getUnaryOrTypeTraitKind(Value.getString());
+  }
+
+  static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
+
+  static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
+};
+
 /// 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() = default;
 

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

 #define OMP_CLAUSE_CLASS(Enum, Str, Class) #Enum,
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
   };
   if (Value.isString())
     return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
                           "OMPC_");
   return llvm::None;
 }
+
+llvm::Optional<std::string>
+clang::ast_matchers::dynamic::internal::ArgTypeTraits<
+    clang::UnaryExprOrTypeTrait>::getBestGuess(const VariantValue &Value) {
+  static constexpr llvm::StringRef Allowed[] = {
+      "UETT_SizeOf",           "UETT_AlignOf",
+      "UETT_VecStep",          "UETT_OpenMPRequiredSimdAlign",
+      "UETT_PreferredAlignOf",
+  };
+  if (Value.isString())
+    return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
+                          "UETT_");
+  return llvm::None;
+}

clang/lib/ASTMatchers/Dynamic/Registry.cpp

do {                                                                         \
     REGISTER_MATCHER_OVERLOAD(name);                                           \
   } while (false)
 
 /// Generate a registry map with all the known matchers.
 /// Please keep sorted alphabetically!
 RegistryMaps::RegistryMaps() {
   // TODO: Here is the list of the missing matchers, grouped by reason.
   //
-  // Need Variant/Parser fixes:
-  // ofKind
-  //
   // Polymorphic + argument overload:
   // findAll
   //
   // Other:
   // equalsNode
 
   REGISTER_OVERLOADED_2(callee);
   REGISTER_OVERLOADED_2(hasAnyCapture);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(objcMessageExpr);
   REGISTER_MATCHER(objcMethodDecl);
   REGISTER_MATCHER(objcObjectPointerType);
   REGISTER_MATCHER(objcPropertyDecl);
   REGISTER_MATCHER(objcProtocolDecl);
   REGISTER_MATCHER(objcThrowStmt);
   REGISTER_MATCHER(objcTryStmt);
   REGISTER_MATCHER(ofClass);
+  REGISTER_MATCHER(ofKind);
   REGISTER_MATCHER(ompDefaultClause);
   REGISTER_MATCHER(ompExecutableDirective);
   REGISTER_MATCHER(on);
   REGISTER_MATCHER(onImplicitObjectArgument);
   REGISTER_MATCHER(opaqueValueExpr);
   REGISTER_MATCHER(optionally);
   REGISTER_MATCHER(parameterCountIs);
   REGISTER_MATCHER(parenExpr);

clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp

TEST(ParserTest, FullParserTest) {
   llvm::Optional<DynTypedMatcher> HasParameterWithNamedValues(
       Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error));
   EXPECT_EQ("", Error.toStringFull());
   M = HasParameterWithNamedValues->unconditionalConvertTo<Decl>();
 
   EXPECT_TRUE(matches("void f(int a, int x);", M));
   EXPECT_FALSE(matches("void f(int x, int a);", M));
 
+  Code = "unaryExprOrTypeTraitExpr(ofKind(\"UETT_SizeOf\"))";
+  llvm::Optional<DynTypedMatcher> UnaryExprSizeOf(
+      Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error));
+  EXPECT_EQ("", Error.toStringFull());
+  Matcher<Stmt> MStmt = UnaryExprSizeOf->unconditionalConvertTo<Stmt>();
+  EXPECT_TRUE(matches("unsigned X = sizeof(int);", MStmt));
+  EXPECT_FALSE(matches("unsigned X = alignof(int);", MStmt));
+
   Code = "hasInitializer(\n    binaryOperator(hasLHS(\"A\")))";
   EXPECT_TRUE(!Parser::parseMatcherExpression(Code, &Error).hasValue());
   EXPECT_EQ("1:1: Error parsing argument 1 for matcher hasInitializer.\n"
             "2:5: Error parsing argument 1 for matcher binaryOperator.\n"
             "2:20: Error building matcher hasLHS.\n"
             "2:27: Incorrect type for arg 1. "
             "(Expected = Matcher<Expr>) != (Actual = String)",
             Error.toStringFull());