[mlir][PDL] Define a new PDLInterp::FuncOp operation and drop uses of FuncOp

[rriddle]

Summary

Defining our own function operation allows for the PDL interpreter
to be more self contained, and also removes any dependency on FuncOp;
which is moving out of the Builtin dialect.

[mehdi_amini]

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

666

Can you document this builder as creating the entry block.
Also does this remove the default generated builders? I'm concerned we'd have some builders generating a block but not all of them.
Does it really pulls it weight when the client just has to call funcOp.addEntryBlock(); post creation?

672

I think there was a TODO in the review of the FunctionOpInterface to rename this API from getType to getFunctionType?
I'm afraid that if we don't address it now as a preamble to adding more custom FuncOp, we'll never get to it.

677–682

Shouldn't these have a default implementation in the interface trait?

687–690

Isn't this included in the ODS generated verifier? Can you have a test hit this condition?

[mehdi_amini]

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

190–191

Why isn't the trait verifying equality as well? The interface intends to accept a mismatch?

193–201

This block of code will be repeated multiple times I think: could this be refactored as a helper in a central place?

[rriddle]

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

666

Yeah, given that we always want an entry block. These functions don't have an "external" equivalent, so we always have a non-empty region.

Lower down I marked skipDefaultBuilders, so this should be the only builder generated.

672

Do you have a strong preference of doing now or later in the current commit stack? I still need to flip PDL over to use the prefixed accessors.

677–682

No. FunctionOpInterface doesn't assume that you use FunctionType, though we might want to consider a helper trait that stubs everything out for the FunctionType case.

687–690

Good point, removed. This was copy over from FuncOp before I added TypeAttrOf to support providing the concrete type to ODS.

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

190–191

Thanks for pointing this out, I don't understand why it doesn't. Let me just move this to the interface.

[mehdi_amini]

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

666

Ah I missed the skipDefaultBuilders

672

I'm fine if you want to do it later, but this is already a left over todo from the interface creation, so I just wouldn't want it to split through the cracks again and get into limbo.

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterp.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
 #define MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
 
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
+#include "mlir/IR/FunctionInterfaces.h"
+#include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.h.inc"

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

 //===- PDLInterpOps.td - Pattern Interpreter Dialect -------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the PDL interpreter dialect ops.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS
 #define MLIR_DIALECT_PDLINTERP_IR_PDLINTERPOPS
 
 include "mlir/Dialect/PDL/IR/PDLTypes.td"
+include "mlir/IR/FunctionInterfaces.td"
+include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_Dialect : Dialect {
   let summary = "Interpreted pattern execution dialect";
let extraClassDeclaration = [{
     /// Returns the loop variable.
     BlockArgument getLoopVariable() { return region().getArgument(0); }
   }];
   let hasCustomAssemblyFormat = 1;
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
+// pdl_interp::FuncOp
+//===----------------------------------------------------------------------===//
+
+def PDLInterp_FuncOp : PDLInterp_Op<"func", [
+    FunctionOpInterface, IsolatedFromAbove, Symbol
+  ]> {
+  let summary = "PDL Interpreter Function Operation";
+  let description = [{
+    `pdl_interp.func` operations act as interpreter functions. These are
+    callable SSA-region operations that contain other interpreter operations.
+    Interpreter functions are used for both the matching and the rewriting
+    portion of the interpreter.
+
+    Example:
+
+    ```mlir
+    pdl_interp.func @rewriter(%root: !pdl.operation) {
+      %op = pdl_interp.create_operation "foo.new_operation"
+      pdl_interp.erase %root
+      pdl_interp.finalize
+    }
+    ```
+  }];
+
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<FunctionType>:$type
+  );
+  let regions = (region MinSizedRegion<1>:$body);
+
+  // Create the function with the given name and type. This also automatically
+  // inserts the entry block for the function.
+  let builders = [OpBuilder<(ins
+    "StringRef":$name, "FunctionType":$type,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
+  >];
+  let extraClassDeclaration = [{
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    //===------------------------------------------------------------------===//
+    // FunctionOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+  }];
+  let hasCustomAssemblyFormat = 1;
+  let skipDefaultBuilders = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // pdl_interp::GetAttributeOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_GetAttributeOp : PDLInterp_Op<"get_attribute", [NoSideEffect]> {
   let summary = "Get a specified attribute value from an `Operation`";
   let description = [{
     `pdl_interp.get_attribute` operations try to get a specific attribute from
     an operation. If the operation does not have that attribute, a null value is

mlir/include/mlir/IR/BuiltinOps.td

let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
 
     /// Returns the argument types of this function.
     ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); }
 
     /// Returns the result types of this function.
     ArrayRef<Type> getResultTypes() { return getType().getResults(); }
 
-    /// Verify the type attribute of this function. Returns failure and emits
-    /// an error if the attribute is invalid.
-    LogicalResult verifyType() {
-      auto type = getTypeAttr().getValue();
-      if (!type.isa<FunctionType>())
-        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
-                           "' attribute of function type");
-      return success();
-    }
-
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
     bool isDeclaration() { return isExternal(); }
   }];
   let hasCustomAssemblyFormat = 1;
-  let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ModuleOp
 //===----------------------------------------------------------------------===//
 
 def ModuleOp : Builtin_Op<"module", [
     AffineScope, IsolatedFromAbove, NoRegionArguments, SymbolTable, Symbol,

mlir/include/mlir/IR/FunctionImplementation.h

 /// trailing ellipsis in the function signature and indicate to the builder
 /// whether the function is variadic.  If the builder returns a null type,
 /// `result` will not contain the `type` attribute.  The caller can then add a
 /// type, report the error or delegate the reporting to the op's verifier.
 ParseResult parseFunctionOp(OpAsmParser &parser, OperationState &result,
                             bool allowVariadic,
                             FuncTypeBuilder funcTypeBuilder);
 
-/// Printer implementation for function-like operations.  Accepts lists of
-/// argument and result types to use while printing.
-void printFunctionOp(OpAsmPrinter &p, Operation *op, ArrayRef<Type> argTypes,
-                     bool isVariadic, ArrayRef<Type> resultTypes);
+/// Printer implementation for function-like operations.
+void printFunctionOp(OpAsmPrinter &p, FunctionOpInterface op, bool isVariadic);
 
 /// Prints the signature of the function-like operation `op`. Assumes `op` has
 /// is a FunctionOpInterface and has passed verification.
 void printFunctionSignature(OpAsmPrinter &p, Operation *op,
                             ArrayRef<Type> argTypes, bool isVariadic,
                             ArrayRef<Type> resultTypes);
 
 /// Prints the list of function prefixed with the "attributes" keyword. The

mlir/include/mlir/IR/FunctionInterfaces.h

 //===- FunctionSupport.h - Utility types for function-like ops --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines support types for Operations that represent function-like
 // constructs to use.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_FUNCTIONINTERFACES_H
 #define MLIR_IR_FUNCTIONINTERFACES_H
 
+#include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/SymbolTable.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/SmallString.h"
 
 namespace mlir {
 

mlir/include/mlir/IR/FunctionInterfaces.td

"::mlir::Type", "cloneTypeWith", (ins
       "::mlir::TypeRange":$inputs, "::mlir::TypeRange":$results
     ), /*methodBody=*/[{}], /*defaultImplementation=*/[{
       return $_op.getType().clone(inputs, results);
     }]>,
 
     InterfaceMethod<[{
       Verify the contents of the body of this function.
 
-      Note: The default implementation merely checks that of the entry block
-      exists, it has the same number arguments as the function type.
+      Note: The default implementation merely checks that if the entry block
+      exists, it has the same number and type of arguments as the function type.
     }],
     "::mlir::LogicalResult", "verifyBody", (ins),
     /*methodBody=*/[{}], /*defaultImplementation=*/[{
       if ($_op.isExternal())
         return success();
+      ArrayRef<Type> fnInputTypes = $_op.getArgumentTypes();
+      Block &entryBlock = $_op.front();
     
-      unsigned numArguments = $_op.getNumArguments();
-      if ($_op.front().getNumArguments() != numArguments)
+      unsigned numArguments = fnInputTypes.size();
+      if (entryBlock.getNumArguments() != numArguments)
         return $_op.emitOpError("entry block must have ")
               << numArguments << " arguments to match function signature";
+
+      for (unsigned i = 0, e = fnInputTypes.size(); i != e; ++i) {
+        Type argType = entryBlock.getArgument(i).getType();
+        if (fnInputTypes[i] != argType) {
+          return $_op.emitOpError("type of entry block argument #")
+                << i << '(' << argType
+                << ") must match the type of the corresponding argument in "
+                << "function signature(" << fnInputTypes[i] << ')';
+        }
+      }
+
       return success();
     }]>,
     InterfaceMethod<[{
       Verify the type attribute of the function for derived op-specific
       invariants.
     }],
-    "::mlir::LogicalResult", "verifyType">,
+    "::mlir::LogicalResult", "verifyType", (ins),
+    /*methodBody=*/[{}], /*defaultImplementation=*/[{
+      return success();
+    }]>,
   ];
 
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // Name
     //===------------------------------------------------------------------===//
 
     /// Return the name of the function.
     StringRef getName() { return SymbolTable::getSymbolName(*this); }
   }];
