[mlir:PDL] Expand how native constraint/rewrite functions can be defined

This commit refactors the expected form of native constraint and rewrite
functions, and greatly reduces the necessary user complexity required when
defining a native function. Namely, this commit adds in automatic processing
of the necessary PDLValue glue code, and allows for users to define
constraint/rewrite functions using the C++ types that they actually want to
use.

As an example, lets see a simple example rewrite defined today:

```
static void rewriteFn(PatternRewriter &rewriter, PDLResultList &results,
                      ArrayRef<PDLValue> args) {
  ValueRange operandValues = args[0].cast<ValueRange>();
  TypeRange typeValues = args[1].cast<TypeRange>();
  ...
  // Create an operation at some point and pass it back to PDL.
  Operation *op = rewriter.create<SomeOp>(...);
  results.push_back(op);
}
```

After this commit, that same rewrite could be defined as:

```
static Operation *rewriteFn(PatternRewriter &rewriter ValueRange operandValues,
                            TypeRange typeValues) {
  ...
  // Create an operation at some point and pass it back to PDL.
  return rewriter.create<SomeOp>(...);
}
```

Differential Revision: https://reviews.llvm.org/D122086

Author: River707

llvm/include/llvm/ADT/STLExtras.h

@@ -129,7 +129,7 @@ struct function_traits<ReturnType (ClassType::*)(Args...) const, false> {
 /// Overload for class function types.
 template <typename ClassType, typename ReturnType, typename... Args>
 struct function_traits<ReturnType (ClassType::*)(Args...), false>
-    : function_traits<ReturnType (ClassType::*)(Args...) const> {};
+    : public function_traits<ReturnType (ClassType::*)(Args...) const> {};
 /// Overload for non-class function types.
 template <typename ReturnType, typename... Args>
 struct function_traits<ReturnType (*)(Args...), false> {
@@ -143,6 +143,9 @@ struct function_traits<ReturnType (*)(Args...), false> {
   template <size_t i>
   using arg_t = typename std::tuple_element<i, std::tuple<Args...>>::type;
 };
+template <typename ReturnType, typename... Args>
+struct function_traits<ReturnType (*const)(Args...), false>
+    : public function_traits<ReturnType (*)(Args...)> {};
 /// Overload for non-class function type references.
 template <typename ReturnType, typename... Args>
 struct function_traits<ReturnType (&)(Args...), false>

mlir/docs/PDLL.md

@@ -1006,17 +1006,11 @@ External constraints are those registered explicitly with the `RewritePatternSet
 the C++ PDL API. For example, the constraints above may be registered as:
 
 ```c++
-// TODO: Cleanup when we allow more accessible wrappers around PDL functions.
-static LogicalResult hasOneUseImpl(PDLValue pdlValue, PatternRewriter &rewriter) {
-  Value value = pdlValue.cast<Value>();
-  
+static LogicalResult hasOneUseImpl(PatternRewriter &rewriter, Value value) {
   return success(value.hasOneUse());
 }
-static LogicalResult hasSameElementTypeImpl(ArrayRef<PDLValue> pdlValues,
-                                            PatternRewriter &rewriter) {
-  Value value1 = pdlValues[0].cast<Value>();
-  Value value2 = pdlValues[1].cast<Value>();
-      
+static LogicalResult hasSameElementTypeImpl(PatternRewriter &rewriter,
+                                            Value value1, Value Value2) {
   return success(value1.getType().cast<ShapedType>().getElementType() ==
                  value2.getType().cast<ShapedType>().getElementType());
 }
@@ -1307,14 +1301,10 @@ External rewrites are those registered explicitly with the `RewritePatternSet` v
 the C++ PDL API. For example, the rewrite above may be registered as:
 
 ```c++
-// TODO: Cleanup when we allow more accessible wrappers around PDL functions.
-static void buildOpImpl(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
-                        PDLResultList &results) {
-  Value value = args[0].cast<Value>();
-
+static Operation *buildOpImpl(PDLResultList &results, Value value) {
   // insert special rewrite logic here.
   Operation *resultOp = ...; 
-  results.push_back(resultOp);
+  return resultOp;
 }
 
 void registerNativeRewrite(RewritePatternSet &patterns) {

mlir/include/mlir/Dialect/PDL/IR/PDLOps.td

@@ -68,18 +68,14 @@ def PDL_ApplyNativeRewriteOp
 
     ```mlir
     // Apply a native rewrite method that returns an attribute.
-    %ret = pdl.apply_native_rewrite "myNativeFunc"(%arg0, %arg1) : !pdl.attribute
+    %ret = pdl.apply_native_rewrite "myNativeFunc"(%arg0, %attr1) : !pdl.attribute
     ```
 
     ```c++
     // The native rewrite as defined in C++:
-    static void myNativeFunc(ArrayRef<PDLValue> args, PatternRewriter &rewriter,
-                             PDLResultList &results) {
-      Value arg0 = args[0].cast<Value>();
-      Value arg1 = args[1].cast<Value>();
-
-      // Just push back the first param attribute.
-      results.push_back(param0);
+    static Attribute myNativeFunc(PatternRewriter &rewriter, Value arg0, Attribute arg1) {
+      // Just return the second arg.
+      return arg1;
     }
 
     void registerNativeRewrite(PDLPatternModule &pdlModule) {

mlir/include/mlir/IR/Builders.h

@@ -409,7 +409,8 @@ class OpBuilder : public Builder {
 
   /// Creates an operation with the given fields.
   Operation *create(Location loc, StringAttr opName, ValueRange operands,
-                    TypeRange types, ArrayRef<NamedAttribute> attributes = {},
+                    TypeRange types = {},
+                    ArrayRef<NamedAttribute> attributes = {},
                     BlockRange successors = {},
                     MutableArrayRef<std::unique_ptr<Region>> regions = {});