+  let extraTraitClassDeclaration = [{
+    //===------------------------------------------------------------------===//
+    // Builders
+    //===------------------------------------------------------------------===//
+
+    /// Build the function with the given name, attributes, and type. This
+    /// builder also inserts an entry block into the function body with the
+    /// given argument types.
+    static void buildWithEntryBlock(
+        OpBuilder &builder, OperationState &state, StringRef name, Type type,
+        ArrayRef<NamedAttribute> attrs, ArrayRef<Type> inputTypes) {
+      state.addAttribute(SymbolTable::getSymbolAttrName(),
+                        builder.getStringAttr(name));
+      state.addAttribute(function_interface_impl::getTypeAttrName(),
+                        TypeAttr::get(type));
+      state.attributes.append(attrs.begin(), attrs.end());
+
+      // Add the function body.
+      Region *bodyRegion = state.addRegion();
+      Block *body = new Block();
+      bodyRegion->push_back(body);
+      for (Type input : inputTypes)
+        body->addArgument(input, state.location);
+    } 
+  }];
   let extraSharedClassDeclaration = [{
     /// Block list iterator types.
     using BlockListType = Region::BlockListType;
     using iterator = BlockListType::iterator;
     using reverse_iterator = BlockListType::reverse_iterator;
 
     /// Block argument iterator types.
     using BlockArgListType = Region::BlockArgListType;

mlir/include/mlir/IR/OpBase.td

 // Any region.
 def AnyRegion : Region<CPred<"true">, "any region">;
 
 // A region with the given number of blocks.
 class SizedRegion<int numBlocks> : Region<
   CPred<"::llvm::hasNItems($_self, " # numBlocks # ")">,
   "region with " # numBlocks # " blocks">;
 
+// A region with at least the given number of blocks.
+class MinSizedRegion<int numBlocks> : Region<
+  CPred<"::llvm::hasNItemsOrMore($_self, " # numBlocks # ")">,
+  "region with at least " # numBlocks # " blocks">;
+
 // A variadic region constraint. It expands to zero or more of the base region.
 class VariadicRegion<Region region>
   : Region<region.predicate, region.summary>;
 
 //===----------------------------------------------------------------------===//
 // Successor definitions
 //===----------------------------------------------------------------------===//
 

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

 // PatternLowering
 //===----------------------------------------------------------------------===//
 
 namespace {
 /// This class generators operations within the PDL Interpreter dialect from a
 /// given module containing PDL pattern operations.
 struct PatternLowering {
 public:
-  PatternLowering(FuncOp matcherFunc, ModuleOp rewriterModule);
+  PatternLowering(pdl_interp::FuncOp matcherFunc, ModuleOp rewriterModule);
 
   /// Generate code for matching and rewriting based on the pattern operations
   /// within the module.
   void lower(ModuleOp module);
 
 private:
   using ValueMap = llvm::ScopedHashTable<Position *, Value>;
   using ValueMapScope = llvm::ScopedHashTableScope<Position *, Value>;
void generateOperationResultTypeRewriter(
       pdl::OperationOp op, SmallVectorImpl<Value> &types,
       DenseMap<Value, Value> &rewriteValues,
       function_ref<Value(Value)> mapRewriteValue);
 
   /// A builder to use when generating interpreter operations.
   OpBuilder builder;
 
   /// The matcher function used for all match related logic within PDL patterns.
-  FuncOp matcherFunc;
+  pdl_interp::FuncOp matcherFunc;
 
   /// The rewriter module containing the all rewrite related logic within PDL
   /// patterns.
   ModuleOp rewriterModule;
 
   /// The symbol table of the rewriter module used for insertion.
   SymbolTable rewriterSymbolTable;
 
private:
   DenseMap<Value, Position *> valueToPosition;
 
   /// The set of operation values whose whose location will be used for newly
   /// generated operations.
   SetVector<Value> locOps;
 };
 } // namespace
 
-PatternLowering::PatternLowering(FuncOp matcherFunc, ModuleOp rewriterModule)
+PatternLowering::PatternLowering(pdl_interp::FuncOp matcherFunc,
+                                 ModuleOp rewriterModule)
     : builder(matcherFunc.getContext()), matcherFunc(matcherFunc),
       rewriterModule(rewriterModule), rewriterSymbolTable(rewriterModule) {}
 
 void PatternLowering::lower(ModuleOp module) {
   PredicateUniquer predicateUniquer;
   PredicateBuilder predicateBuilder(predicateUniquer, module.getContext());
 
   // Define top-level scope for the arguments to the matcher function.
   ValueMapScope topLevelValueScope(values);
 
   // Insert the root operation, i.e. argument to the matcher, at the root
   // position.
-  Block *matcherEntryBlock = matcherFunc.addEntryBlock();
+  Block *matcherEntryBlock = &matcherFunc.front();
   values.insert(predicateBuilder.getRoot(), matcherEntryBlock->getArgument(0));
 
   // Generate a root matcher node from the provided PDL module.
   std::unique_ptr<MatcherNode> root = MatcherNode::generateMatcherTree(
       module, predicateBuilder, valueToPosition);
   Block *firstMatcherBlock = generateMatcher(*root, matcherFunc.getBody());
   assert(failureBlockStack.empty() && "failed to empty the stack");
 
void PatternLowering::generate(SuccessNode *successNode, Block *&currentBlock) {
   builder.create<pdl_interp::RecordMatchOp>(
       pattern.getLoc(), mappedMatchValues, locOps.getArrayRef(),
       rewriterFuncRef, rootKindAttr, generatedOpsAttr, pattern.benefitAttr(),
       failureBlockStack.back());
 }
 
 SymbolRefAttr PatternLowering::generateRewriter(
     pdl::PatternOp pattern, SmallVectorImpl<Position *> &usedMatchValues) {
-  FuncOp rewriterFunc =
-      FuncOp::create(pattern.getLoc(), "pdl_generated_rewriter",
-                     builder.getFunctionType(llvm::None, llvm::None));
+  builder.setInsertionPointToEnd(rewriterModule.getBody());
+  auto rewriterFunc = builder.create<pdl_interp::FuncOp>(
+      pattern.getLoc(), "pdl_generated_rewriter",
   rewriterSymbolTable.insert(rewriterFunc);
 
   // Generate the rewriter function body.
-  builder.setInsertionPointToEnd(rewriterFunc.addEntryBlock());
+  builder.setInsertionPointToEnd(&rewriterFunc.front());
 
   // Map an input operand of the pattern to a generated interpreter value.
   DenseMap<Value, Value> rewriteValues;
   auto mapRewriteValue = [&](Value oldValue) {
     Value &newValue = rewriteValues[oldValue];
     if (newValue)
       return newValue;
 

 /// Convert the given module containing PDL pattern operations into a PDL
 /// Interpreter operations.
 void PDLToPDLInterpPass::runOnOperation() {
   ModuleOp module = getOperation();
 
   // Create the main matcher function This function contains all of the match
   // related functionality from patterns in the module.
   OpBuilder builder = OpBuilder::atBlockBegin(module.getBody());
-  FuncOp matcherFunc = builder.create<FuncOp>(
+  auto matcherFunc = builder.create<pdl_interp::FuncOp>(
       module.getLoc(), pdl_interp::PDLInterpDialect::getMatcherFunctionName(),
       builder.getFunctionType(builder.getType<pdl::OperationType>(),
                               /*results=*/llvm::None),
       /*attrs=*/llvm::None);
 
   // Create a nested module to hold the functions invoked for rewriting the IR
   // after a successful match.
   ModuleOp rewriterModule = builder.create<ModuleOp>(

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
   function_interface_impl::addArgAndResultAttrs(builder, result, argAttrs,
                                                 /*resultAttrs=*/llvm::None);
 }
 
 // Builds an LLVM function type from the given lists of input and output types.
 // Returns a null type if any of the types provided are non-LLVM types, or if
 // there is more than one output type.
 static Type
-buildLLVMFunctionType(OpAsmParser &parser, SMLoc loc,
-                      ArrayRef<Type> inputs, ArrayRef<Type> outputs,
+buildLLVMFunctionType(OpAsmParser &parser, SMLoc loc, ArrayRef<Type> inputs,
+                      ArrayRef<Type> outputs,
                       function_interface_impl::VariadicFlag variadicFlag) {
   Builder &b = parser.getBuilder();
   if (outputs.size() > 1) {
     parser.emitError(loc, "failed to construct function type: expected zero or "
                           "one function result");
     return {};
   }
 
LogicalResult LLVMFuncOp::verify() {
 
   if (isVarArg())
     return emitOpError("only external functions can be variadic");
 
   return success();
 }
 
 /// Verifies LLVM- and implementation-specific properties of the LLVM func Op:
-/// - entry block arguments are of LLVM types and match the function signature.
+/// - entry block arguments are of LLVM types.
 LogicalResult LLVMFuncOp::verifyRegions() {
   if (isExternal())
     return success();
 
   unsigned numArguments = getType().getNumParams();
   Block &entryBlock = front();
   for (unsigned i = 0; i < numArguments; ++i) {
     Type argType = entryBlock.getArgument(i).getType();
     if (!isCompatibleType(argType))
       return emitOpError("entry block argument #")
              << i << " is not of LLVM type";
-    if (getType().getParamType(i) != argType)
-      return emitOpError("the type of entry block argument #")
-             << i << " does not match the function signature";
   }
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Verification for LLVM::ConstantOp.
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

 //===- PDLInterp.cpp - PDL Interpreter Dialect ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/FunctionImplementation.h"
 
 using namespace mlir;
 using namespace mlir::pdl_interp;
 
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.cpp.inc"
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect
LogicalResult ForEachOp::verify() {
   Type rangeType = pdl::RangeType::get(arg.getType());
   if (rangeType != values().getType())
     return emitOpError("operand must be a range of loop variable type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
+// pdl_interp::FuncOp
+//===----------------------------------------------------------------------===//
+
+void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
+                   FunctionType type, ArrayRef<NamedAttribute> attrs) {
+  buildWithEntryBlock(builder, state, name, type, attrs, type.getInputs());
+}
+
+ParseResult FuncOp::parse(OpAsmParser &parser, OperationState &result) {
+  auto buildFuncType =
+      [](Builder &builder, ArrayRef<Type> argTypes, ArrayRef<Type> results,
+         function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
+
+  return function_interface_impl::parseFunctionOp(
+      parser, result, /*allowVariadic=*/false, buildFuncType);
+}
+
+void FuncOp::print(OpAsmPrinter &p) {
+  function_interface_impl::printFunctionOp(p, *this, /*isVariadic=*/false);
+}
+
+//===----------------------------------------------------------------------===//
 // pdl_interp::GetValueTypeOp
 //===----------------------------------------------------------------------===//
 
 /// Given the result type of a `GetValueTypeOp`, return the expected input type.
 static Type getGetValueTypeOpValueType(Type type) {
   Type valueTy = pdl::ValueType::get(type.getContext());
   return type.isa<pdl::RangeType>() ? pdl::RangeType::get(valueTy) : valueTy;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchAttributeOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SwitchAttributeOp::verify() { return verifySwitchOp(*this); }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperandCountOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult SwitchOperandCountOp::verify() { return verifySwitchOp(*this); }
 

mlir/lib/IR/BuiltinDialect.cpp

auto buildFuncType =
          function_interface_impl::VariadicFlag,
          std::string &) { return builder.getFunctionType(argTypes, results); };
 
   return function_interface_impl::parseFunctionOp(
       parser, result, /*allowVariadic=*/false, buildFuncType);
 }
 
 void FuncOp::print(OpAsmPrinter &p) {
-  FunctionType fnType = getType();
-  function_interface_impl::printFunctionOp(
-      p, *this, fnType.getInputs(), /*isVariadic=*/false, fnType.getResults());
-}
-
-LogicalResult FuncOp::verify() {
-  // If this function is external there is nothing to do.
-  if (isExternal())
-    return success();
-
-  // Verify that the argument list of the function and the arg list of the entry
-  // block line up.  The trait already verified that the number of arguments is
-  // the same between the signature and the block.
-  auto fnInputTypes = getType().getInputs();
-  Block &entryBlock = front();
-  for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i)
-    if (fnInputTypes[i] != entryBlock.getArgument(i).getType())
-      return emitOpError("type of entry block argument #")
-             << i << '(' << entryBlock.getArgument(i).getType()
-             << ") must match the type of the corresponding argument in "
-             << "function signature(" << fnInputTypes[i] << ')';
-
-  return success();
+  function_interface_impl::printFunctionOp(p, *this, /*isVariadic=*/false);
 }
 
 /// Clone the internal blocks from this function into dest and all attributes
 /// from this function to dest.
 void FuncOp::cloneInto(FuncOp dest, BlockAndValueMapping &mapper) {
   // Add the attributes of this function to dest.
   llvm::MapVector<StringAttr, Attribute> newAttrMap;
   for (const auto &attr : dest->getAttrs())

mlir/lib/IR/FunctionImplementation.cpp

void mlir::function_interface_impl::printFunctionAttributes(
   SmallVector<StringRef, 2> ignoredAttrs = {
       ::mlir::SymbolTable::getSymbolAttrName(), getTypeAttrName(),
       getArgDictAttrName(), getResultDictAttrName()};
   ignoredAttrs.append(elided.begin(), elided.end());
 
   p.printOptionalAttrDictWithKeyword(op->getAttrs(), ignoredAttrs);
 }
 
-void mlir::function_interface_impl::printFunctionOp(
-    OpAsmPrinter &p, Operation *op, ArrayRef<Type> argTypes, bool isVariadic,
-    ArrayRef<Type> resultTypes) {
+void mlir::function_interface_impl::printFunctionOp(OpAsmPrinter &p,
+                                                    FunctionOpInterface op,
+                                                    bool isVariadic) {
   // Print the operation and the function name.
   auto funcName =
       op->getAttrOfType<StringAttr>(SymbolTable::getSymbolAttrName())
           .getValue();
   p << ' ';
 
   StringRef visibilityAttrName = SymbolTable::getVisibilityAttrName();
   if (auto visibility = op->getAttrOfType<StringAttr>(visibilityAttrName))
     p << visibility.getValue() << ' ';
   p.printSymbolName(funcName);
 
+  ArrayRef<Type> argTypes = op.getArgumentTypes();
+  ArrayRef<Type> resultTypes = op.getResultTypes();
   printFunctionSignature(p, op, argTypes, isVariadic, resultTypes);
   printFunctionAttributes(p, op, argTypes.size(), resultTypes.size(),
                           {visibilityAttrName});
   // Print the body if this is not an external function.
   Region &body = op->getRegion(0);
   if (!body.empty()) {
     p << ' ';
     p.printRegion(body, /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/true);
   }
 }

mlir/lib/Rewrite/ByteCode.cpp

getMemIndex(T val) {
     if (it.second)
       uniquedData.push_back(opaqueVal);
     return it.first->second;
   }
 
 private:
   /// Allocate memory indices for the results of operations within the matcher
   /// and rewriters.
-  void allocateMemoryIndices(FuncOp matcherFunc, ModuleOp rewriterModule);
+  void allocateMemoryIndices(pdl_interp::FuncOp matcherFunc,
+                             ModuleOp rewriterModule);
 
   /// Generate the bytecode for the given operation.
   void generate(Region *region, ByteCodeWriter &writer);
   void generate(Operation *op, ByteCodeWriter &writer);
   void generate(pdl_interp::ApplyConstraintOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::ApplyRewriteOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::AreEqualOp op, ByteCodeWriter &writer);
   void generate(pdl_interp::BranchOp op, ByteCodeWriter &writer);
struct ByteCodeLiveRange {
   Optional<unsigned> typeRangeIndex;
 
   /// The value range storage index for this range.
   Optional<unsigned> valueRangeIndex;
 };
 } // namespace
 
 void Generator::generate(ModuleOp module) {
-  FuncOp matcherFunc = module.lookupSymbol<FuncOp>(
+  auto matcherFunc = module.lookupSymbol<pdl_interp::FuncOp>(
       pdl_interp::PDLInterpDialect::getMatcherFunctionName());
   ModuleOp rewriterModule = module.lookupSymbol<ModuleOp>(
       pdl_interp::PDLInterpDialect::getRewriterModuleName());
   assert(matcherFunc && rewriterModule && "invalid PDL Interpreter module");
 
   // Allocate memory indices for the results of operations within the matcher
   // and rewriters.
   allocateMemoryIndices(matcherFunc, rewriterModule);
 
   // Generate code for the rewriter functions.
   ByteCodeWriter rewriterByteCodeWriter(rewriterByteCode, *this);
-  for (FuncOp rewriterFunc : rewriterModule.getOps<FuncOp>()) {
+  for (auto rewriterFunc : rewriterModule.getOps<pdl_interp::FuncOp>()) {
     rewriterToAddr.try_emplace(rewriterFunc.getName(), rewriterByteCode.size());
     for (Operation &op : rewriterFunc.getOps())
       generate(&op, rewriterByteCodeWriter);
   }
   assert(rewriterByteCodeWriter.unresolvedSuccessorRefs.empty() &&
          "unexpected branches in rewriter function");
 
   // Generate code for the matcher function.
   ByteCodeWriter matcherByteCodeWriter(matcherByteCode, *this);
   generate(&matcherFunc.getBody(), matcherByteCodeWriter);
 
   // Resolve successor references in the matcher.
   for (auto &it : matcherByteCodeWriter.unresolvedSuccessorRefs) {
     ByteCodeAddr addr = blockToAddr[it.first];
     for (unsigned offsetToFix : it.second)
       std::memcpy(&matcherByteCode[offsetToFix], &addr, sizeof(ByteCodeAddr));
   }
 }
 
-void Generator::allocateMemoryIndices(FuncOp matcherFunc,
+void Generator::allocateMemoryIndices(pdl_interp::FuncOp matcherFunc,
                                       ModuleOp rewriterModule) {
   // Rewriters use simplistic allocation scheme that simply assigns an index to
   // each result.
-  for (FuncOp rewriterFunc : rewriterModule.getOps<FuncOp>()) {
+  for (auto rewriterFunc : rewriterModule.getOps<pdl_interp::FuncOp>()) {
     ByteCodeField index = 0, typeRangeIndex = 0, valueRangeIndex = 0;
     auto processRewriterValue = [&](Value val) {
       valueToMemIndex.try_emplace(val, index++);
       if (pdl::RangeType rangeType = val.getType().dyn_cast<pdl::RangeType>()) {
         Type elementTy = rangeType.getElementType();
         if (elementTy.isa<pdl::TypeType>())
           valueToRangeIndex.try_emplace(val, typeRangeIndex++);
         else if (elementTy.isa<pdl::ValueType>())

mlir/test/Dialect/LLVMIR/func.mlir

module {
   ^bb0(%arg0: i64):
     llvm.return
   }) {sym_name = "wrong_arg_number", type = !llvm.func<void ()>} : () -> ()
 }
 
 // -----
 
 module {
-  // expected-error@+1 {{entry block argument #0 is not of LLVM type}}
+  // expected-error@+1 {{entry block argument #0('tensor<*xf32>') must match the type of the corresponding argument in function signature('i64')}}
   "llvm.func"() ({
   ^bb0(%arg0: tensor<*xf32>):
     llvm.return
   }) {sym_name = "wrong_arg_number", type = !llvm.func<void (i64)>} : () -> ()
 }
 
 // -----
 
 module {
-  // expected-error@+1 {{entry block argument #0 does not match the function signature}}
-  "llvm.func"() ({
-  ^bb0(%arg0: i32):
-    llvm.return
-  }) {sym_name = "wrong_arg_number", type = !llvm.func<void (i64)>} : () -> ()
-}
-
-// -----
-
-module {
   // expected-error@+1 {{failed to construct function type: expected LLVM type for function arguments}}
   llvm.func @foo(tensor<*xf32>)
 }
 
 // -----
 
 module {
   // expected-error@+1 {{failed to construct function type: expected LLVM type for function results}}

mlir/test/Rewrite/pdl-bytecode.mlir

 // RUN: mlir-opt %s -test-pdl-bytecode-pass -split-input-file | FileCheck %s
 
 // Note: Tests here are written using the PDL Interpreter dialect to avoid
 // unnecessarily testing unnecessary aspects of the pattern compilation
 // pipeline. These tests are written such that we can focus solely on the
 // lowering/execution of the bytecode itself.
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ApplyConstraintOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.apply_constraint "multi_entity_constraint"(%root, %root : !pdl.operation, !pdl.operation) -> ^pat, ^end
 
   ^pat:
     pdl_interp.apply_constraint "single_entity_constraint"(%root : !pdl.operation) -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.replaced_by_pattern"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_constraint_1
 // CHECK: "test.replaced_by_pattern"
 module @ir attributes { test.apply_constraint_1 } {
   "test.op"() { test_attr } : () -> ()
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %results = pdl_interp.get_results of %root : !pdl.range<value>
     %types = pdl_interp.get_value_type of %results : !pdl.range<type>
     pdl_interp.apply_constraint "multi_entity_var_constraint"(%results, %types : !pdl.range<value>, !pdl.range<type>) -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.replaced_by_pattern"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_constraint_2
 // CHECK-NOT: "test.replaced_by_pattern"
 // CHECK: "test.replaced_by_pattern"
 module @ir attributes { test.apply_constraint_2 } {
   "test.failure_op"() { test_attr } : () -> ()
   "test.success_op"() : () -> (i32, i64)
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ApplyRewriteOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %operand = pdl_interp.get_operand 0 of %root
       pdl_interp.apply_rewrite "rewriter"[42](%root, %operand : !pdl.operation, !pdl.value)
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_rewrite_1
 // CHECK: %[[INPUT:.*]] = "test.op_input"
 // CHECK-NOT: "test.op"
 // CHECK: "test.success"(%[[INPUT]]) {constantParams = [42]}
 module @ir attributes { test.apply_rewrite_1 } {
   %input = "test.op_input"() : () -> i32
   "test.op"(%input) : (i32) -> ()
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.apply_rewrite "creator"(%root : !pdl.operation) : !pdl.operation
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_rewrite_2
 // CHECK: "test.success"
 module @ir attributes { test.apply_rewrite_2 } {
   "test.op"() : () -> ()
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %operands, %types = pdl_interp.apply_rewrite "var_creator"(%root : !pdl.operation) : !pdl.range<value>, !pdl.range<type>
       %op = pdl_interp.create_operation "test.success"(%operands : !pdl.range<value>) -> (%types : !pdl.range<type>)
       pdl_interp.replace %root with (%operands : !pdl.range<value>)
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_rewrite_3
 // CHECK: %[[OPERAND:.*]] = "test.producer"
 // CHECK: "test.success"(%[[OPERAND]]) : (i32) -> i32
 // CHECK: "test.consumer"(%[[OPERAND]])
 module @ir attributes { test.apply_rewrite_3 } {
   %first_operand = "test.producer"() : () -> (i32)
   %operand = "test.op"(%first_operand) : (i32) -> (i32)
   "test.consumer"(%operand) : (i32) -> ()
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %type = pdl_interp.apply_rewrite "type_creator" : !pdl.type
       %newOp = pdl_interp.create_operation "test.success" -> (%type : !pdl.type)
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.apply_rewrite_4
 // CHECK: "test.success"() : () -> f32
 module @ir attributes { test.apply_rewrite_4 } {
   "test.op"() : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::AreEqualOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %test_attr = pdl_interp.create_attribute unit
     %attr = pdl_interp.get_attribute "test_attr" of %root
     pdl_interp.are_equal %test_attr, %attr : !pdl.attribute -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.are_equal_1
 // CHECK: "test.success"
 module @ir attributes { test.are_equal_1 } {
   "test.op"() { test_attr } : () -> ()
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %const_types = pdl_interp.create_types [i32, i64]
     %results = pdl_interp.get_results of %root : !pdl.range<value>
     %result_types = pdl_interp.get_value_type of %results : !pdl.range<type>
     pdl_interp.are_equal %result_types, %const_types : !pdl.range<type> -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.are_equal_2
 // CHECK: "test.not_equal"
 // CHECK: "test.success"
 // CHECK-NOT: "test.op"
 module @ir attributes { test.are_equal_2 } {
   "test.not_equal"() : () -> (i32)
   "test.op"() : () -> (i32, i64)
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::BranchOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat1, ^end
 
   ^pat1:
     pdl_interp.branch ^pat2
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(2), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.branch_1
 // CHECK: "test.success"
 module @ir attributes { test.branch_1 } {
   "test.op"() : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckAttributeOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %attr = pdl_interp.get_attribute "test_attr" of %root
     pdl_interp.check_attribute %attr is unit -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.check_attribute_1
 // CHECK: "test.success"
 module @ir attributes { test.check_attribute_1 } {
   "test.op"() { test_attr } : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckOperandCountOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operand_count of %root is at_least 1 -> ^exact_check, ^end
 
   ^exact_check:
     pdl_interp.check_operand_count of %root is 2 -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.check_operand_count_1
 // CHECK: "test.op"() : () -> i32
 // CHECK: "test.success"
 module @ir attributes { test.check_operand_count_1 } {
   %operand = "test.op"() : () -> i32
   "test.op"(%operand, %operand) : (i32, i32) -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckOperationNameOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.check_operation_name_1
 // CHECK: "test.success"
 module @ir attributes { test.check_operation_name_1 } {
   "test.op"() : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckResultCountOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_result_count of %root is at_least 1 -> ^exact_check, ^end
 
   ^exact_check:
     pdl_interp.check_result_count of %root is 2 -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.check_result_count_1
 // CHECK: "test.op"() : () -> i32
 // CHECK: "test.success"() : () -> ()
 // CHECK-NOT: "test.op"() : () -> (i32, i32)
 module @ir attributes { test.check_result_count_1 } {
   "test.op"() : () -> i32
   "test.op"() : () -> (i32, i32)
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckTypeOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %attr = pdl_interp.get_attribute "test_attr" of %root
     pdl_interp.is_not_null %attr : !pdl.attribute -> ^pat1, ^end
 
   ^pat1:
     %type = pdl_interp.get_attribute_type of %attr
     pdl_interp.check_type %type is i32 -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.check_type_1
 // CHECK: "test.success"
 module @ir attributes { test.check_type_1 } {
   "test.op"() { test_attr = 10 : i32 } : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CheckTypesOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %results = pdl_interp.get_results of %root : !pdl.range<value>
     %result_types = pdl_interp.get_value_type of %results : !pdl.range<type>
     pdl_interp.check_types %result_types are [i32] -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.check_types_1

 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::CreateTypeOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %attr = pdl_interp.get_attribute "test_attr" of %root
     pdl_interp.is_not_null %attr : !pdl.attribute -> ^pat1, ^end
 
   ^pat1:
     %test_type = pdl_interp.create_type i32
     %type = pdl_interp.get_attribute_type of %attr
     pdl_interp.are_equal %type, %test_type : !pdl.type -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.create_type_1

 
 // Fully tested within the tests for other operations.
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ExtractOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %val = pdl_interp.get_result 0 of %root
     %ops = pdl_interp.get_users of %val : !pdl.value
     %op1 = pdl_interp.extract 1 of %ops : !pdl.operation
     pdl_interp.is_not_null %op1 : !pdl.operation -> ^success, ^end
   ^success:
     pdl_interp.record_match @rewriters::@success(%op1 : !pdl.operation) : benefit(1), loc([%root]) -> ^end
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%matched : !pdl.operation) {
+    pdl_interp.func @success(%matched : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %matched
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.extract_op
 // CHECK: "test.success"
 // CHECK: %[[OPERAND:.*]] = "test.op"
 // CHECK: "test.op"(%[[OPERAND]])
 module @ir attributes { test.extract_op } {
   %operand = "test.op"() : () -> i32
   "test.op"(%operand) : (i32) -> (i32)
   "test.op"(%operand, %operand) : (i32, i32) -> (i32)
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %vals = pdl_interp.get_results of %root : !pdl.range<value>
     %types = pdl_interp.get_value_type of %vals : !pdl.range<type>
     %type1 = pdl_interp.extract 1 of %types : !pdl.type
     pdl_interp.is_not_null %type1 : !pdl.type -> ^success, ^end
   ^success:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%matched : !pdl.operation) {
+    pdl_interp.func @success(%matched : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %matched
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.extract_type
 // CHECK: %[[OPERAND:.*]] = "test.op"
 // CHECK: "test.success"
 // CHECK: "test.op"(%[[OPERAND]])
 module @ir attributes { test.extract_type } {
   %operand = "test.op"() : () -> i32
   "test.op"(%operand) : (i32) -> (i32, i32)
   "test.op"(%operand) : (i32) -> (i32)
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %vals = pdl_interp.get_results of %root : !pdl.range<value>
     %val1 = pdl_interp.extract 1 of %vals : !pdl.value
     pdl_interp.is_not_null %val1 : !pdl.value -> ^success, ^end
   ^success:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%matched : !pdl.operation) {
+    pdl_interp.func @success(%matched : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %matched
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.extract_value

 
 // Fully tested within the tests for other operations.
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ForEachOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %val1 = pdl_interp.get_result 0 of %root
     %ops1 = pdl_interp.get_users of %val1 : !pdl.value
     pdl_interp.foreach %op1 : !pdl.operation in %ops1 {
       %val2 = pdl_interp.get_result 0 of %op1
       %ops2 = pdl_interp.get_users of %val2 : !pdl.value
       pdl_interp.foreach %op2 : !pdl.operation in %ops2 {
         pdl_interp.record_match @rewriters::@success(%op2 : !pdl.operation) : benefit(1), loc([%root]) -> ^cont
       ^cont:
         pdl_interp.continue
       } -> ^cont
     ^cont:
       pdl_interp.continue
     } -> ^end
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%matched : !pdl.operation) {
+    pdl_interp.func @success(%matched : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %matched
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.foreach

 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetUsersOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %val = pdl_interp.get_result 0 of %root
     %ops = pdl_interp.get_users of %val : !pdl.value
     pdl_interp.foreach %op : !pdl.operation in %ops {
       pdl_interp.record_match @rewriters::@success(%op : !pdl.operation) : benefit(1), loc([%root]) -> ^cont
     ^cont:
       pdl_interp.continue
     } -> ^end
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%matched : !pdl.operation) {
+    pdl_interp.func @success(%matched : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %matched
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.get_users_of_value
 // CHECK: "test.success"
 // CHECK: "test.success"
 // CHECK: %[[OPERAND:.*]] = "test.op"
 module @ir attributes { test.get_users_of_value } {
   %operand = "test.op"() : () -> i32
   "test.op"(%operand) : (i32) -> (i32)
   "test.op"(%operand, %operand) : (i32, i32) -> (i32)
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_result_count of %root is at_least 2 -> ^next, ^end
   ^next:
     %vals = pdl_interp.get_results of %root : !pdl.range<value>
     %ops = pdl_interp.get_users of %vals : !pdl.range<value>
     pdl_interp.foreach %op : !pdl.operation in %ops {
       pdl_interp.record_match @rewriters::@success(%op : !pdl.operation) : benefit(1), loc([%root]) -> ^cont
     ^cont:
       pdl_interp.continue
     } -> ^end
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%matched : !pdl.operation) {
+    pdl_interp.func @success(%matched : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %matched
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.get_all_users_of_range
 // CHECK: "test.success"
 // CHECK: "test.success"
 // CHECK: %[[OPERANDS:.*]]:2 = "test.op"
 module @ir attributes { test.get_all_users_of_range } {
   %operands:2 = "test.op"() : () -> (i32, i32)
   "test.op"(%operands#0) : (i32) -> (i32)
   "test.op"(%operands#1) : (i32) -> (i32)
 }
 
 // -----
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_result_count of %root is at_least 2 -> ^next, ^end
   ^next:
     %vals = pdl_interp.get_results of %root : !pdl.range<value>
     %val = pdl_interp.extract 0 of %vals : !pdl.value
     %ops = pdl_interp.get_users of %val : !pdl.value
     pdl_interp.foreach %op : !pdl.operation in %ops {
       pdl_interp.record_match @rewriters::@success(%op : !pdl.operation) : benefit(1), loc([%root]) -> ^cont
     ^cont:
       pdl_interp.continue
     } -> ^end
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%matched : !pdl.operation) {
+    pdl_interp.func @success(%matched : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %matched
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.get_first_users_of_range

 
 // Fully tested within the tests for other operations.
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetDefiningOpOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operand_count of %root is 5 -> ^pat1, ^end
 
   ^pat1:
     %operand0 = pdl_interp.get_operand 0 of %root
     %operand4 = pdl_interp.get_operand 4 of %root
     %defOp0 = pdl_interp.get_defining_op of %operand0 : !pdl.value
     %defOp4 = pdl_interp.get_defining_op of %operand4 : !pdl.value
     pdl_interp.are_equal %defOp0, %defOp4 : !pdl.operation -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.get_defining_op_1

 
 // Fully tested within the tests for other operations.
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetOperandsOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operand_count of %root is 2 -> ^pat1, ^end
 
   ^pat1:
     %operands = pdl_interp.get_operands 0 of %root : !pdl.range<value>
     %full_operands = pdl_interp.get_operands of %root : !pdl.range<value>
     pdl_interp.are_equal %operands, %full_operands : !pdl.range<value> -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.get_operands_1
 // CHECK: "test.success"
 module @ir attributes { test.get_operands_1 } {
   %inputs:2 = "test.producer"() : () -> (i32, i32)
   "test.op"(%inputs#0, %inputs#1) : (i32, i32) -> ()
 }
 
 // -----
 
 // Test all of the various combinations related to `AttrSizedOperandSegments`.
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.attr_sized_operands" -> ^pat1, ^end
 
   ^pat1:
     %operands_0 = pdl_interp.get_operands 0 of %root : !pdl.range<value>
     pdl_interp.is_not_null %operands_0 : !pdl.range<value> -> ^pat2, ^end
 
   ^pat2:
     %operands_0_single = pdl_interp.get_operands 0 of %root : !pdl.value
^pat8:
     pdl_interp.record_match @rewriters::@success(%root, %operands_0, %operands_1, %operands_2, %operands_2_single : !pdl.operation, !pdl.range<value>, !pdl.range<value>, !pdl.range<value>, !pdl.value) : benefit(1), loc([%root]) -> ^end
 
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root: !pdl.operation, %operands_0: !pdl.range<value>, %operands_1: !pdl.range<value>, %operands_2: !pdl.range<value>, %operands_2_single: !pdl.value) {
+    pdl_interp.func @success(%root: !pdl.operation, %operands_0: !pdl.range<value>, %operands_1: !pdl.range<value>, %operands_2: !pdl.range<value>, %operands_2_single: !pdl.value) {
       %op0 = pdl_interp.create_operation "test.success"(%operands_0 : !pdl.range<value>)
       %op1 = pdl_interp.create_operation "test.success"(%operands_1 : !pdl.range<value>)
       %op2 = pdl_interp.create_operation "test.success"(%operands_2 : !pdl.range<value>)
       %op3 = pdl_interp.create_operation "test.success"(%operands_2_single : !pdl.value)
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }

 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetResultOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_result_count of %root is 5 -> ^pat1, ^end
 
   ^pat1:
     %result0 = pdl_interp.get_result 0 of %root
     %result4 = pdl_interp.get_result 4 of %root
     %result0_type = pdl_interp.get_value_type of %result0 : !pdl.type
     %result4_type = pdl_interp.get_value_type of %result4 : !pdl.type
     pdl_interp.are_equal %result0_type, %result4_type : !pdl.type -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.get_result_1
 // CHECK: "test.success"
 // CHECK: "test.op"() : () -> (i32, i32, i32, i32, i64)
 module @ir attributes { test.get_result_1 } {
   %a:5 = "test.op"() : () -> (i32, i32, i32, i32, i32)
   %b:5 = "test.op"() : () -> (i32, i32, i32, i32, i64)
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::GetResultsOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_result_count of %root is 5 -> ^pat1, ^end
 
   ^pat1:
     %results = pdl_interp.get_results 0 of %root : !pdl.range<value>
     %full_results = pdl_interp.get_results of %root : !pdl.range<value>
     pdl_interp.are_equal %results, %full_results : !pdl.range<value> -> ^pat2, ^end
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.get_results_1
 // CHECK: "test.success"
 module @ir attributes { test.get_results_1 } {
   %a:5 = "test.producer"() : () -> (i32, i32, i32, i32, i32)
 }
 
 // -----
 
 // Test all of the various combinations related to `AttrSizedResultSegments`.
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.attr_sized_results" -> ^pat1, ^end
 
   ^pat1:
     %results_0 = pdl_interp.get_results 0 of %root : !pdl.range<value>
     pdl_interp.is_not_null %results_0 : !pdl.range<value> -> ^pat2, ^end
 
   ^pat2:
     %results_0_single = pdl_interp.get_results 0 of %root : !pdl.value
^pat8:
     pdl_interp.record_match @rewriters::@success(%root, %results_0, %results_1, %results_2, %results_2_single : !pdl.operation, !pdl.range<value>, !pdl.range<value>, !pdl.range<value>, !pdl.value) : benefit(1), loc([%root]) -> ^end
 
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root: !pdl.operation, %results_0: !pdl.range<value>, %results_1: !pdl.range<value>, %results_2: !pdl.range<value>, %results_2_single: !pdl.value) {
+    pdl_interp.func @success(%root: !pdl.operation, %results_0: !pdl.range<value>, %results_1: !pdl.range<value>, %results_2: !pdl.range<value>, %results_2_single: !pdl.value) {
       %results_0_types = pdl_interp.get_value_type of %results_0 : !pdl.range<type>
       %results_1_types = pdl_interp.get_value_type of %results_1 : !pdl.range<type>
       %results_2_types = pdl_interp.get_value_type of %results_2 : !pdl.range<type>
       %results_2_single_types = pdl_interp.get_value_type of %results_2_single : !pdl.type
 
       %op0 = pdl_interp.create_operation "test.success" -> (%results_0_types : !pdl.range<type>)
       %op1 = pdl_interp.create_operation "test.success" -> (%results_1_types : !pdl.range<type>)
       %op2 = pdl_interp.create_operation "test.success" -> (%results_2_types : !pdl.range<type>)

 // Fully tested within the tests for other operations.
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::RecordMatchOp
 //===----------------------------------------------------------------------===//
 
 // Check that the highest benefit pattern is selected.
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat1, ^end
 
   ^pat1:
     pdl_interp.record_match @rewriters::@failure(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^pat2
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(2), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @failure(%root : !pdl.operation) {
+    pdl_interp.func @failure(%root : !pdl.operation) {
       pdl_interp.erase %root
       pdl_interp.finalize
     }
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.record_match_1
 // CHECK: "test.success"
 module @ir attributes { test.record_match_1 } {
   "test.op"() : () -> ()
 }
 
 // -----
 
 // Check that ranges are properly forwarded to the result.
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat1, ^end
 
   ^pat1:
     %operands = pdl_interp.get_operands of %root : !pdl.range<value>
     %results = pdl_interp.get_results of %root : !pdl.range<value>
     %types = pdl_interp.get_value_type of %results : !pdl.range<type>
     pdl_interp.record_match @rewriters::@success(%operands, %types, %root : !pdl.range<value>, !pdl.range<type>, !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%operands: !pdl.range<value>, %types: !pdl.range<type>, %root: !pdl.operation) {
+    pdl_interp.func @success(%operands: !pdl.range<value>, %types: !pdl.range<type>, %root: !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"(%operands : !pdl.range<value>) -> (%types : !pdl.range<type>)
       %results = pdl_interp.get_results of %op : !pdl.range<value>
       pdl_interp.replace %root with (%results : !pdl.range<value>)
       pdl_interp.finalize
     }
   }
 }
 

 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::ReplaceOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.check_operation_name of %root is "test.op" -> ^pat, ^end
 
   ^pat:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %operand = pdl_interp.get_operand 0 of %root
       pdl_interp.replace %root with (%operand : !pdl.value)
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.replace_op_1
 // CHECK: %[[INPUT:.*]] = "test.op_input"
 // CHECK-NOT: "test.op"
 // CHECK: "test.op_consumer"(%[[INPUT]])
 module @ir attributes { test.replace_op_1 } {
   %input = "test.op_input"() : () -> i32
   %result = "test.op"(%input) : (i32) -> i32
   "test.op_consumer"(%result) : (i32) -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchAttributeOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %attr = pdl_interp.get_attribute "test_attr" of %root
     pdl_interp.switch_attribute %attr to [0, unit](^end, ^pat) -> ^end
 
   ^pat:
     %attr_2 = pdl_interp.get_attribute "test_attr_2" of %root
     pdl_interp.switch_attribute %attr_2 to [0, unit](^end, ^end) -> ^pat2
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.switch_attribute_1
 // CHECK: "test.success"
 module @ir attributes { test.switch_attribute_1 } {
   "test.op"() { test_attr } : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperandCountOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.switch_operand_count of %root to dense<[0, 1]> : vector<2xi32>(^end, ^pat) -> ^end
 
   ^pat:
     pdl_interp.switch_operand_count of %root to dense<[0, 2]> : vector<2xi32>(^end, ^end) -> ^pat2
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.switch_operand_1
 // CHECK: "test.success"
 module @ir attributes { test.switch_operand_1 } {
   %input = "test.op_input"() : () -> i32
   "test.op"(%input) : (i32) -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchOperationNameOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.switch_operation_name of %root to ["foo.op", "test.op"](^end, ^pat1) -> ^end
 
   ^pat1:
     pdl_interp.switch_operation_name of %root to ["foo.op", "bar.op"](^end, ^end) -> ^pat2
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.switch_operation_name_1
 // CHECK: "test.success"
 module @ir attributes { test.switch_operation_name_1 } {
   "test.op"() : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchResultCountOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     pdl_interp.switch_result_count of %root to dense<[0, 1]> : vector<2xi32>(^end, ^pat) -> ^end
 
   ^pat:
     pdl_interp.switch_result_count of %root to dense<[0, 2]> : vector<2xi32>(^end, ^end) -> ^pat2
 
   ^pat2:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.switch_result_1
 // CHECK: "test.success"
 module @ir attributes { test.switch_result_1 } {
   "test.op"() : () -> i32
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypeOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %attr = pdl_interp.get_attribute "test_attr" of %root
     pdl_interp.is_not_null %attr : !pdl.attribute -> ^pat1, ^end
 
   ^pat1:
     %type = pdl_interp.get_attribute_type of %attr
     pdl_interp.switch_type %type to [i32, i64](^pat2, ^end) -> ^end
 
   ^pat2:
     pdl_interp.switch_type %type to [i16, i64](^end, ^end) -> ^pat3
 
   ^pat3:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.switch_type_1
 // CHECK: "test.success"
 module @ir attributes { test.switch_type_1 } {
   "test.op"() { test_attr = 10 : i32 } : () -> ()
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::SwitchTypesOp
 //===----------------------------------------------------------------------===//
 
 module @patterns {
-  func @matcher(%root : !pdl.operation) {
+  pdl_interp.func @matcher(%root : !pdl.operation) {
     %results = pdl_interp.get_results of %root : !pdl.range<value>
     %types = pdl_interp.get_value_type of %results : !pdl.range<type>
     pdl_interp.switch_types %types to [[i64, i64], [i32]](^pat2, ^end) -> ^end
 
   ^pat2:
     pdl_interp.switch_types %types to [[i32], [i64, i32]](^end, ^end) -> ^pat3
 
   ^pat3:
     pdl_interp.record_match @rewriters::@success(%root : !pdl.operation) : benefit(1), loc([%root]) -> ^end
 
   ^end:
     pdl_interp.finalize
   }
 
   module @rewriters {
-    func @success(%root : !pdl.operation) {
+    pdl_interp.func @success(%root : !pdl.operation) {
       %op = pdl_interp.create_operation "test.success"
       pdl_interp.erase %root
       pdl_interp.finalize
     }
   }
 }
 
 // CHECK-LABEL: test.switch_types_1
 // CHECK: "test.success"
 module @ir attributes { test.switch_types_1 } {
   %results:2 = "test.op"() : () -> (i64, i64)
 }