[mlir] Convert OpTrait::FunctionLike to FunctionOpInterface

[rriddle]

Summary

This commit refactors the FunctionLike trait into an interface (FunctionOpInterface).
FunctionLike as it is today is already a pseudo-interface, with many users checking the
presence of the trait and then manually into functionality implemented in the
function_like_impl namespace. By transitioning to an interface, these accesses are much
cleaner (ideally with no direct calls to the impl namespace outside of the implementation
of the derived function operations, e.g. for parsing/printing utilities).

I've tried to maintain as much compatability with the current state as possible, while
also trying to clean up as much of the cruft as possible. The general migration plan for
current users of FunctionLike is as follows:

• function_like_impl -> function_interface_impl

Realistically most user calls should remove references to functions within this namespace
outside of a vary narrow set (e.g. parsing/printing utilities). Calls to the attribute name
accessors should be migrated to the FunctionOpInterface:: equivalent, most everything
else should be updated to be driven through an instance of the interface.

• OpTrait::FunctionLike -> FunctionOpInterface

hasTrait checks will need to be moved to isa, along with the other various Trait vs
Interface API differences.

• populateFunctionLikeTypeConversionPattern -> populateFunctionOpInterfaceTypeConversionPattern

Fixes #52917

[mehdi_amini]

Nice!

mlir/include/mlir/IR/BuiltinOps.td

114

Indeed: since there is a $type, why isn't there a getType() already generated by ODS?

mlir/include/mlir/IR/FunctionOpInterface.td

41 ↗

(On Diff #399879)

I'm not fond of this: I would have a the concrete op be more explicit ($funcType or something like that) to avoid confusion with the "usual Type" we get on APIs which is about the Value domain.

On the other hand, we'll have the opportunity to have a FunctionType getType() method on the interface now and redirect users to it.

136 ↗

(On Diff #399879)

Why isn't the default checking that getTypeAttr() is a FunctionType?

[rriddle]

mlir/include/mlir/IR/FunctionOpInterface.td

136 ↗

(On Diff #399879)

FunctionLike (now FunctionOpInterface) doesn't require a FunctionType. The type of the function is allowed to be represented by other types.

[mehdi_amini]

mlir/include/mlir/IR/FunctionOpInterface.td

55–56 ↗

(On Diff #399879)

I think the contract here is just that the operation has a getType() method that returns a type that has a getInputs() method :)

136 ↗

(On Diff #399879)

Oh really? I see the doc on the other APIs actually, you could do the same here though: it seems that all the defaultImplementation are freely assuming it and come with:

Note: This method must be overridden if the function does not use
`mlir::FunctionType` as the underlying function type.

[rriddle]

mlir/include/mlir/IR/BuiltinOps.td

114

The builtin dialect is not yet generating the get* accessors.

mlir/include/mlir/IR/FunctionOpInterface.td

41 ↗

(On Diff #399879)

Even if we have a getType, we still end up setting the type and interacting with it via utility functions. I'm not claiming that the current setup is the best, but this patch in particular is trying to balance the fine line of NFC-ish refactoring from Trait->Interface, and cleaning up all of the lingering tech debt in FunctionLike. I've tried to keep things relatively close to what they were before, given that we already have quite a bit of code motion happening here.

55–56 ↗

(On Diff #399879)

Indeed, restructured these to rely on the derived getType() having the desired methods (in the default implementation that is). As mentioned before, I've tried to keep things relatively close to what they are now. I'm hesitating to fix all of the current tech debt given that this commit is already quite a large refactoring (for some definition of large). Ideally in a followup, the dubious restrictions and way things are setup here can be restructured.

136 ↗

(On Diff #399879)

This isn't assuming FunctionType, it's assuming that there are no additional invariants on the function type (however that type is represented). Just removed the default implementation though, better to make this explicit.

[mehdi_amini]

mlir/include/mlir/IR/FunctionOpInterface.td

41 ↗

(On Diff #399879)

Can you include a TODO: this field will be renamed to something less generic?

Right we're documenting the interface expectations and changing this will be painful, but I think it is important to acknowledge that "type" as an attribute and the associated getters/setters isn't ideal for non-SSA value

[mehdi_amini]

LG otherwise :)

[rriddle]

mlir/include/mlir/IR/FunctionOpInterface.td

41 ↗

(On Diff #399879)

Yeah, right on. I'm all for adding in as many FIXME/TODOs as we can (there is a lot of mess here to clean up). Let me know if you see any other obvious spots to add a PLEASE_FIX_THIS (even if I submit before then, I'll add them as a followup to resolve).

mlir/docs/Traits.md

 establishes a set of properties that allow reasoning about / converting between
 scalar/vector/tensor code. These same properties allow blanket implementations
 of various analyses/transformations for all `ElementwiseMappable` ops.
 
 Note: Not all ops that are "elementwise" in some abstract sense satisfy this
 trait. In particular, broadcasting behavior is not allowed. See the comments on
 `OpTrait::ElementwiseMappable` for the precise requirements.
 
-### Function-Like
-
-*   `OpTrait::FunctionLike`
-
-This trait provides APIs for operations that behave like functions. In
-particular:
-
--   Ops must be symbols, i.e. also have the `Symbol` trait;
--   Ops have a single region with multiple blocks that corresponds to the body
-    of the function;
--   An op with a single empty region corresponds to an external function;
--   arguments of the first block of the region are treated as function
-    arguments;
--   they can have argument and result attributes that are stored in dictionary
-    attributes on the operation itself.
-
-This trait provides limited type support for the declared or defined functions.
-The convenience function `getTypeAttrName()` returns the name of an attribute
-that can be used to store the function type. In addition, this trait provides
-`getType` and `setType` helpers to store a `FunctionType` in the attribute named
-by `getTypeAttrName()`.
-
-In general, this trait assumes concrete ops use `FunctionType` under the hood.
-If this is not the case, in order to use the function type support, concrete ops
-must define the following methods, using the same name, to hide the ones defined
-for `FunctionType`: `addBodyBlock`, `getType`, `getTypeWithoutArgsAndResults`
-and `setType`.
-
 ### HasParent
 
 *   `OpTrait::HasParent<typename ParentOpType>` -- `HasParent<string op>` or
     `ParentOneOf<list<string> opList>`
 
 This trait provides APIs and verifiers for operations that can only be nested
 within regions that are attached to operations of `ParentOpType`.
 

mlir/include/mlir/Dialect/GPU/GPUDialect.h

 #ifndef MLIR_DIALECT_GPU_GPUDIALECT_H
 #define MLIR_DIALECT_GPU_GPUDIALECT_H
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/DLTI/Traits.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 namespace mlir {
 class FuncOp;

mlir/include/mlir/Dialect/GPU/GPUOps.td

 
 #ifndef GPU_OPS
 #define GPU_OPS
 
 include "mlir/Dialect/DLTI/DLTIBase.td"
 include "mlir/Dialect/GPU/GPUBase.td"
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/IR/EnumAttr.td"
+include "mlir/IR/FunctionInterfaces.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/DataLayoutInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // GPU Dialect operations.
 //===----------------------------------------------------------------------===//
let description = [{
     %sgSz = gpu.subgroup_size : index
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` type($result)";
   let verifier = [{ return success(); }];
 }
 
-def GPU_GPUFuncOp : GPU_Op<"func", [HasParent<"GPUModuleOp">,
-                                    AutomaticAllocationScope, FunctionLike,
-                                    IsolatedFromAbove, Symbol]> {
+def GPU_GPUFuncOp : GPU_Op<"func", [
+    HasParent<"GPUModuleOp">, AutomaticAllocationScope, FunctionOpInterface,
+    IsolatedFromAbove, Symbol
+  ]> {
   let summary = "Function executable on a GPU";
 
   let description = [{
     Defines a function that can be executed on a GPU. This supports memory
     attribution and its body has a particular execution model.
 
     GPU functions are either kernels (as indicated by the `kernel` attribute) or
     regular functions. The former can be launched from the host side, while the
let extraClassDeclaration = [{
     BlockArgument addPrivateAttribution(Type type);
 
     /// Returns the name of the attribute containing the number of buffers
     /// located in the workgroup memory.
     static StringRef getNumWorkgroupAttributionsAttrName() {
       return "workgroup_attributions";
     }
 
-    // FunctionLike trait needs access to the functions below.
-    friend class OpTrait::FunctionLike<GPUFuncOp>;
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); }
 
-    /// Hooks for the input/output type enumeration in FunctionLike .
-    unsigned getNumFuncArguments() { return getType().getNumInputs(); }
-    unsigned getNumFuncResults() { return getType().getNumResults(); }
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return getType().getResults(); }
 
     /// Returns the keywords used in the custom syntax for this Op.
     static StringRef getWorkgroupKeyword() { return "workgroup"; }
     static StringRef getPrivateKeyword() { return "private"; }
     static StringRef getKernelKeyword() { return "kernel"; }
 
-    /// Hook for FunctionLike verifier.
+    /// Hook for FunctionOpInterface verifier.
     LogicalResult verifyType();
 
     /// Verifies the body of the function.
     LogicalResult verifyBody();
   }];
 
   // let verifier = [{ return ::verifFuncOpy(*this); }];
   let printer = [{ printGPUFuncOp(p, *this); }];

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVMIR_OPS
 #define LLVMIR_OPS
 
 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 include "mlir/Dialect/LLVMIR/LLVMOpsInterfaces.td"
+include "mlir/IR/FunctionInterfaces.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def FMFnnan     : BitEnumAttrCase<"nnan", 0x1>;
 def FMFninf     : BitEnumAttrCase<"ninf", 0x2>;
 def FMFnsz      : BitEnumAttrCase<"nsz", 0x4>;
let description = [{
     llvm.mlir.global_dtors {@dtor}
     ```
 
   }];
   let verifier = [{ return ::verify(*this); }];
   let assemblyFormat = "attr-dict";
 }
 
-def LLVM_LLVMFuncOp : LLVM_Op<"func",
-    [AutomaticAllocationScope, IsolatedFromAbove, FunctionLike, Symbol]> {
+def LLVM_LLVMFuncOp : LLVM_Op<"func", [
+    AutomaticAllocationScope, IsolatedFromAbove, FunctionOpInterface, Symbol
+  ]> {
   let summary = "LLVM dialect function.";
 
   let description = [{
     MLIR functions are defined by an operation that is not built into the IR
     itself. The LLVM dialect provides an `llvm.func` operation to define
     functions compatible with LLVM IR. These functions have LLVM dialect
     function type but use MLIR syntax to express it. They are required to have
     exactly one result type. LLVM function operation is intended to capture
def LLVM_LLVMFuncOp : LLVM_Op<"func", [
   ];
 
   let extraClassDeclaration = [{
     // Add an entry block to an empty function, and set up the block arguments
     // to match the signature of the function.
     Block *addEntryBlock();
 
     LLVMFunctionType getType() {
-      return (*this)->getAttrOfType<TypeAttr>(getTypeAttrName())
-          .getValue().cast<LLVMFunctionType>();
-    }
-    bool isVarArg() {
-      return getType().isVarArg();
+      return getTypeAttr().getValue().cast<LLVMFunctionType>();
     }
+    bool isVarArg() { return getType().isVarArg(); }
 
-    // Hook for OpTrait::FunctionLike, returns the number of function arguments`.
-    // Depends on the type attribute being correct as checked by verifyType.
-    unsigned getNumFuncArguments();
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return getType().getParams(); }
 
-    // Hook for OpTrait::FunctionLike, returns the number of function results.
-    // Depends on the type attribute being correct as checked by verifyType.
-    unsigned getNumFuncResults();
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return getType().getReturnTypes(); }
 
-    // Hook for OpTrait::FunctionLike, called after verifying that the 'type'
-    // attribute is present.  This can check for preconditions of the
-    // getNumArguments hook not failing.
+    /// Hook for FunctionOpInterface, called after verifying that the 'type'
+    /// attribute is present.  This can check for preconditions of the
+    /// getNumArguments hook not failing.
     LogicalResult verifyType();
   }];
 
   let verifier = [{ return ::verify(*this); }];
   let printer = [{ printLLVMFuncOp(p, *this); }];
   let parser = [{ return parseLLVMFuncOp(parser, result); }];
 }
 

mlir/include/mlir/Dialect/LLVMIR/LLVMTypes.h

public:
 
   /// Checks if the given type can be used an argument in a function type.
   static bool isValidArgumentType(Type type);
 
   /// Checks if the given type can be used as a result in a function type.
   static bool isValidResultType(Type type);
 
   /// Returns whether the function is variadic.
-  bool isVarArg();
+  bool isVarArg() const;
 
   /// Gets or creates an instance of LLVM dialect function in the same context
   /// as the `result` type.
   static LLVMFunctionType get(Type result, ArrayRef<Type> arguments,
                               bool isVarArg = false);
   static LLVMFunctionType
   getChecked(function_ref<InFlightDiagnostic()> emitError, Type result,
              ArrayRef<Type> arguments, bool isVarArg = false);
 
+  /// Returns a clone of this function type with the given argument
+  /// and result types.
+  LLVMFunctionType clone(TypeRange inputs, TypeRange results) const;
+
   /// Returns the result type of the function.
   Type getReturnType();
 
+  /// Returns the result type of the function as an ArrayRef, enabling better
+  /// integration with generic MLIR utilities.
+  ArrayRef<Type> getReturnTypes();
+
   /// Returns the number of arguments to the function.
   unsigned getNumParams();
 
   /// Returns `i`-th argument of the function. Asserts on out-of-bounds.
   Type getParamType(unsigned i);
 
   /// Returns a list of argument types of the function.
   ArrayRef<Type> getParams();

mlir/include/mlir/Dialect/Linalg/Passes.td

 include "mlir/Pass/PassBase.td"
 
 def ConvertElementwiseToLinalg : Pass<"convert-elementwise-to-linalg", ""> {
   let summary = "Convert ElementwiseMappable ops to linalg";
   let description = [{
     Convert ops with the `ElementwiseMappable` trait to linalg parallel loops.
 
     This pass only converts ops that operate on ranked tensors. It can be
-    run on op which contains linalg ops (most commonly a FunctionLike op).
+    run on op which contains linalg ops (most commonly a
+    FunctionOpInterface op).
   }];
   let constructor = "mlir::createConvertElementwiseToLinalgPass()";
   let dependentDialects = ["linalg::LinalgDialect", "memref::MemRefDialect"];
 }
 
 def LinalgComprehensiveModuleBufferize :
     Pass<"linalg-comprehensive-module-bufferize", "ModuleOp"> {
   let summary = "Bufferize (tensor into memref) for a Module.";
let description = [{
     1. Detect/match an op that can be detensored.
     2. Detensor the operands of the op and replace it with a primitive
        equivalent.
 
     In addition to detensoring individual ops, this pass detensors internal
     control flow inside a function. All blocks except for the entry block are
     detensored by converting their arguments whenever possible.
 
-    This can be run on any op with the FunctionLike trait and must not be
+    This can be run on any FunctionOpInterface op and must not be
     run on others. This is because it performs specific legalization of the
-    blocks that make up the body, which it assumes has a FunctionLike trait.
+    blocks that make up the body, which it assumes has is a FunctionOpInterface.
   }];
   let options = [
     Option<"aggressiveMode", "aggressive-mode", "bool", /*default=*/"false",
            "Detensorize all ops that qualify for detensoring along with branch"
            " operands and basic-block arguments.">
 
   ];
 }

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

 
 //===----------------------------------------------------------------------===//
 // SPIR-V OpTrait definitions
 //===----------------------------------------------------------------------===//
 
 // Check that an op can only be used within the scope of a function-like op.
 def InFunctionScope : PredOpTrait<
   "op must appear in a function-like op's block",
-  CPred<"isNestedInFunctionLikeOp($_op.getParentOp())">>;
+  CPred<"isNestedInFunctionOpInterface($_op.getParentOp())">>;
 
 // Check that an op can only be used within the scope of a module-like op.
 def InModuleScope : PredOpTrait<
   "op must appear in a module-like op's block",
   CPred<"isDirectInModuleLikeOp($_op.getParentOp())">>;
 
 def UnsignedOp : NativeOpTrait<"spirv::UnsignedOp">;
 

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVStructureOps.td

 // from the SPIR-V binary format in order to utilize MLIR mechanisms.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS
 #define MLIR_DIALECT_SPIRV_IR_STRUCTURE_OPS
 
 include "mlir/Dialect/SPIRV/IR/SPIRVBase.td"
+include "mlir/IR/FunctionInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // -----
 
 def SPV_AddressOfOp : SPV_Op<"mlir.addressof",
let builders = [
     OpBuilder<(ins "spirv::FuncOp":$function,
       "spirv::ExecutionMode":$executionMode, "ArrayRef<int32_t>":$params)>];
 }
 
 // -----
 
 def SPV_FuncOp : SPV_Op<"func", [
     AutomaticAllocationScope, DeclareOpInterfaceMethods<CallableOpInterface>,
-    FunctionLike, InModuleScope, IsolatedFromAbove, Symbol
+    FunctionOpInterface, InModuleScope, IsolatedFromAbove, Symbol
   ]> {
   let summary = "Declare or define a function";
 
   let description = [{
     This op declares or defines a SPIR-V function using one region, which
     contains one or more blocks.
 
     Different from the SPIR-V binary format, this op is not allowed to
OpBuilder<(ins "StringRef":$name, "FunctionType":$type,
       CArg<"spirv::FunctionControl", "spirv::FunctionControl::None">:$control,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>];
 
   let hasOpcode = 0;
 
   let autogenSerialization = 0;
 
   let extraClassDeclaration = [{
-  private:
-    // This trait needs access to the hooks defined below.
-    friend class OpTrait::FunctionLike<FuncOp>;
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
 
-    /// Returns the number of arguments. Hook for OpTrait::FunctionLike.
-    unsigned getNumFuncArguments() { return getType().getNumInputs(); }
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return getType().getInputs(); }
 
-    /// Returns the number of results. Hook for OpTrait::FunctionLike.
-    unsigned getNumFuncResults() { return getType().getNumResults(); }
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return getType().getResults(); }
 
-    /// Hook for OpTrait::FunctionLike, called after verifying that the 'type'
+    /// Hook for FunctionOpInterface, called after verifying that the 'type'
     /// attribute is present and checks if it holds a function type. Ensures
-    /// getType, getNumFuncArguments, and getNumFuncResults can be called safely
+    /// getType, getNumArguments, and getNumResults can be called safely
     LogicalResult verifyType();
 
-    /// Hook for OpTrait::FunctionLike, called after verifying the function
+    /// Hook for FunctionOpInterface, called after verifying the function
     /// type and the presence of the (potentially empty) function body.
     /// Ensures SPIR-V specific semantics.
     LogicalResult verifyBody();
   }];
 }
 
 // -----
 

mlir/include/mlir/IR/BuiltinOps.h

 //===- BuiltinOps.h - MLIR Builtin Operations -------------------*- 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 contains the Builtin dialect's operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_BUILTINOPS_H_
 #define MLIR_IR_BUILTINOPS_H_
 
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/OwningOpRef.h"
 #include "mlir/IR/RegionKindInterface.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"

mlir/include/mlir/IR/BuiltinOps.td

 // necessary for the validity of and defining the IR.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BUILTIN_OPS
 #define BUILTIN_OPS
 
 include "mlir/IR/BuiltinDialect.td"
+include "mlir/IR/FunctionInterfaces.td"
 include "mlir/IR/OpAsmInterface.td"
 include "mlir/IR/RegionKindInterface.td"
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/DataLayoutInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Base class for Builtin dialect ops.
 class Builtin_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Builtin_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Builtin_Op<"func", [
-  AffineScope, AutomaticAllocationScope, CallableOpInterface, FunctionLike,
-  IsolatedFromAbove, Symbol
+  AffineScope, AutomaticAllocationScope, CallableOpInterface,
+  FunctionOpInterface, IsolatedFromAbove, Symbol
 ]> {
   let summary = "An operation with a name containing a single `SSACFG` region";
   let description = [{
     Operations within the function cannot implicitly capture values defined
     outside of the function, i.e. Functions are `IsolatedFromAbove`. All
     external references must use function arguments or attributes that establish
     a symbolic connection (e.g. symbols referenced by name via a string
     attribute like SymbolRefAttr). An external function declaration (used when
let extraClassDeclaration = [{
     FuncOp clone();
 
     /// Clone the internal blocks and attributes from this function into dest.
     /// Any cloned blocks are appended to the back of dest. This function
     /// asserts that the attributes of the current function and dest are
     /// compatible.
     void cloneInto(FuncOp dest, BlockAndValueMapping &mapper);
 
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
     //===------------------------------------------------------------------===//
     // CallableOpInterface
     //===------------------------------------------------------------------===//
 
     /// Returns the region on the current operation that is callable. This may
     /// return null in the case of an external callable object, e.g. an external
     /// function.
     ::mlir::Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
 
     /// Returns the results types that the callable region produces when
     /// executed.
     ArrayRef<Type> getCallableResults() { return getType().getResults(); }
 
     //===------------------------------------------------------------------===//
-    // SymbolOpInterface Methods
+    // FunctionOpInterface Methods
     //===------------------------------------------------------------------===//
 
-    bool isDeclaration() { return isExternal(); }
+    /// 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(); }
 
-  private:
-    // This trait needs access to the hooks defined below.
-    friend class OpTrait::FunctionLike<FuncOp>;
-
-    /// Returns the number of arguments. This is a hook for
-    /// OpTrait::FunctionLike.
-    unsigned getNumFuncArguments() { return getType().getInputs().size(); }
-
-    /// Returns the number of results. This is a hook for OpTrait::FunctionLike.
-    unsigned getNumFuncResults() { return getType().getResults().size(); }
-
-    /// Hook for OpTrait::FunctionLike, called after verifying that the 'type'
-    /// attribute is present and checks if it holds a function type. Ensures
-    /// getType, getNumFuncArguments, and getNumFuncResults can be called
-    /// safely.
+    /// 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 '" + getTypeAttrName() +
                            "' attribute of function type");
       return success();
     }
+
+    //===------------------------------------------------------------------===//
+    // SymbolOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    bool isDeclaration() { return isExternal(); }
   }];
   let parser = [{ return ::parseFuncOp(parser, result); }];
   let printer = [{ return ::print(*this, p); }];
   let verifier = [{ return ::verify(*this); }];
 }
 
 //===----------------------------------------------------------------------===//
 // ModuleOp

mlir/include/mlir/IR/BuiltinTypes.td

let extraClassDeclaration = [{
     /// Input types.
     unsigned getNumInputs() const;
     Type getInput(unsigned i) const { return getInputs()[i]; }
 
     /// Result types.
     unsigned getNumResults() const;
     Type getResult(unsigned i) const { return getResults()[i]; }
 
+    /// Returns a clone of this function type with the given argument
+    /// and result types.
+    FunctionType clone(TypeRange inputs, TypeRange results) const;
+
     /// Returns a new function type with the specified arguments and results
     /// inserted.
     FunctionType getWithArgsAndResults(ArrayRef<unsigned> argIndices,
                                        TypeRange argTypes,
                                        ArrayRef<unsigned> resultIndices,
                                        TypeRange resultTypes);
 
     /// Returns a new function type without the specified arguments and results.

mlir/include/mlir/IR/CMakeLists.txt

 mlir_tablegen(BuiltinTypes.cpp.inc -gen-typedef-defs)
 add_public_tablegen_target(MLIRBuiltinTypesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS BuiltinTypeInterfaces.td)
 mlir_tablegen(BuiltinTypeInterfaces.h.inc -gen-type-interface-decls)
 mlir_tablegen(BuiltinTypeInterfaces.cpp.inc -gen-type-interface-defs)
 add_public_tablegen_target(MLIRBuiltinTypeInterfacesIncGen)
 
+set(LLVM_TARGET_DEFINITIONS FunctionInterfaces.td)
+mlir_tablegen(FunctionOpInterfaces.h.inc -gen-op-interface-decls)
+mlir_tablegen(FunctionOpInterfaces.cpp.inc -gen-op-interface-defs)
+add_public_tablegen_target(MLIRFunctionInterfacesIncGen)
+add_dependencies(mlir-generic-headers MLIRFunctionInterfacesIncGen)
+
 set(LLVM_TARGET_DEFINITIONS SubElementInterfaces.td)
 mlir_tablegen(SubElementAttrInterfaces.h.inc -gen-attr-interface-decls)
 mlir_tablegen(SubElementAttrInterfaces.cpp.inc -gen-attr-interface-defs)
 mlir_tablegen(SubElementTypeInterfaces.h.inc -gen-type-interface-decls)
 mlir_tablegen(SubElementTypeInterfaces.cpp.inc -gen-type-interface-defs)
 add_public_tablegen_target(MLIRSubElementInterfacesIncGen)
 
 set(LLVM_TARGET_DEFINITIONS TensorEncoding.td)

mlir/include/mlir/IR/FunctionImplementation.h

 // operations, in particular, parsing, printing and verification components
 // common to function-like operations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_IR_FUNCTIONIMPLEMENTATION_H_
 #define MLIR_IR_FUNCTIONIMPLEMENTATION_H_
 
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/OpImplementation.h"
 
 namespace mlir {
 
-namespace function_like_impl {
+namespace function_interface_impl {
 
 /// A named class for passing around the variadic flag.
 class VariadicFlag {
 public:
   explicit VariadicFlag(bool variadic) : variadic(variadic) {}
   bool isVariadic() const { return variadic; }
 
 private:
   /// Underlying storage.
   bool variadic;
 };
 
 /// Adds argument and result attributes, provided as `argAttrs` and
 /// `resultAttrs` arguments, to the list of operation attributes in `result`.
 /// Internally, argument and result attributes are stored as dict attributes
 /// with special names given by getResultAttrName, getArgumentAttrName.
 void addArgAndResultAttrs(Builder &builder, OperationState &result,
                           ArrayRef<DictionaryAttr> argAttrs,
                           ArrayRef<DictionaryAttr> resultAttrs);
 void addArgAndResultAttrs(Builder &builder, OperationState &result,
                           ArrayRef<NamedAttrList> argAttrs,
                           ArrayRef<NamedAttrList> resultAttrs);
 
-/// Callback type for `parseFunctionLikeOp`, the callback should produce the
+/// Callback type for `parseFunctionOp`, the callback should produce the
 /// type that will be associated with a function-like operation from lists of
 /// function arguments and results, VariadicFlag indicates whether the function
 /// should have variadic arguments; in case of error, it may populate the last
 /// argument with a message.
 using FuncTypeBuilder = function_ref<Type(
     Builder &, ArrayRef<Type>, ArrayRef<Type>, VariadicFlag, std::string &)>;
 
 /// Parses function arguments using `parser`. The `allowVariadic` argument

 
 /// Parser implementation for function-like operations.  Uses
 /// `funcTypeBuilder` to construct the custom function type given lists of
 /// input and output types.  If `allowVariadic` is set, the parser will accept
 /// 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 parseFunctionLikeOp(OpAsmParser &parser, OperationState &result,
-                                bool allowVariadic,
-                                FuncTypeBuilder funcTypeBuilder);
+ParseResult parseFunctionOp(OpAsmParser &parser, OperationState &result,
 
 /// Printer implementation for function-like operations.  Accepts lists of
 /// argument and result types to use while printing.
-void printFunctionLikeOp(OpAsmPrinter &p, Operation *op,
-                         ArrayRef<Type> argTypes, bool isVariadic,
-                         ArrayRef<Type> resultTypes);
+void printFunctionOp(OpAsmPrinter &p, Operation *op, ArrayRef<Type> argTypes,
+                     bool isVariadic, ArrayRef<Type> resultTypes);
 
-/// Prints the signature of the function-like operation `op`.  Assumes `op` has
-/// the FunctionLike trait and passed the verification.
+/// 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
 /// attributes with names listed in "elided" as well as those used by the
 /// function-like operation internally are not printed. Nothing is printed
-/// if all attributes are elided. Assumes `op` has the `FunctionLike` trait and
-/// passed the verification.
+/// if all attributes are elided. Assumes `op` is a FunctionOpInterface and
+/// has passed verification.
 void printFunctionAttributes(OpAsmPrinter &p, Operation *op, unsigned numInputs,
                              unsigned numResults,
                              ArrayRef<StringRef> elided = {});
 
-} // namespace function_like_impl
+} // namespace function_interface_impl
 
 } // namespace mlir
 
 #endif // MLIR_IR_FUNCTIONIMPLEMENTATION_H_

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/BuiltinTypes.h"
+#include "mlir/IR/OpDefinition.h"
+#include "llvm/ADT/SmallString.h"
+
+namespace mlir {
+
+namespace function_interface_impl {
+
+/// Return the name of the attribute used for function types.
+inline StringRef getTypeAttrName() { return "type"; }
+
+/// Return the name of the attribute used for function argument attributes.
+inline StringRef getArgDictAttrName() { return "arg_attrs"; }
+
+/// Return the name of the attribute used for function argument attributes.
+inline StringRef getResultDictAttrName() { return "res_attrs"; }
+
+/// Returns the dictionary attribute corresponding to the argument at 'index'.
+/// If there are no argument attributes at 'index', a null attribute is
+/// returned.
+DictionaryAttr getArgAttrDict(Operation *op, unsigned index);
+
+/// Returns the dictionary attribute corresponding to the result at 'index'.
+/// If there are no result attributes at 'index', a null attribute is
+/// returned.
+DictionaryAttr getResultAttrDict(Operation *op, unsigned index);
+
+namespace detail {
+/// Update the given index into an argument or result attribute dictionary.
+void setArgResAttrDict(Operation *op, StringRef attrName,
+                       unsigned numTotalIndices, unsigned index,
+                       DictionaryAttr attrs);
+} // namespace detail
+
+/// Set all of the argument or result attribute dictionaries for a function. The
+/// size of `attrs` is expected to match the number of arguments/results of the
+/// given `op`.
+void setAllArgAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
+void setAllArgAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
+void setAllResultAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
+void setAllResultAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
+
+/// Return all of the attributes for the argument at 'index'.
+inline ArrayRef<NamedAttribute> getArgAttrs(Operation *op, unsigned index) {
+  auto argDict = getArgAttrDict(op, index);
+  return argDict ? argDict.getValue() : llvm::None;
+}
+
+/// Return all of the attributes for the result at 'index'.
+inline ArrayRef<NamedAttribute> getResultAttrs(Operation *op, unsigned index) {
+  auto resultDict = getResultAttrDict(op, index);
+  return resultDict ? resultDict.getValue() : llvm::None;
+}
+
+/// Insert the specified arguments and update the function type attribute.
+void insertFunctionArguments(Operation *op, ArrayRef<unsigned> argIndices,
+                             TypeRange argTypes,
+                             ArrayRef<DictionaryAttr> argAttrs,
+                             ArrayRef<Optional<Location>> argLocs,
+                             unsigned originalNumArgs, Type newType);
+
+/// Insert the specified results and update the function type attribute.
+void insertFunctionResults(Operation *op, ArrayRef<unsigned> resultIndices,
+                           TypeRange resultTypes,
+                           ArrayRef<DictionaryAttr> resultAttrs,
+                           unsigned originalNumResults, Type newType);
+
+/// Erase the specified arguments and update the function type attribute.
+void eraseFunctionArguments(Operation *op, ArrayRef<unsigned> argIndices,
+                            unsigned originalNumArgs, Type newType);
+
+/// Erase the specified results and update the function type attribute.
+void eraseFunctionResults(Operation *op, ArrayRef<unsigned> resultIndices,
+                          unsigned originalNumResults, Type newType);
+
+/// Set a FunctionOpInterface operation's type signature.
+void setFunctionType(Operation *op, Type newType);
+
+/// Insert a set of `newTypes` into `oldTypes` at the given `indices`. If any
+/// types are inserted, `storage` is used to hold the new type list. The new
+/// type list is returned. `indices` must be sorted by increasing index.
+TypeRange insertTypesInto(TypeRange oldTypes, ArrayRef<unsigned> indices,
+                          TypeRange newTypes, SmallVectorImpl<Type> &storage);
+
+/// Filters out any elements referenced by `indices`. If any types are removed,
+/// `storage` is used to hold the new type list. Returns the new type list.
+TypeRange filterTypesOut(TypeRange types, ArrayRef<unsigned> indices,
+                         SmallVectorImpl<Type> &storage);
+
+//===----------------------------------------------------------------------===//
+// Function Argument Attribute.
+//===----------------------------------------------------------------------===//
+
+/// Set the attributes held by the argument at 'index'.
+template <typename ConcreteType>
+void setArgAttrs(ConcreteType op, unsigned index,
+                 ArrayRef<NamedAttribute> attributes) {
+  assert(index < op.getNumArguments() && "invalid argument number");
+  return detail::setArgResAttrDict(
+      op, getArgDictAttrName(), op.getNumArguments(), index,
+      DictionaryAttr::get(op->getContext(), attributes));
+}
+template <typename ConcreteType>
+void setArgAttrs(ConcreteType op, unsigned index, DictionaryAttr attributes) {
+  return detail::setArgResAttrDict(
+      op, getArgDictAttrName(), op.getNumArguments(), index,
+      attributes ? attributes : DictionaryAttr::get(op->getContext()));
+}
+
+/// If the an attribute exists with the specified name, change it to the new
+/// value. Otherwise, add a new attribute with the specified name/value.
+template <typename ConcreteType>
+void setArgAttr(ConcreteType op, unsigned index, StringAttr name,
+                Attribute value) {
+  NamedAttrList attributes(op.getArgAttrDict(index));
+  Attribute oldValue = attributes.set(name, value);
+
+  // If the attribute changed, then set the new arg attribute list.
+  if (value != oldValue)
+    op.setArgAttrs(index, attributes.getDictionary(value.getContext()));
+}
+
+/// Remove the attribute 'name' from the argument at 'index'. Returns the
+/// removed attribute, or nullptr if `name` was not a valid attribute.
+template <typename ConcreteType>
+Attribute removeArgAttr(ConcreteType op, unsigned index, StringAttr name) {
+  // Build an attribute list and remove the attribute at 'name'.
+  NamedAttrList attributes(op.getArgAttrDict(index));
+  Attribute removedAttr = attributes.erase(name);
+
+  // If the attribute was removed, then update the argument dictionary.
+  if (removedAttr)
+    op.setArgAttrs(index, attributes.getDictionary(removedAttr.getContext()));
+  return removedAttr;
+}
+
+//===----------------------------------------------------------------------===//
+// Function Result Attribute.
+//===----------------------------------------------------------------------===//
+
+/// Set the attributes held by the result at 'index'.
+template <typename ConcreteType>
+void setResultAttrs(ConcreteType op, unsigned index,
+                    ArrayRef<NamedAttribute> attributes) {
+  assert(index < op.getNumResults() && "invalid result number");
+  return detail::setArgResAttrDict(
+      op, getResultDictAttrName(), op.getNumResults(), index,
+      DictionaryAttr::get(op->getContext(), attributes));
+}
+
+template <typename ConcreteType>
+void setResultAttrs(ConcreteType op, unsigned index,
+                    DictionaryAttr attributes) {
+  assert(index < op.getNumResults() && "invalid result number");
+  return detail::setArgResAttrDict(
+      op, getResultDictAttrName(), op.getNumResults(), index,
+      attributes ? attributes : DictionaryAttr::get(op->getContext()));
+}
+
+/// If the an attribute exists with the specified name, change it to the new
+/// value. Otherwise, add a new attribute with the specified name/value.
+template <typename ConcreteType>
+void setResultAttr(ConcreteType op, unsigned index, StringAttr name,
+                   Attribute value) {
+  NamedAttrList attributes(op.getResultAttrDict(index));
+  Attribute oldAttr = attributes.set(name, value);
+
+  // If the attribute changed, then set the new arg attribute list.
+  if (oldAttr != value)
+    op.setResultAttrs(index, attributes.getDictionary(value.getContext()));
+}
+
+/// Remove the attribute 'name' from the result at 'index'.
+template <typename ConcreteType>
+Attribute removeResultAttr(ConcreteType op, unsigned index, StringAttr name) {
+  // Build an attribute list and remove the attribute at 'name'.
+  NamedAttrList attributes(op.getResultAttrDict(index));
+  Attribute removedAttr = attributes.erase(name);
+
+  // If the attribute was removed, then update the result dictionary.
+  if (removedAttr)
+    op.setResultAttrs(index,
+                      attributes.getDictionary(removedAttr.getContext()));
+  return removedAttr;
+}
+
+/// This function defines the internal implementation of the `verifyTrait`
+/// method on FunctionOpInterface::Trait.
+template <typename ConcreteOp>
+LogicalResult verifyTrait(ConcreteOp op) {
+  if (!op.getTypeAttr())
+    return op.emitOpError("requires a type attribute '")
+           << ConcreteOp::getTypeAttrName() << '\'';
+
+  if (failed(op.verifyType()))
+    return failure();
+
+  if (ArrayAttr allArgAttrs = op.getAllArgAttrs()) {
+    unsigned numArgs = op.getNumArguments();
+    if (allArgAttrs.size() != numArgs) {
+      return op.emitOpError()
+             << "expects argument attribute array `" << getArgDictAttrName()
+             << "` to have the same number of elements as the number of "
+                "function arguments, got "
+             << allArgAttrs.size() << ", but expected " << numArgs;
+    }
+    for (unsigned i = 0; i != numArgs; ++i) {
+      DictionaryAttr argAttrs =
+          allArgAttrs[i].dyn_cast_or_null<DictionaryAttr>();
+      if (!argAttrs) {
+        return op.emitOpError() << "expects argument attribute dictionary "
+                                   "to be a DictionaryAttr, but got `"
+                                << allArgAttrs[i] << "`";
+      }
+
+      // Verify that all of the argument attributes are dialect attributes, i.e.
+      // that they contain a dialect prefix in their name.  Call the dialect, if
+      // registered, to verify the attributes themselves.
+      for (auto attr : argAttrs) {
+        if (!attr.getName().strref().contains('.'))
+          return op.emitOpError("arguments may only have dialect attributes");
+        if (Dialect *dialect = attr.getNameDialect()) {
+          if (failed(dialect->verifyRegionArgAttribute(op, /*regionIndex=*/0,
+                                                       /*argIndex=*/i, attr)))
+            return failure();
+        }
+      }
+    }
+  }
+  if (ArrayAttr allResultAttrs = op.getAllResultAttrs()) {
+    unsigned numResults = op.getNumResults();
+    if (allResultAttrs.size() != numResults) {
+      return op.emitOpError()
+             << "expects result attribute array `" << getResultDictAttrName()
+             << "` to have the same number of elements as the number of "
+                "function results, got "
+             << allResultAttrs.size() << ", but expected " << numResults;
+    }
+    for (unsigned i = 0; i != numResults; ++i) {
+      DictionaryAttr resultAttrs =
+          allResultAttrs[i].dyn_cast_or_null<DictionaryAttr>();
+      if (!resultAttrs) {
+        return op.emitOpError() << "expects result attribute dictionary "
+                                   "to be a DictionaryAttr, but got `"
+                                << allResultAttrs[i] << "`";
+      }
+
+      // Verify that all of the result attributes are dialect attributes, i.e.
+      // that they contain a dialect prefix in their name.  Call the dialect, if
+      // registered, to verify the attributes themselves.
+      for (auto attr : resultAttrs) {
+        if (!attr.getName().strref().contains('.'))
+          return op.emitOpError("results may only have dialect attributes");
+        if (Dialect *dialect = attr.getNameDialect()) {
+          if (failed(dialect->verifyRegionResultAttribute(op, /*regionIndex=*/0,
+                                                          /*resultIndex=*/i,
+                                                          attr)))
+            return failure();
+        }
+      }
+    }
+  }
+
+  // Check that the op has exactly one region for the body.
+  if (op->getNumRegions() != 1)
+    return op.emitOpError("expects one region");
+
+  return op.verifyBody();
+}
+} // namespace function_interface_impl
+} // namespace mlir
+
+//===----------------------------------------------------------------------===//
+// Tablegen Interface Declarations
+//===----------------------------------------------------------------------===//
+
+#include "mlir/IR/FunctionOpInterfaces.h.inc"
+
+#endif // MLIR_IR_FUNCTIONINTERFACES_H

mlir/include/mlir/IR/FunctionInterfaces.td

+//===- FunctionInterfaces.td - Function interfaces --------*- 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 contains definitions for interfaces that support the definition of
+// "function-like" operations.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_IR_FUNCTIONINTERFACES_TD_
+#define MLIR_IR_FUNCTIONINTERFACES_TD_
+
+include "mlir/IR/OpBase.td"
+
+//===----------------------------------------------------------------------===//
+// FunctionOpInterface
+//===----------------------------------------------------------------------===//
+
+def FunctionOpInterface : OpInterface<"FunctionOpInterface"> {
+  let cppNamespace = "::mlir";
+  let description = [{
+    This interfaces provides support for interacting with operations that
+    behave like functions. In particular, these operations:
+
+      - must be symbols, i.e. have the `Symbol` trait.
+      - must have a single region, that may be comprised with multiple blocks,
+        that corresponds to the function body.
+        * when this region is empty, the operation corresponds to an external
+          function.
+        * leading arguments of the first block of the region are treated as
+          function arguments.
+
+    The function, aside from implementing the various interface methods,
+    should have the following ODS arguments:
+
+      - `type` (required)
+        * A TypeAttr that holds the signature type of the function.
+        * TODO: this field will soon be renamed to something less generic.
+
+      - `arg_attrs` (optional)
+        * An ArrayAttr of DictionaryAttr that contains attribute dictionaries
+          for each of the function arguments.
+
+      - `res_attrs` (optional)
+        * An ArrayAttr of DictionaryAttr that contains attribute dictionaries
+          for each of the function results.
+  }];
+  let methods = [
+    InterfaceMethod<[{
+      Returns the function argument types based exclusively on
+      the type (to allow for this method may be called on function
+      declarations).
+    }],
+    "ArrayRef<Type>", "getArgumentTypes">,
+    InterfaceMethod<[{
+      Returns the function result types based exclusively on
+      the type (to allow for this method may be called on function
+      declarations).
+    }],
+    "ArrayRef<Type>", "getResultTypes">,
+    InterfaceMethod<[{
+      Returns a clone of the function type with the given argument and
+      result types.
+
+      Note: The default implementation assumes the function type has
+            an appropriate clone method:
+              `Type clone(ArrayRef<Type> inputs, ArrayRef<Type> results)`
+    }],
+    "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.
+    }],
+    "::mlir::LogicalResult", "verifyBody", (ins),
+    /*methodBody=*/[{}], /*defaultImplementation=*/[{
+      if ($_op.isExternal())
+        return success();
+
+      unsigned numArguments = $_op.getNumArguments();
+      if ($_op.front().getNumArguments() != numArguments)
+        return $_op.emitOpError("entry block must have ")
+              << numArguments << " arguments to match function signature";
+      return success();
+    }]>,
+    InterfaceMethod<[{
+      Verify the type attribute of the function for derived op-specific
+      invariants.
+    }],
+    "::mlir::LogicalResult", "verifyType">,
+  ];
+
+  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;
+    using args_iterator = BlockArgListType::iterator;
+
+    //===------------------------------------------------------------------===//
+    // Body Handling
+    //===------------------------------------------------------------------===//
+
+    /// Returns true if this function is external, i.e. it has no body.
+    bool isExternal() { return empty(); }
+
+    /// Return the region containing the body of this function.
+    Region &getBody() { return $_op->getRegion(0); }
+
+    /// Delete all blocks from this function.
+    void eraseBody() {
+      getBody().dropAllReferences();
+      getBody().getBlocks().clear();
+    }
+
+    /// Return the list of blocks within the function body.
+    BlockListType &getBlocks() { return getBody().getBlocks(); }
+
+    iterator begin() { return getBody().begin(); }
+    iterator end() { return getBody().end(); }
+    reverse_iterator rbegin() { return getBody().rbegin(); }
+    reverse_iterator rend() { return getBody().rend(); }
+
+    /// Returns true if this function has no blocks within the body.
+    bool empty() { return getBody().empty(); }
+
+    /// Push a new block to the back of the body region.
+    void push_back(Block *block) { getBody().push_back(block); }
+
+    /// Push a new block to the front of the body region.
+    void push_front(Block *block) { getBody().push_front(block); }
+
+    /// Return the last block in the body region.
+    Block &back() { return getBody().back(); }
+
+    /// Return the first block in the body region.
+    Block &front() { return getBody().front(); }
+
+    /// Add an entry block to an empty function, and set up the block arguments
+    /// to match the signature of the function. The newly inserted entry block
+    /// is returned.
+    Block *addEntryBlock() {
+      assert(empty() && "function already has an entry block");
+      Block *entry = new Block();
+      push_back(entry);
+      entry->addArguments($_op.getArgumentTypes());
+      return entry;
+    }
+
+    /// Add a normal block to the end of the function's block list. The function
+    /// should at least already have an entry block.
+    Block *addBlock() {
+      assert(!empty() && "function should at least have an entry block");
+      push_back(new Block());
+      return &back();
+    }
+
+    //===------------------------------------------------------------------===//
+    // Type Attribute Handling
+    //===------------------------------------------------------------------===//
+
+    /// Change the type of this function in place. This is an extremely dangerous
+    /// operation and it is up to the caller to ensure that this is legal for
+    /// this function, and to restore invariants:
+    ///  - the entry block args must be updated to match the function params.
+    ///  - the argument/result attributes may need an update: if the new type
+    ///    has less parameters we drop the extra attributes, if there are more
+    ///    parameters they won't have any attributes.
+    void setType(Type newType) {
+      function_interface_impl::setFunctionType(this->getOperation(), newType);
+    }
+
+    // FIXME: These functions should be removed in favor of just forwarding to
+    // the derived operation, which should already have these defined
+    // (via ODS).
+
+    /// Returns the name of the attribute used for function types.
+    static StringRef getTypeAttrName() {
+      return function_interface_impl::getTypeAttrName();
+    }
+
+    /// Returns the name of the attribute used for function argument attributes.
+    static StringRef getArgDictAttrName() {
+      return function_interface_impl::getArgDictAttrName();
+    }
+
+    /// Returns the name of the attribute used for function argument attributes.
+    static StringRef getResultDictAttrName() {
+      return function_interface_impl::getResultDictAttrName();
+    }
+
+    /// Return the attribute containing the type of this function.
+    TypeAttr getTypeAttr() {
+      return this->getOperation()->template getAttrOfType<TypeAttr>(
+          getTypeAttrName());
+    }
+
+    /// Return the type of this function.
+    Type getType() { return getTypeAttr().getValue(); }
+
+    //===------------------------------------------------------------------===//
+    // Argument and Result Handling
+    //===------------------------------------------------------------------===//
+
+    /// Returns the number of function arguments.
+    unsigned getNumArguments() { return $_op.getArgumentTypes().size(); }
+
+    /// Returns the number of function results.
+    unsigned getNumResults() { return $_op.getResultTypes().size(); }
+
+    /// Returns the entry block function argument at the given index.
+    BlockArgument getArgument(unsigned idx) {
+      return getBody().getArgument(idx);
+    }
+
+    /// Support argument iteration.
+    args_iterator args_begin() { return getBody().args_begin(); }
+    args_iterator args_end() { return getBody().args_end(); }
+    BlockArgListType getArguments() { return getBody().getArguments(); }
+
+    /// Insert a single argument of type `argType` with attributes `argAttrs` and
+    /// location `argLoc` at `argIndex`.
+    void insertArgument(unsigned argIndex, Type argType, DictionaryAttr argAttrs,
+                        Optional<Location> argLoc = {}) {
+      insertArguments({argIndex}, {argType}, {argAttrs}, {argLoc});
+    }
+
+    /// Inserts arguments with the listed types, attributes, and locations at the
+    /// listed indices. `argIndices` must be sorted. Arguments are inserted in the
+    /// order they are listed, such that arguments with identical index will
+    /// appear in the same order that they were listed here.
+    void insertArguments(ArrayRef<unsigned> argIndices, TypeRange argTypes,
+                        ArrayRef<DictionaryAttr> argAttrs,
+                        ArrayRef<Optional<Location>> argLocs) {
+      unsigned originalNumArgs = $_op.getNumArguments();
+      Type newType = $_op.getTypeWithArgsAndResults(
+          argIndices, argTypes, /*resultIndices=*/{}, /*resultTypes=*/{});
+      function_interface_impl::insertFunctionArguments(
+          this->getOperation(), argIndices, argTypes, argAttrs, argLocs,
+          originalNumArgs, newType);
+    }
+
+    /// Insert a single result of type `resultType` at `resultIndex`.
+    void insertResult(unsigned resultIndex, Type resultType,
+                      DictionaryAttr resultAttrs) {
+      insertResults({resultIndex}, {resultType}, {resultAttrs});
+    }
+
+    /// Inserts results with the listed types at the listed indices.
+    /// `resultIndices` must be sorted. Results are inserted in the order they are
+    /// listed, such that results with identical index will appear in the same
+    /// order that they were listed here.
+    void insertResults(ArrayRef<unsigned> resultIndices, TypeRange resultTypes,
+                      ArrayRef<DictionaryAttr> resultAttrs) {
+      unsigned originalNumResults = $_op.getNumResults();
+      Type newType = $_op.getTypeWithArgsAndResults(
+        /*argIndices=*/{}, /*argTypes=*/{}, resultIndices, resultTypes);
+      function_interface_impl::insertFunctionResults(
+          this->getOperation(), resultIndices, resultTypes, resultAttrs,
+          originalNumResults, newType);
+    }
+
+    /// Erase a single argument at `argIndex`.
+    void eraseArgument(unsigned argIndex) { eraseArguments({argIndex}); }
+
+    /// Erases the arguments listed in `argIndices`.
+    /// `argIndices` is allowed to have duplicates and can be in any order.
+    void eraseArguments(ArrayRef<unsigned> argIndices) {
+      unsigned originalNumArgs = $_op.getNumArguments();
+      Type newType = $_op.getTypeWithoutArgsAndResults(argIndices, {});
+      function_interface_impl::eraseFunctionArguments(this->getOperation(), argIndices,
+                                                originalNumArgs, newType);
+    }
+
+    /// Erase a single result at `resultIndex`.
+    void eraseResult(unsigned resultIndex) { eraseResults({resultIndex}); }
+
+    /// Erases the results listed in `resultIndices`.
+    /// `resultIndices` is allowed to have duplicates and can be in any order.
+    void eraseResults(ArrayRef<unsigned> resultIndices) {
+      unsigned originalNumResults = $_op.getNumResults();
+      Type newType = $_op.getTypeWithoutArgsAndResults({}, resultIndices);
+      function_interface_impl::eraseFunctionResults(
+          this->getOperation(), resultIndices, originalNumResults, newType);
+    }
+
+    /// Return the type of this function with the specified arguments and
+    /// results inserted. This is used to update the function's signature in
+    /// the `insertArguments` and `insertResults` methods. The arrays must be
+    /// sorted by increasing index.
+    Type getTypeWithArgsAndResults(
+      ArrayRef<unsigned> argIndices, TypeRange argTypes,
+      ArrayRef<unsigned> resultIndices, TypeRange resultTypes) {
+      SmallVector<Type> argStorage, resultStorage;
+      TypeRange newArgTypes = function_interface_impl::insertTypesInto(
+          $_op.getArgumentTypes(), argIndices, argTypes, argStorage);
+      TypeRange newResultTypes = function_interface_impl::insertTypesInto(
+          $_op.getResultTypes(), resultIndices, resultTypes, resultStorage);
+      return $_op.cloneTypeWith(newArgTypes, newResultTypes);
+    }
+
+    /// Return the type of this function without the specified arguments and
+    /// results. This is used to update the function's signature in the
+    /// `eraseArguments` and `eraseResults` methods. The arrays of indices are
+    /// allowed to have duplicates and can be in any order.
+    Type getTypeWithoutArgsAndResults(
+      ArrayRef<unsigned> argIndices, ArrayRef<unsigned> resultIndices) {
+      SmallVector<Type> argStorage, resultStorage;
+      TypeRange newArgTypes = function_interface_impl::filterTypesOut(
+          $_op.getArgumentTypes(), argIndices, argStorage);
+      TypeRange newResultTypes = function_interface_impl::filterTypesOut(
+          $_op.getResultTypes(), resultIndices, resultStorage);
+      return $_op.cloneTypeWith(newArgTypes, newResultTypes);
+    }
+
+    //===------------------------------------------------------------------===//
+    // Argument Attributes
+    //===------------------------------------------------------------------===//
+
+    /// Return all of the attributes for the argument at 'index'.
+    ArrayRef<NamedAttribute> getArgAttrs(unsigned index) {
+      return function_interface_impl::getArgAttrs(this->getOperation(), index);
+    }
+
+    /// Return an ArrayAttr containing all argument attribute dictionaries of
+    /// this function, or nullptr if no arguments have attributes.
+    ArrayAttr getAllArgAttrs() {
+      return this->getOperation()->template getAttrOfType<ArrayAttr>(
+          getArgDictAttrName());
+    }
+    /// Return all argument attributes of this function.
+    void getAllArgAttrs(SmallVectorImpl<DictionaryAttr> &result) {
+      if (ArrayAttr argAttrs = getAllArgAttrs()) {
+        auto argAttrRange = argAttrs.template getAsRange<DictionaryAttr>();
+        result.append(argAttrRange.begin(), argAttrRange.end());
+      } else {
+        result.append($_op.getNumArguments(),
+                      DictionaryAttr::get(this->getOperation()->getContext()));
+      }
+    }
+
+    /// Return the specified attribute, if present, for the argument at 'index',
+    /// null otherwise.
+    Attribute getArgAttr(unsigned index, StringAttr name) {
+      auto argDict = getArgAttrDict(index);
+      return argDict ? argDict.get(name) : nullptr;
+    }
+    Attribute getArgAttr(unsigned index, StringRef name) {
+      auto argDict = getArgAttrDict(index);
+      return argDict ? argDict.get(name) : nullptr;
+    }
+
+    template <typename AttrClass>
+    AttrClass getArgAttrOfType(unsigned index, StringAttr name) {
+      return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
+    }
+    template <typename AttrClass>
+    AttrClass getArgAttrOfType(unsigned index, StringRef name) {
+      return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
+    }
+
+    /// Set the attributes held by the argument at 'index'.
+    void setArgAttrs(unsigned index, ArrayRef<NamedAttribute> attributes) {
+      function_interface_impl::setArgAttrs($_op, index, attributes);
+    }
+
+    /// Set the attributes held by the argument at 'index'. `attributes` may be
+    /// null, in which case any existing argument attributes are removed.
+    void setArgAttrs(unsigned index, DictionaryAttr attributes) {
+      function_interface_impl::setArgAttrs($_op, index, attributes);
+    }
+    void setAllArgAttrs(ArrayRef<DictionaryAttr> attributes) {
+      assert(attributes.size() == $_op.getNumArguments());
+      function_interface_impl::setAllArgAttrDicts(this->getOperation(), attributes);
+    }
+    void setAllArgAttrs(ArrayRef<Attribute> attributes) {
+      assert(attributes.size() == $_op.getNumArguments());
+      function_interface_impl::setAllArgAttrDicts(this->getOperation(), attributes);
+    }
+    void setAllArgAttrs(ArrayAttr attributes) {
+      assert(attributes.size() == $_op.getNumArguments());
+      this->getOperation()->setAttr(getArgDictAttrName(), attributes);
+    }
+
+    /// If the an attribute exists with the specified name, change it to the new
+    /// value. Otherwise, add a new attribute with the specified name/value.
+    void setArgAttr(unsigned index, StringAttr name, Attribute value) {
+      function_interface_impl::setArgAttr($_op, index, name, value);
+    }
+    void setArgAttr(unsigned index, StringRef name, Attribute value) {
+      setArgAttr(index,
+                 StringAttr::get(this->getOperation()->getContext(), name),
+                 value);
+    }
+
+    /// Remove the attribute 'name' from the argument at 'index'. Return the
+    /// attribute that was erased, or nullptr if there was no attribute with
+    /// such name.
+    Attribute removeArgAttr(unsigned index, StringAttr name) {
+      return function_interface_impl::removeArgAttr($_op, index, name);
+    }
+    Attribute removeArgAttr(unsigned index, StringRef name) {
+      return removeArgAttr(
+          index, StringAttr::get(this->getOperation()->getContext(), name));
+    }
+
+    //===------------------------------------------------------------------===//
+    // Result Attributes
+    //===------------------------------------------------------------------===//
+
+    /// Return all of the attributes for the result at 'index'.
+    ArrayRef<NamedAttribute> getResultAttrs(unsigned index) {
+      return function_interface_impl::getResultAttrs(this->getOperation(), index);
+    }
+
+    /// Return an ArrayAttr containing all result attribute dictionaries of this
+    /// function, or nullptr if no result have attributes.
+    ArrayAttr getAllResultAttrs() {
+      return this->getOperation()->template getAttrOfType<ArrayAttr>(
+          getResultDictAttrName());
+    }
+    /// Return all result attributes of this function.
+    void getAllResultAttrs(SmallVectorImpl<DictionaryAttr> &result) {
+      if (ArrayAttr argAttrs = getAllResultAttrs()) {
+        auto argAttrRange = argAttrs.template getAsRange<DictionaryAttr>();
+        result.append(argAttrRange.begin(), argAttrRange.end());
+      } else {
+        result.append($_op.getNumResults(),
+                      DictionaryAttr::get(this->getOperation()->getContext()));
+      }
+    }
+
+    /// Return the specified attribute, if present, for the result at 'index',
+    /// null otherwise.
+    Attribute getResultAttr(unsigned index, StringAttr name) {
+      auto argDict = getResultAttrDict(index);
+      return argDict ? argDict.get(name) : nullptr;
+    }
+    Attribute getResultAttr(unsigned index, StringRef name) {
+      auto argDict = getResultAttrDict(index);
+      return argDict ? argDict.get(name) : nullptr;
+    }
+
+    template <typename AttrClass>
+    AttrClass getResultAttrOfType(unsigned index, StringAttr name) {
+      return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
+    }
+    template <typename AttrClass>
+    AttrClass getResultAttrOfType(unsigned index, StringRef name) {
+      return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
+    }
+
+    /// Set the attributes held by the result at 'index'.
+    void setResultAttrs(unsigned index, ArrayRef<NamedAttribute> attributes) {
+      function_interface_impl::setResultAttrs($_op, index, attributes);
+    }
+
+    /// Set the attributes held by the result at 'index'. `attributes` may be
+    /// null, in which case any existing argument attributes are removed.
+    void setResultAttrs(unsigned index, DictionaryAttr attributes) {
+      function_interface_impl::setResultAttrs($_op, index, attributes);
+    }
+    void setAllResultAttrs(ArrayRef<DictionaryAttr> attributes) {
+      assert(attributes.size() == $_op.getNumResults());
+      function_interface_impl::setAllResultAttrDicts(
+        this->getOperation(), attributes);
+    }
+    void setAllResultAttrs(ArrayRef<Attribute> attributes) {
+      assert(attributes.size() == $_op.getNumResults());
+      function_interface_impl::setAllResultAttrDicts(
+        this->getOperation(), attributes);
+    }
+    void setAllResultAttrs(ArrayAttr attributes) {
+      assert(attributes.size() == $_op.getNumResults());
+      this->getOperation()->setAttr(getResultDictAttrName(), attributes);
+    }
+
+    /// If the an attribute exists with the specified name, change it to the new
+    /// value. Otherwise, add a new attribute with the specified name/value.
+    void setResultAttr(unsigned index, StringAttr name, Attribute value) {
+      function_interface_impl::setResultAttr($_op, index, name, value);
+    }
+    void setResultAttr(unsigned index, StringRef name, Attribute value) {
+      setResultAttr(index,
+                    StringAttr::get(this->getOperation()->getContext(), name),
+                    value);
+    }
+
+    /// Remove the attribute 'name' from the result at 'index'. Return the
+    /// attribute that was erased, or nullptr if there was no attribute with
+    /// such name.
+    Attribute removeResultAttr(unsigned index, StringAttr name) {
+      return function_interface_impl::removeResultAttr($_op, index, name);
+    }
+
+    /// Returns the dictionary attribute corresponding to the argument at
+    /// 'index'. If there are no argument attributes at 'index', a null
+    /// attribute is returned.
+    DictionaryAttr getArgAttrDict(unsigned index) {
+      assert(index < $_op.getNumArguments() && "invalid argument number");
+      return function_interface_impl::getArgAttrDict(this->getOperation(), index);
+    }
+
+    /// Returns the dictionary attribute corresponding to the result at 'index'.
+    /// If there are no result attributes at 'index', a null attribute is
+    /// returned.
+    DictionaryAttr getResultAttrDict(unsigned index) {
+      assert(index < $_op.getNumResults() && "invalid result number");
+      return function_interface_impl::getResultAttrDict(this->getOperation(), index);
+    }
+  }];
+
+  let verify = "return function_interface_impl::verifyTrait(cast<ConcreteOp>($_op));";
+}
+
+#endif // MLIR_IR_FUNCTIONINTERFACES_TD_

mlir/include/mlir/IR/FunctionSupport.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_FUNCTIONSUPPORT_H
-#define MLIR_IR_FUNCTIONSUPPORT_H
-
-#include "mlir/IR/BuiltinTypes.h"
-#include "mlir/IR/OpDefinition.h"
-#include "llvm/ADT/SmallString.h"
-
-namespace mlir {
-
-namespace function_like_impl {
-
-/// Return the name of the attribute used for function types.
-inline StringRef getTypeAttrName() { return "type"; }
-
-/// Return the name of the attribute used for function argument attributes.
-inline StringRef getArgDictAttrName() { return "arg_attrs"; }
-
-/// Return the name of the attribute used for function argument attributes.
-inline StringRef getResultDictAttrName() { return "res_attrs"; }
-
-/// Returns the dictionary attribute corresponding to the argument at 'index'.
-/// If there are no argument attributes at 'index', a null attribute is
-/// returned.
-DictionaryAttr getArgAttrDict(Operation *op, unsigned index);
-
-/// Returns the dictionary attribute corresponding to the result at 'index'.
-/// If there are no result attributes at 'index', a null attribute is
-/// returned.
-DictionaryAttr getResultAttrDict(Operation *op, unsigned index);
-
-namespace detail {
-/// Update the given index into an argument or result attribute dictionary.
-void setArgResAttrDict(Operation *op, StringRef attrName,
-                       unsigned numTotalIndices, unsigned index,
-                       DictionaryAttr attrs);
-} // namespace detail
-
-/// Set all of the argument or result attribute dictionaries for a function. The
-/// size of `attrs` is expected to match the number of arguments/results of the
-/// given `op`.
-void setAllArgAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
-void setAllArgAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
-void setAllResultAttrDicts(Operation *op, ArrayRef<DictionaryAttr> attrs);
-void setAllResultAttrDicts(Operation *op, ArrayRef<Attribute> attrs);
-
-/// Return all of the attributes for the argument at 'index'.
-inline ArrayRef<NamedAttribute> getArgAttrs(Operation *op, unsigned index) {
-  auto argDict = getArgAttrDict(op, index);
-  return argDict ? argDict.getValue() : llvm::None;
-}
-
-/// Return all of the attributes for the result at 'index'.
-inline ArrayRef<NamedAttribute> getResultAttrs(Operation *op, unsigned index) {
-  auto resultDict = getResultAttrDict(op, index);
-  return resultDict ? resultDict.getValue() : llvm::None;
-}
-
-/// Insert the specified arguments and update the function type attribute.
-void insertFunctionArguments(Operation *op, ArrayRef<unsigned> argIndices,
-                             TypeRange argTypes,
-                             ArrayRef<DictionaryAttr> argAttrs,
-                             ArrayRef<Optional<Location>> argLocs,
-                             unsigned originalNumArgs, Type newType);
-
-/// Insert the specified results and update the function type attribute.
-void insertFunctionResults(Operation *op, ArrayRef<unsigned> resultIndices,
-                           TypeRange resultTypes,
-                           ArrayRef<DictionaryAttr> resultAttrs,
-                           unsigned originalNumResults, Type newType);
-
-/// Erase the specified arguments and update the function type attribute.
-void eraseFunctionArguments(Operation *op, ArrayRef<unsigned> argIndices,
-                            unsigned originalNumArgs, Type newType);
-
-/// Erase the specified results and update the function type attribute.
-void eraseFunctionResults(Operation *op, ArrayRef<unsigned> resultIndices,
-                          unsigned originalNumResults, Type newType);
-
-/// Get and set a FunctionLike operation's type signature.
-FunctionType getFunctionType(Operation *op);
-void setFunctionType(Operation *op, FunctionType newType);
-
-/// Get a FunctionLike operation's body.
-Region &getFunctionBody(Operation *op);
-
-} // namespace function_like_impl
-
-namespace OpTrait {
-
-/// This trait provides APIs for Ops that behave like functions.  In particular:
-/// - Ops must be symbols, i.e. also have the `Symbol` trait;
-/// - Ops have a single region with multiple blocks that corresponds to the body
-///   of the function;
-/// - An op with a single empty region corresponds to an external function;
-/// - leading arguments of the first block of the region are treated as function
-///   arguments;
-/// - they can have argument attributes that are stored in a dictionary
-///   attribute on the Op itself.
-///
-/// This trait provides limited type support for the declared or defined
-/// functions. The convenience function `getTypeAttrName()` returns the name of
-/// an attribute that can be used to store the function type. In addition, this
-/// trait provides `getType` and `setType` helpers to store a `FunctionType` in
-/// the attribute named by `getTypeAttrName()`.
-///
-/// In general, this trait assumes concrete ops use `FunctionType` under the
-/// hood. If this is not the case, in order to use the function type support,
-/// concrete ops must define the following methods, using the same name, to hide
-/// the ones defined for `FunctionType`: `addBodyBlock`, `getType`,
-/// `getTypeWithoutArgsAndResults` and `setType`.
-///
-/// Besides the requirements above, concrete ops must interact with this trait
-/// using the following functions:
-/// - Concrete ops *must* define a member function `getNumFuncArguments()` that
-///   returns the number of function arguments based exclusively on type (so
-///   that it can be called on function declarations).
-/// - Concrete ops *must* define a member function `getNumFuncResults()` that
-///   returns the number of function results based exclusively on type (so that
-///   it can be called on function declarations).
-/// - To verify that the type respects op-specific invariants, concrete ops may
-///   redefine the `verifyType()` hook that will be called after verifying the
-///   presence of the `type` attribute and before any call to
-///   `getNumFuncArguments`/`getNumFuncResults` from the verifier.
-/// - To verify that the body respects op-specific invariants, concrete ops may
-///   redefine the `verifyBody()` hook that will be called after verifying the
-///   function type and the presence of the (potentially empty) body region.
-template <typename ConcreteType>
-class FunctionLike : public OpTrait::TraitBase<ConcreteType, FunctionLike> {
-public:
-  /// Verify that all of the argument attributes are dialect attributes.
-  static LogicalResult verifyTrait(Operation *op);
-
-  //===--------------------------------------------------------------------===//
-  // Body Handling
-  //===--------------------------------------------------------------------===//
-
-  /// Returns true if this function is external, i.e. it has no body.
-  bool isExternal() { return empty(); }
-
-  Region &getBody() {
-    return function_like_impl::getFunctionBody(this->getOperation());
-  }
-
-  /// Delete all blocks from this function.
-  void eraseBody() {
-    getBody().dropAllReferences();
-    getBody().getBlocks().clear();
-  }
-
-  /// This is the list of blocks in the function.
-  using BlockListType = Region::BlockListType;
-  BlockListType &getBlocks() { return getBody().getBlocks(); }
-
-  // Iteration over the block in the function.
-  using iterator = BlockListType::iterator;
-  using reverse_iterator = BlockListType::reverse_iterator;
-
-  iterator begin() { return getBody().begin(); }
-  iterator end() { return getBody().end(); }
-  reverse_iterator rbegin() { return getBody().rbegin(); }
-  reverse_iterator rend() { return getBody().rend(); }
-
-  bool empty() { return getBody().empty(); }
-  void push_back(Block *block) { getBody().push_back(block); }
-  void push_front(Block *block) { getBody().push_front(block); }
-
-  Block &back() { return getBody().back(); }
-  Block &front() { return getBody().front(); }
-
-  /// Add an entry block to an empty function, and set up the block arguments
-  /// to match the signature of the function. The newly inserted entry block
-  /// is returned.
-  ///
-  /// Note that the concrete class must define a method with the same name to
-  /// hide this one if the concrete class does not use FunctionType for the
-  /// function type under the hood.
-  Block *addEntryBlock();
-
-  /// Add a normal block to the end of the function's block list. The function
-  /// should at least already have an entry block.
-  Block *addBlock();
-
-  /// Hook for concrete ops to verify the contents of the body. Called as a
-  /// part of trait verification, after type verification and ensuring that a
-  /// region exists.
-  LogicalResult verifyBody();
-
-  //===--------------------------------------------------------------------===//
-  // Type Attribute Handling
-  //===--------------------------------------------------------------------===//
-
-  /// Return the name of the attribute used for function types.
-  static StringRef getTypeAttrName() {
-    return function_like_impl::getTypeAttrName();
-  }
-
-  TypeAttr getTypeAttr() {
-    return this->getOperation()->template getAttrOfType<TypeAttr>(
-        getTypeAttrName());
-  }
-
-  /// Return the type of this function.
-  ///
-  /// Note that the concrete class must define a method with the same name to
-  /// hide this one if the concrete class does not use FunctionType for the
-  /// function type under the hood.
-  FunctionType getType() {
-    return function_like_impl::getFunctionType(this->getOperation());
-  }
-
-  /// Return the type of this function with the specified arguments and results
-  /// inserted. This is used to update the function's signature in the
-  /// `insertArguments` and `insertResults` methods. The arrays must be sorted
-  /// by increasing index.
-  ///
-  /// Note that the concrete class must define a method with the same name to
-  /// hide this one if the concrete class does not use FunctionType for the
-  /// function type under the hood.
-  FunctionType getTypeWithArgsAndResults(ArrayRef<unsigned> argIndices,
-                                         TypeRange argTypes,
-                                         ArrayRef<unsigned> resultIndices,
-                                         TypeRange resultTypes) {
-    return getType().getWithArgsAndResults(argIndices, argTypes, resultIndices,
-                                           resultTypes);
-  }
-
-  /// Return the type of this function without the specified arguments and
-  /// results. This is used to update the function's signature in the
-  /// `eraseArguments` and `eraseResults` methods. The arrays of indices are
-  /// allowed to have duplicates and can be in any order.
-  ///
-  /// Note that the concrete class must define a method with the same name to
-  /// hide this one if the concrete class does not use FunctionType for the
-  /// function type under the hood.
-  FunctionType getTypeWithoutArgsAndResults(ArrayRef<unsigned> argIndices,
-                                            ArrayRef<unsigned> resultIndices) {
-    return getType().getWithoutArgsAndResults(argIndices, resultIndices);
-  }
-
-  bool isTypeAttrValid() {
-    auto typeAttr = getTypeAttr();
-    if (!typeAttr)
-      return false;
-    return typeAttr.getValue() != Type{};
-  }
-
-  /// Change the type of this function in place. This is an extremely dangerous
-  /// operation and it is up to the caller to ensure that this is legal for this
-  /// function, and to restore invariants:
-  ///  - the entry block args must be updated to match the function params.
-  ///  - the argument/result attributes may need an update: if the new type
-  ///    has less parameters we drop the extra attributes, if there are more
-  ///    parameters they won't have any attributes.
-  ///
-  /// Note that the concrete class must define a method with the same name to
-  /// hide this one if the concrete class does not use FunctionType for the
-  /// function type under the hood.
-  void setType(FunctionType newType);
-
-  //===--------------------------------------------------------------------===//
-  // Argument and Result Handling
-  //===--------------------------------------------------------------------===//
-  using BlockArgListType = Region::BlockArgListType;
-
-  unsigned getNumArguments() {
-    return static_cast<ConcreteType *>(this)->getNumFuncArguments();
-  }
-
-  unsigned getNumResults() {
-    return static_cast<ConcreteType *>(this)->getNumFuncResults();
-  }
-
-  /// Gets argument.
-  BlockArgument getArgument(unsigned idx) { return getBody().getArgument(idx); }
-
-  /// Support argument iteration.
-  using args_iterator = Region::args_iterator;
-  args_iterator args_begin() { return getBody().args_begin(); }
-  args_iterator args_end() { return getBody().args_end(); }
-  Block::BlockArgListType getArguments() { return getBody().getArguments(); }
-
-  ValueTypeRange<BlockArgListType> getArgumentTypes() {
-    return getBody().getArgumentTypes();
-  }
-
-  /// Insert a single argument of type `argType` with attributes `argAttrs` and
-  /// location `argLoc` at `argIndex`.
-  void insertArgument(unsigned argIndex, Type argType, DictionaryAttr argAttrs,
-                      Optional<Location> argLoc = {}) {
-    insertArguments({argIndex}, {argType}, {argAttrs}, {argLoc});
-  }
-
-  /// Inserts arguments with the listed types, attributes, and locations at the
-  /// listed indices. `argIndices` must be sorted. Arguments are inserted in the
-  /// order they are listed, such that arguments with identical index will
-  /// appear in the same order that they were listed here.
-  void insertArguments(ArrayRef<unsigned> argIndices, TypeRange argTypes,
-                       ArrayRef<DictionaryAttr> argAttrs,
-                       ArrayRef<Optional<Location>> argLocs) {
-    unsigned originalNumArgs = getNumArguments();
-    Type newType = getTypeWithArgsAndResults(
-        argIndices, argTypes, /*resultIndices=*/{}, /*resultTypes=*/{});
-    function_like_impl::insertFunctionArguments(
-        this->getOperation(), argIndices, argTypes, argAttrs, argLocs,
-        originalNumArgs, newType);
-  }
-
-  /// Insert a single result of type `resultType` at `resultIndex`.
-  void insertResult(unsigned resultIndex, Type resultType,
-                    DictionaryAttr resultAttrs) {
-    insertResults({resultIndex}, {resultType}, {resultAttrs});
-  }
-
-  /// Inserts results with the listed types at the listed indices.
-  /// `resultIndices` must be sorted. Results are inserted in the order they are
-  /// listed, such that results with identical index will appear in the same
-  /// order that they were listed here.
-  void insertResults(ArrayRef<unsigned> resultIndices, TypeRange resultTypes,
-                     ArrayRef<DictionaryAttr> resultAttrs) {
-    unsigned originalNumResults = getNumResults();
-    Type newType = getTypeWithArgsAndResults(/*argIndices=*/{}, /*argTypes=*/{},
-                                             resultIndices, resultTypes);
-    function_like_impl::insertFunctionResults(
-        this->getOperation(), resultIndices, resultTypes, resultAttrs,
-        originalNumResults, newType);
-  }
-
-  /// Erase a single argument at `argIndex`.
-  void eraseArgument(unsigned argIndex) { eraseArguments({argIndex}); }
-
-  /// Erases the arguments listed in `argIndices`.
-  /// `argIndices` is allowed to have duplicates and can be in any order.
-  void eraseArguments(ArrayRef<unsigned> argIndices) {
-    unsigned originalNumArgs = getNumArguments();
-    Type newType = getTypeWithoutArgsAndResults(argIndices, {});
-    function_like_impl::eraseFunctionArguments(this->getOperation(), argIndices,
-                                               originalNumArgs, newType);
-  }
-
-  /// Erase a single result at `resultIndex`.
-  void eraseResult(unsigned resultIndex) { eraseResults({resultIndex}); }
-
-  /// Erases the results listed in `resultIndices`.
-  /// `resultIndices` is allowed to have duplicates and can be in any order.
-  void eraseResults(ArrayRef<unsigned> resultIndices) {
-    unsigned originalNumResults = getNumResults();
-    Type newType = getTypeWithoutArgsAndResults({}, resultIndices);
-    function_like_impl::eraseFunctionResults(
-        this->getOperation(), resultIndices, originalNumResults, newType);
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Argument Attributes
-  //===--------------------------------------------------------------------===//
-
-  /// FunctionLike operations allow for attaching attributes to each of the
-  /// respective function arguments. These argument attributes are stored as
-  /// DictionaryAttrs in the main operation attribute dictionary. The name of
-  /// these entries is `arg` followed by the index of the argument. These
-  /// argument attribute dictionaries are optional, and will generally only
-  /// exist if they are non-empty.
-
-  /// Return all of the attributes for the argument at 'index'.
-  ArrayRef<NamedAttribute> getArgAttrs(unsigned index) {
-    return function_like_impl::getArgAttrs(this->getOperation(), index);
-  }
-
-  /// Return an ArrayAttr containing all argument attribute dictionaries of this
-  /// function, or nullptr if no arguments have attributes.
-  ArrayAttr getAllArgAttrs() {
-    return this->getOperation()->template getAttrOfType<ArrayAttr>(
-        function_like_impl::getArgDictAttrName());
-  }
-  /// Return all argument attributes of this function.
-  void getAllArgAttrs(SmallVectorImpl<DictionaryAttr> &result) {
-    if (ArrayAttr argAttrs = getAllArgAttrs()) {
-      auto argAttrRange = argAttrs.template getAsRange<DictionaryAttr>();
-      result.append(argAttrRange.begin(), argAttrRange.end());
-    } else {
-      result.append(getNumArguments(),
-                    DictionaryAttr::get(this->getOperation()->getContext()));
-    }
-  }
-
-  /// Return the specified attribute, if present, for the argument at 'index',
-  /// null otherwise.
-  Attribute getArgAttr(unsigned index, StringAttr name) {
-    auto argDict = getArgAttrDict(index);
-    return argDict ? argDict.get(name) : nullptr;
-  }
-  Attribute getArgAttr(unsigned index, StringRef name) {
-    auto argDict = getArgAttrDict(index);
-    return argDict ? argDict.get(name) : nullptr;
-  }
-
-  template <typename AttrClass>
-  AttrClass getArgAttrOfType(unsigned index, StringAttr name) {
-    return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
-  }
-  template <typename AttrClass>
-  AttrClass getArgAttrOfType(unsigned index, StringRef name) {
-    return getArgAttr(index, name).template dyn_cast_or_null<AttrClass>();
-  }
-
-  /// Set the attributes held by the argument at 'index'.
-  void setArgAttrs(unsigned index, ArrayRef<NamedAttribute> attributes);
-
-  /// Set the attributes held by the argument at 'index'. `attributes` may be
-  /// null, in which case any existing argument attributes are removed.
-  void setArgAttrs(unsigned index, DictionaryAttr attributes);
-  void setAllArgAttrs(ArrayRef<DictionaryAttr> attributes) {
-    assert(attributes.size() == getNumArguments());
-    function_like_impl::setAllArgAttrDicts(this->getOperation(), attributes);
-  }
-  void setAllArgAttrs(ArrayRef<Attribute> attributes) {
-    assert(attributes.size() == getNumArguments());
-    function_like_impl::setAllArgAttrDicts(this->getOperation(), attributes);
-  }
-  void setAllArgAttrs(ArrayAttr attributes) {
-    assert(attributes.size() == getNumArguments());
-    this->getOperation()->setAttr(function_like_impl::getArgDictAttrName(),
-                                  attributes);
-  }
-
-  /// If the an attribute exists with the specified name, change it to the new
-  /// value. Otherwise, add a new attribute with the specified name/value.
-  void setArgAttr(unsigned index, StringAttr name, Attribute value);
-  void setArgAttr(unsigned index, StringRef name, Attribute value) {
-    setArgAttr(index, StringAttr::get(this->getOperation()->getContext(), name),
-               value);
-  }
-
-  /// Remove the attribute 'name' from the argument at 'index'. Return the
-  /// attribute that was erased, or nullptr if there was no attribute with such
-  /// name.
-  Attribute removeArgAttr(unsigned index, StringAttr name);
-  Attribute removeArgAttr(unsigned index, StringRef name) {
-    return removeArgAttr(
-        index, StringAttr::get(this->getOperation()->getContext(), name));
-  }
-
-  //===--------------------------------------------------------------------===//
-  // Result Attributes
-  //===--------------------------------------------------------------------===//
-
-  /// FunctionLike operations allow for attaching attributes to each of the
-  /// respective function results. These result attributes are stored as
-  /// DictionaryAttrs in the main operation attribute dictionary. The name of
-  /// these entries is `result` followed by the index of the result. These
-  /// result attribute dictionaries are optional, and will generally only
-  /// exist if they are non-empty.
-
-  /// Return all of the attributes for the result at 'index'.
-  ArrayRef<NamedAttribute> getResultAttrs(unsigned index) {
-    return function_like_impl::getResultAttrs(this->getOperation(), index);
-  }
-
-  /// Return an ArrayAttr containing all result attribute dictionaries of this
-  /// function, or nullptr if no result have attributes.
-  ArrayAttr getAllResultAttrs() {
-    return this->getOperation()->template getAttrOfType<ArrayAttr>(
-        function_like_impl::getResultDictAttrName());
-  }
-  /// Return all result attributes of this function.
-  void getAllResultAttrs(SmallVectorImpl<DictionaryAttr> &result) {
-    if (ArrayAttr argAttrs = getAllResultAttrs()) {
-      auto argAttrRange = argAttrs.template getAsRange<DictionaryAttr>();
-      result.append(argAttrRange.begin(), argAttrRange.end());
-    } else {
-      result.append(getNumResults(),
-                    DictionaryAttr::get(this->getOperation()->getContext()));
-    }
-  }
-
-  /// Return the specified attribute, if present, for the result at 'index',
-  /// null otherwise.
-  Attribute getResultAttr(unsigned index, StringAttr name) {
-    auto argDict = getResultAttrDict(index);
-    return argDict ? argDict.get(name) : nullptr;
-  }
-  Attribute getResultAttr(unsigned index, StringRef name) {
-    auto argDict = getResultAttrDict(index);
-    return argDict ? argDict.get(name) : nullptr;
-  }
-
-  template <typename AttrClass>
-  AttrClass getResultAttrOfType(unsigned index, StringAttr name) {
-    return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
-  }
-  template <typename AttrClass>
-  AttrClass getResultAttrOfType(unsigned index, StringRef name) {
-    return getResultAttr(index, name).template dyn_cast_or_null<AttrClass>();
-  }
-
-  /// Set the attributes held by the result at 'index'.
-  void setResultAttrs(unsigned index, ArrayRef<NamedAttribute> attributes);
-
-  /// Set the attributes held by the result at 'index'. `attributes` may be
-  /// null, in which case any existing argument attributes are removed.
-  void setResultAttrs(unsigned index, DictionaryAttr attributes);
-  void setAllResultAttrs(ArrayRef<DictionaryAttr> attributes) {
-    assert(attributes.size() == getNumResults());
-    function_like_impl::setAllResultAttrDicts(this->getOperation(), attributes);
-  }
-  void setAllResultAttrs(ArrayRef<Attribute> attributes) {
-    assert(attributes.size() == getNumResults());
-    function_like_impl::setAllResultAttrDicts(this->getOperation(), attributes);
-  }
-  void setAllResultAttrs(ArrayAttr attributes) {
-    assert(attributes.size() == getNumResults());
-    this->getOperation()->setAttr(function_like_impl::getResultDictAttrName(),
-                                  attributes);
-  }
-
-  /// If the an attribute exists with the specified name, change it to the new
-  /// value. Otherwise, add a new attribute with the specified name/value.
-  void setResultAttr(unsigned index, StringAttr name, Attribute value);
-  void setResultAttr(unsigned index, StringRef name, Attribute value) {
-    setResultAttr(index,
-                  StringAttr::get(this->getOperation()->getContext(), name),
-                  value);
-  }
-
-  /// Remove the attribute 'name' from the result at 'index'. Return the
-  /// attribute that was erased, or nullptr if there was no attribute with such
-  /// name.
-  Attribute removeResultAttr(unsigned index, StringAttr name);
-
-protected:
-  /// Returns the dictionary attribute corresponding to the argument at 'index'.
-  /// If there are no argument attributes at 'index', a null attribute is
-  /// returned.
-  DictionaryAttr getArgAttrDict(unsigned index) {
-    assert(index < getNumArguments() && "invalid argument number");
-    return function_like_impl::getArgAttrDict(this->getOperation(), index);
-  }
-
-  /// Returns the dictionary attribute corresponding to the result at 'index'.
-  /// If there are no result attributes at 'index', a null attribute is
-  /// returned.
-  DictionaryAttr getResultAttrDict(unsigned index) {
-    assert(index < getNumResults() && "invalid result number");
-    return function_like_impl::getResultAttrDict(this->getOperation(), index);
-  }
-
-  /// Hook for concrete classes to verify that the type attribute respects
-  /// op-specific invariants.  Default implementation always succeeds.
-  LogicalResult verifyType() { return success(); }
-};
-
-/// Default verifier checks that if the entry block exists, it has the same
-/// number of arguments as the function-like operation.
-template <typename ConcreteType>
-LogicalResult FunctionLike<ConcreteType>::verifyBody() {
-  auto funcOp = cast<ConcreteType>(this->getOperation());
-
-  if (funcOp.isExternal())
-    return success();
-
-  unsigned numArguments = funcOp.getNumArguments();
-  if (funcOp.front().getNumArguments() != numArguments)
-    return funcOp.emitOpError("entry block must have ")
-           << numArguments << " arguments to match function signature";
-
-  return success();
-}
-
-template <typename ConcreteType>
-LogicalResult FunctionLike<ConcreteType>::verifyTrait(Operation *op) {
-  auto funcOp = cast<ConcreteType>(op);
-  if (!funcOp.isTypeAttrValid())
-    return funcOp.emitOpError("requires a type attribute '")
-           << getTypeAttrName() << '\'';
-
-  if (failed(funcOp.verifyType()))
-    return failure();
-
-  if (ArrayAttr allArgAttrs = funcOp.getAllArgAttrs()) {
-    unsigned numArgs = funcOp.getNumArguments();
-    if (allArgAttrs.size() != numArgs) {
-      return funcOp.emitOpError()
-             << "expects argument attribute array `"
-             << function_like_impl::getArgDictAttrName()
-             << "` to have the same number of elements as the number of "
-                "function arguments, got "
-             << allArgAttrs.size() << ", but expected " << numArgs;
-    }
-    for (unsigned i = 0; i != numArgs; ++i) {
-      DictionaryAttr argAttrs =
-          allArgAttrs[i].dyn_cast_or_null<DictionaryAttr>();
-      if (!argAttrs) {
-        return funcOp.emitOpError() << "expects argument attribute dictionary "
-                                       "to be a DictionaryAttr, but got `"
-                                    << allArgAttrs[i] << "`";
-      }
-
-      // Verify that all of the argument attributes are dialect attributes, i.e.
-      // that they contain a dialect prefix in their name.  Call the dialect, if
-      // registered, to verify the attributes themselves.
-      for (auto attr : argAttrs) {
-        if (!attr.getName().strref().contains('.'))
-          return funcOp.emitOpError(
-              "arguments may only have dialect attributes");
-        if (Dialect *dialect = attr.getNameDialect()) {
-          if (failed(dialect->verifyRegionArgAttribute(op, /*regionIndex=*/0,
-                                                       /*argIndex=*/i, attr)))
-            return failure();
-        }
-      }
-    }
-  }
-  if (ArrayAttr allResultAttrs = funcOp.getAllResultAttrs()) {
-    unsigned numResults = funcOp.getNumResults();
-    if (allResultAttrs.size() != numResults) {
-      return funcOp.emitOpError()
-             << "expects result attribute array `"
-             << function_like_impl::getResultDictAttrName()
-             << "` to have the same number of elements as the number of "
-                "function results, got "
-             << allResultAttrs.size() << ", but expected " << numResults;
-    }
-    for (unsigned i = 0; i != numResults; ++i) {
-      DictionaryAttr resultAttrs =
-          allResultAttrs[i].dyn_cast_or_null<DictionaryAttr>();
-      if (!resultAttrs) {
-        return funcOp.emitOpError() << "expects result attribute dictionary "
-                                       "to be a DictionaryAttr, but got `"
-                                    << allResultAttrs[i] << "`";
-      }
-
-      // Verify that all of the result attributes are dialect attributes, i.e.
-      // that they contain a dialect prefix in their name.  Call the dialect, if
-      // registered, to verify the attributes themselves.
-      for (auto attr : resultAttrs) {
-        if (!attr.getName().strref().contains('.'))
-          return funcOp.emitOpError("results may only have dialect attributes");
-        if (Dialect *dialect = attr.getNameDialect()) {
-          if (failed(dialect->verifyRegionResultAttribute(op, /*regionIndex=*/0,
-                                                          /*resultIndex=*/i,
-                                                          attr)))
-            return failure();
-        }
-      }
-    }
-  }
-
-  // Check that the op has exactly one region for the body.
-  if (op->getNumRegions() != 1)
-    return funcOp.emitOpError("expects one region");
-
-  return funcOp.verifyBody();
-}
-
-//===----------------------------------------------------------------------===//
-// Function Body.
-//===----------------------------------------------------------------------===//
-
-template <typename ConcreteType>
-Block *FunctionLike<ConcreteType>::addEntryBlock() {
-  assert(empty() && "function already has an entry block");
-  auto *entry = new Block();
-  push_back(entry);
-  entry->addArguments(getType().getInputs());
-  return entry;
-}
-
-template <typename ConcreteType>
-Block *FunctionLike<ConcreteType>::addBlock() {
-  assert(!empty() && "function should at least have an entry block");
-  push_back(new Block());
-  return &back();
-}
-
-//===----------------------------------------------------------------------===//
-// Function Type Attribute.
-//===----------------------------------------------------------------------===//
-
-template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setType(FunctionType newType) {
-  function_like_impl::setFunctionType(this->getOperation(), newType);
-}
-
-//===----------------------------------------------------------------------===//
-// Function Argument Attribute.
-//===----------------------------------------------------------------------===//
-
-/// Set the attributes held by the argument at 'index'.
-template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setArgAttrs(
-    unsigned index, ArrayRef<NamedAttribute> attributes) {
-  assert(index < getNumArguments() && "invalid argument number");
-  Operation *op = this->getOperation();
-  return function_like_impl::detail::setArgResAttrDict(
-      op, function_like_impl::getArgDictAttrName(), getNumArguments(), index,
-      DictionaryAttr::get(op->getContext(), attributes));
-}
-
-template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setArgAttrs(unsigned index,
-                                             DictionaryAttr attributes) {
-  Operation *op = this->getOperation();
-  return function_like_impl::detail::setArgResAttrDict(
-      op, function_like_impl::getArgDictAttrName(), getNumArguments(), index,
-      attributes ? attributes : DictionaryAttr::get(op->getContext()));
-}
-
-/// If the an attribute exists with the specified name, change it to the new
-/// value. Otherwise, add a new attribute with the specified name/value.
-template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setArgAttr(unsigned index, StringAttr name,
-                                            Attribute value) {
-  NamedAttrList attributes(getArgAttrDict(index));
-  Attribute oldValue = attributes.set(name, value);
-
-  // If the attribute changed, then set the new arg attribute list.
-  if (value != oldValue)
-    setArgAttrs(index, attributes.getDictionary(value.getContext()));
-}
-
-/// Remove the attribute 'name' from the argument at 'index'.
-template <typename ConcreteType>
-Attribute FunctionLike<ConcreteType>::removeArgAttr(unsigned index,
-                                                    StringAttr name) {
-  // Build an attribute list and remove the attribute at 'name'.
-  NamedAttrList attributes(getArgAttrDict(index));
-  Attribute removedAttr = attributes.erase(name);
-
-  // If the attribute was removed, then update the argument dictionary.
-  if (removedAttr)
-    setArgAttrs(index, attributes.getDictionary(removedAttr.getContext()));
-  return removedAttr;
-}
-
-//===----------------------------------------------------------------------===//
-// Function Result Attribute.
-//===----------------------------------------------------------------------===//
-
-/// Set the attributes held by the result at 'index'.
-template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setResultAttrs(
-    unsigned index, ArrayRef<NamedAttribute> attributes) {
-  assert(index < getNumResults() && "invalid result number");
-  Operation *op = this->getOperation();
-  return function_like_impl::detail::setArgResAttrDict(
-      op, function_like_impl::getResultDictAttrName(), getNumResults(), index,
-      DictionaryAttr::get(op->getContext(), attributes));
-}
-
-template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setResultAttrs(unsigned index,
-                                                DictionaryAttr attributes) {
-  assert(index < getNumResults() && "invalid result number");
-  Operation *op = this->getOperation();
-  return function_like_impl::detail::setArgResAttrDict(
-      op, function_like_impl::getResultDictAttrName(), getNumResults(), index,
-      attributes ? attributes : DictionaryAttr::get(op->getContext()));
-}
-
-/// If the an attribute exists with the specified name, change it to the new
-/// value. Otherwise, add a new attribute with the specified name/value.
-template <typename ConcreteType>
-void FunctionLike<ConcreteType>::setResultAttr(unsigned index, StringAttr name,
-                                               Attribute value) {
-  NamedAttrList attributes(getResultAttrDict(index));
-  Attribute oldAttr = attributes.set(name, value);
-
-  // If the attribute changed, then set the new arg attribute list.
-  if (oldAttr != value)
-    setResultAttrs(index, attributes.getDictionary(value.getContext()));
-}
-
-/// Remove the attribute 'name' from the result at 'index'.
-template <typename ConcreteType>
-Attribute FunctionLike<ConcreteType>::removeResultAttr(unsigned index,
-                                                       StringAttr name) {
-  // Build an attribute list and remove the attribute at 'name'.
-  NamedAttrList attributes(getResultAttrDict(index));
-  Attribute removedAttr = attributes.erase(name);
-
-  // If the attribute was removed, then update the result dictionary.
-  if (removedAttr)
-    setResultAttrs(index, attributes.getDictionary(removedAttr.getContext()));
-  return removedAttr;
-}
-
-} // namespace OpTrait
-
-} // namespace mlir
-
-#endif // MLIR_IR_FUNCTIONSUPPORT_H

mlir/include/mlir/IR/OpBase.td

 // X op Y == Y op X
 def Commutative  : NativeOpTrait<"IsCommutative">;
 // op op X == op X (unary) / X op X == X (binary)
 def Idempotent  : NativeOpTrait<"IsIdempotent">;
 // op op X == X
 def Involution  : NativeOpTrait<"IsInvolution">;
 // Op behaves like a constant.
 def ConstantLike : NativeOpTrait<"ConstantLike">;
-// Op behaves like a function.
-def FunctionLike : NativeOpTrait<"FunctionLike">;
 // Op is isolated from above.
 def IsolatedFromAbove : NativeOpTrait<"IsIsolatedFromAbove">;
 // Op results are float or vectors/tensors thereof.
 def ResultsAreFloatLike : NativeOpTrait<"ResultsAreFloatLike">;
 // Op has the same operand type.
 def SameTypeOperands : NativeOpTrait<"SameTypeOperands">;
 // Op has same shape for all operands.
 def SameOperandsShape : NativeOpTrait<"SameOperandsShape">;

mlir/include/mlir/Transforms/DialectConversion.h

matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
     return success();
   }
 
 private:
   using ConversionPattern::matchAndRewrite;
 };
 
 /// Add a pattern to the given pattern list to convert the signature of a
-/// FunctionLike op with the given type converter. This only supports
-/// FunctionLike ops which use FunctionType to represent their type.
-void populateFunctionLikeTypeConversionPattern(StringRef functionLikeOpName,
-                                               RewritePatternSet &patterns,
-                                               TypeConverter &converter);
+/// FunctionOpInterface op with the given type converter. This only supports
+/// ops which use FunctionType to represent their type.
+void populateFunctionOpInterfaceTypeConversionPattern(
+    StringRef functionLikeOpName, RewritePatternSet &patterns,
 
 template <typename FuncOpT>
-void populateFunctionLikeTypeConversionPattern(RewritePatternSet &patterns,
-                                               TypeConverter &converter) {
-  populateFunctionLikeTypeConversionPattern(FuncOpT::getOperationName(),
+void populateFunctionOpInterfaceTypeConversionPattern(
+    RewritePatternSet &patterns, TypeConverter &converter) {
+  populateFunctionOpInterfaceTypeConversionPattern(FuncOpT::getOperationName(),
                                                    patterns, converter);
 }
 
 //===----------------------------------------------------------------------===//
 // Conversion PatternRewriter
 //===----------------------------------------------------------------------===//
 
 namespace detail {
 struct ConversionPatternRewriterImpl;

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

 //===- LocalAliasAnalysis.cpp - Local stateless alias Analysis for MLIR ---===//
 //
 // 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/Analysis/AliasAnalysis/LocalAliasAnalysis.h"
 
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
if (llvm::isa<SideEffects::AutomaticAllocationScopeResource>(
     allocScopeOp = op->getParentWithTrait<OpTrait::AutomaticAllocationScope>();
     return success();
   }
 
   // TODO: Here we could look at the users to see if the resource is either
   // freed on all paths within the region, or is just not captured by anything.
   // For now assume allocation scope to the function scope (we don't care if
   // pointer escape outside function).
-  allocScopeOp = op->getParentWithTrait<OpTrait::FunctionLike>();
+  allocScopeOp = op->getParentOfType<FunctionOpInterface>();
   return success();
 }
 
 /// Given the two values, return their aliasing behavior.
 static AliasResult aliasImpl(Value lhs, Value rhs) {
   if (lhs == rhs)
     return AliasResult::MustAlias;
   Operation *lhsAllocScope = nullptr, *rhsAllocScope = nullptr;

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

void ConvertAsyncToLLVMPass::runOnOperation() {
   RewritePatternSet patterns(ctx);
 
   // We use conversion to LLVM type to lower async.runtime load and store
   // operations.
   LLVMTypeConverter llvmConverter(ctx);
   llvmConverter.addConversion(AsyncRuntimeTypeConverter::convertAsyncTypes);
 
   // Convert async types in function signatures and function calls.
-  populateFunctionLikeTypeConversionPattern<FuncOp>(patterns, converter);
+  populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns, converter);
   populateCallOpTypeConversionPattern(patterns, converter);
 
   // Convert return operations inside async.execute regions.
   patterns.add<ReturnOpOpConversion>(converter, ctx);
 
   // Lower async.runtime operations to the async runtime API calls.
   patterns.add<RuntimeSetAvailableOpLowering, RuntimeSetErrorOpLowering,
                RuntimeIsErrorOpLowering, RuntimeAwaitOpLowering,

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp

GPUFuncOpLowering::matchAndRewrite(gpu::GPUFuncOp gpuFuncOp, OpAdaptor adaptor,
   getTypeConverter()->convertFunctionSignature(
       gpuFuncOp.getType(), /*isVariadic=*/false, signatureConversion);
 
   // Create the new function operation. Only copy those attributes that are
   // not specific to function modeling.
   SmallVector<NamedAttribute, 4> attributes;
   for (const auto &attr : gpuFuncOp->getAttrs()) {
     if (attr.getName() == SymbolTable::getSymbolAttrName() ||
-        attr.getName() == function_like_impl::getTypeAttrName() ||
+        attr.getName() == FunctionOpInterface::getTypeAttrName() ||
         attr.getName() == gpu::GPUFuncOp::getNumWorkgroupAttributionsAttrName())
       continue;
     attributes.push_back(attr);
   }
   // Add a dialect specific kernel attribute in addition to GPU kernel
   // attribute. The former is necessary for further translation while the
   // latter is expected by gpu.launch_func.
   if (gpuFuncOp.isKernel())

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

for (const auto &argType : enumerate(funcOp.getType().getInputs())) {
       signatureConverter.addInputs(argType.index(), convertedType);
     }
   }
   auto newFuncOp = rewriter.create<spirv::FuncOp>(
       funcOp.getLoc(), funcOp.getName(),
       rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
                                llvm::None));
   for (const auto &namedAttr : funcOp->getAttrs()) {
-    if (namedAttr.getName() == function_like_impl::getTypeAttrName() ||
+    if (namedAttr.getName() == FunctionOpInterface::getTypeAttrName() ||
         namedAttr.getName() == SymbolTable::getSymbolAttrName())
       continue;
     newFuncOp->setAttr(namedAttr.getName(), namedAttr.getValue());
   }
 
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   if (failed(rewriter.convertRegionTypes(&newFuncOp.getBody(), typeConverter,

mlir/lib/Conversion/MathToLibm/MathToLibm.cpp

if (!opFunc) {
     OpBuilder::InsertionGuard guard(rewriter);
     rewriter.setInsertionPointToStart(&module->getRegion(0).front());
     auto opFunctionTy = FunctionType::get(
         rewriter.getContext(), op->getOperandTypes(), op->getResultTypes());
     opFunc =
         rewriter.create<FuncOp>(rewriter.getUnknownLoc(), name, opFunctionTy);
     opFunc.setPrivate();
   }
-  assert(SymbolTable::lookupSymbolIn(module, name)
-             ->template hasTrait<mlir::OpTrait::FunctionLike>());
+  assert(isa<FunctionOpInterface>(SymbolTable::lookupSymbolIn(module, name)));
 
   rewriter.replaceOpWithNewOp<CallOp>(op, name, op.getType(),
                                       op->getOperands());
 
   return success();
 }
 
 void mlir::populateMathToLibmConversionPatterns(RewritePatternSet &patterns,

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

 /// Only retain those attributes that are not constructed by
 /// `LLVMFuncOp::build`. If `filterArgAttrs` is set, also filter out argument
 /// attributes.
 static void filterFuncAttributes(ArrayRef<NamedAttribute> attrs,
                                  bool filterArgAttrs,
                                  SmallVectorImpl<NamedAttribute> &result) {
   for (const auto &attr : attrs) {
     if (attr.getName() == SymbolTable::getSymbolAttrName() ||
-        attr.getName() == function_like_impl::getTypeAttrName() ||
+        attr.getName() == FunctionOpInterface::getTypeAttrName() ||
         attr.getName() == "std.varargs" ||
         (filterArgAttrs &&
-         attr.getName() == function_like_impl::getArgDictAttrName()))
+         attr.getName() == FunctionOpInterface::getArgDictAttrName()))
       continue;
     result.push_back(attr);
   }
 }
 
 /// Creates an auxiliary function with pointer-to-memref-descriptor-struct
 /// arguments instead of unpacked arguments. This function can be called from C
 /// by passing a pointer to a C struct corresponding to a memref descriptor.
if (ArrayAttr argAttrDicts = funcOp.getAllArgAttrs()) {
       for (unsigned i = 0, e = funcOp.getNumArguments(); i < e; ++i) {
         auto mapping = result.getInputMapping(i);
         assert(mapping.hasValue() &&
                "unexpected deletion of function argument");
         for (size_t j = 0; j < mapping->size; ++j)
           newArgAttrs[mapping->inputNo + j] = argAttrDicts[i];
       }
       attributes.push_back(
-          rewriter.getNamedAttr(function_like_impl::getArgDictAttrName(),
+          rewriter.getNamedAttr(FunctionOpInterface::getArgDictAttrName(),
                                 rewriter.getArrayAttr(newArgAttrs)));
     }
     for (const auto &pair : llvm::enumerate(attributes)) {
       if (pair.value().getName() == "llvm.linkage") {
         attributes.erase(attributes.begin() + pair.index());
         break;
       }
     }

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

 static ParseResult
 parseLaunchFuncOperands(OpAsmParser &parser,
                         SmallVectorImpl<OpAsmParser::OperandType> &argNames,
                         SmallVectorImpl<Type> &argTypes) {
   if (parser.parseOptionalKeyword("args"))
     return success();
   SmallVector<NamedAttrList, 4> argAttrs;
   bool isVariadic = false;
-  return function_like_impl::parseFunctionArgumentList(
+  return function_interface_impl::parseFunctionArgumentList(
       parser, /*allowAttributes=*/false,
       /*allowVariadic=*/false, argNames, argTypes, argAttrs, isVariadic);
 }
 
 static void printLaunchFuncOperands(OpAsmPrinter &printer, Operation *,
                                     OperandRange operands, TypeRange types) {
   if (operands.empty())
     return;
static ParseResult parseGPUFuncOp(OpAsmParser &parser, OperationState &result) {
 
   // Parse the function name.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, ::mlir::SymbolTable::getSymbolAttrName(),
                              result.attributes))
     return failure();
 
   auto signatureLocation = parser.getCurrentLocation();
-  if (failed(function_like_impl::parseFunctionSignature(
+  if (failed(function_interface_impl::parseFunctionSignature(
           parser, /*allowVariadic=*/false, entryArgs, argTypes, argAttrs,
           isVariadic, resultTypes, resultAttrs)))
     return failure();
 
   if (entryArgs.empty() && !argTypes.empty())
     return parser.emitError(signatureLocation)
            << "gpu.func requires named arguments";
 
static ParseResult parseGPUFuncOp(OpAsmParser &parser, OperationState &result) {
   // Parse the kernel attribute if present.
   if (succeeded(parser.parseOptionalKeyword(GPUFuncOp::getKernelKeyword())))
     result.addAttribute(GPUDialect::getKernelFuncAttrName(),
                         builder.getUnitAttr());
 
   // Parse attributes.
   if (failed(parser.parseOptionalAttrDictWithKeyword(result.attributes)))
     return failure();
-  function_like_impl::addArgAndResultAttrs(builder, result, argAttrs,
+  function_interface_impl::addArgAndResultAttrs(builder, result, argAttrs,
                                                 resultAttrs);
 
   // Parse the region. If no argument names were provided, take all names
   // (including those of attributions) from the entry block.
   auto *body = result.addRegion();
   return parser.parseRegion(*body, entryArgs, argTypes);
 }
 
 static void printAttributions(OpAsmPrinter &p, StringRef keyword,
                               ArrayRef<BlockArgument> values) {
   if (values.empty())
     return;
 
   p << ' ' << keyword << '(';
   llvm::interleaveComma(
       values, p, [&p](BlockArgument v) { p << v << " : " << v.getType(); });
   p << ')';
 }
 
 /// Prints a GPU Func op.
 static void printGPUFuncOp(OpAsmPrinter &p, GPUFuncOp op) {
   p << ' ';
   p.printSymbolName(op.getName());
 
   FunctionType type = op.getType();
-  function_like_impl::printFunctionSignature(
+  function_interface_impl::printFunctionSignature(
       p, op.getOperation(), type.getInputs(),
       /*isVariadic=*/false, type.getResults());
 
   printAttributions(p, op.getWorkgroupKeyword(), op.getWorkgroupAttributions());
   printAttributions(p, op.getPrivateKeyword(), op.getPrivateAttributions());
   if (op.isKernel())
     p << ' ' << op.getKernelKeyword();
 
-  function_like_impl::printFunctionAttributes(
+  function_interface_impl::printFunctionAttributes(
       p, op.getOperation(), type.getNumInputs(), type.getNumResults(),
       {op.getNumWorkgroupAttributionsAttrName(),
        GPUDialect::getKernelFuncAttrName()});
   p << ' ';
   p.printRegion(op.getBody(), /*printEntryBlockArgs=*/false);
 }
 
-/// Hook for FunctionLike verifier.
 LogicalResult GPUFuncOp::verifyType() {
   Type type = getTypeAttr().getValue();
   if (!type.isa<FunctionType>())
     return emitOpError("requires '" + getTypeAttrName() +
                        "' attribute of function type");
 
   if (isKernel() && getType().getNumResults() != 0)
     return emitOpError() << "expected void return type for kernel function";

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

void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
   result.attributes.append(attrs.begin(), attrs.end());
   if (dsoLocal)
     result.addAttribute("dso_local", builder.getUnitAttr());
   if (argAttrs.empty())
     return;
 
   assert(type.cast<LLVMFunctionType>().getNumParams() == argAttrs.size() &&
          "expected as many argument attribute lists as arguments");
-  function_like_impl::addArgAndResultAttrs(builder, result, argAttrs,
+  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, llvm::SMLoc loc,
                       ArrayRef<Type> inputs, ArrayRef<Type> outputs,
-                      function_like_impl::VariadicFlag variadicFlag) {
+                      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 {};
   }
 
   // Convert inputs to LLVM types, exit early on error.
static ParseResult parseLLVMFuncOp(OpAsmParser &parser,
   SmallVector<NamedAttrList, 1> resultAttrs;
   SmallVector<Type, 8> argTypes;
   SmallVector<Type, 4> resultTypes;
   bool isVariadic;
 
   auto signatureLocation = parser.getCurrentLocation();
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              result.attributes) ||
-      function_like_impl::parseFunctionSignature(
+      function_interface_impl::parseFunctionSignature(
           parser, /*allowVariadic=*/true, entryArgs, argTypes, argAttrs,
           isVariadic, resultTypes, resultAttrs))
     return failure();
 
   auto type =
       buildLLVMFunctionType(parser, signatureLocation, argTypes, resultTypes,
-                            function_like_impl::VariadicFlag(isVariadic));
+                            function_interface_impl::VariadicFlag(isVariadic));
   if (!type)
     return failure();
-  result.addAttribute(function_like_impl::getTypeAttrName(),
+  result.addAttribute(FunctionOpInterface::getTypeAttrName(),
                       TypeAttr::get(type));
 
   if (failed(parser.parseOptionalAttrDictWithKeyword(result.attributes)))
     return failure();
-  function_like_impl::addArgAndResultAttrs(parser.getBuilder(), result,
+  function_interface_impl::addArgAndResultAttrs(parser.getBuilder(), result,
                                                 argAttrs, resultAttrs);
 
   auto *body = result.addRegion();
   OptionalParseResult parseResult = parser.parseOptionalRegion(
       *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes);
   return failure(parseResult.hasValue() && failed(*parseResult));
 }
 
 // Print the LLVMFuncOp. Collects argument and result types and passes them to
static void printLLVMFuncOp(OpAsmPrinter &p, LLVMFuncOp op) {
   argTypes.reserve(fnType.getNumParams());
   for (unsigned i = 0, e = fnType.getNumParams(); i < e; ++i)
     argTypes.push_back(fnType.getParamType(i));
 
   Type returnType = fnType.getReturnType();
   if (!returnType.isa<LLVMVoidType>())
     resTypes.push_back(returnType);
 
-  function_like_impl::printFunctionSignature(p, op, argTypes, op.isVarArg(),
-                                             resTypes);
-  function_like_impl::printFunctionAttributes(
+  function_interface_impl::printFunctionSignature(p, op, argTypes,
+                                                  op.isVarArg(), resTypes);
+  function_interface_impl::printFunctionAttributes(
       p, op, argTypes.size(), resTypes.size(), {getLinkageAttrName()});
 
   // Print the body if this is not an external function.
   Region &body = op.getBody();
   if (!body.empty()) {
     p << ' ';
     p.printRegion(body, /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/true);
   }
 }
 
-// Hook for OpTrait::FunctionLike, called after verifying that the 'type'
-// attribute is present.  This can check for preconditions of the
-// getNumArguments hook not failing.
 LogicalResult LLVMFuncOp::verifyType() {
   auto llvmType = getTypeAttr().getValue().dyn_cast_or_null<LLVMFunctionType>();
   if (!llvmType)
     return emitOpError("requires '" + getTypeAttrName() +
                        "' attribute of wrapped LLVM function type");
 
   return success();
 }
 
-// Hook for OpTrait::FunctionLike, returns the number of function arguments.
-// Depends on the type attribute being correct as checked by verifyType
-unsigned LLVMFuncOp::getNumFuncArguments() { return getType().getNumParams(); }
-
-// Hook for OpTrait::FunctionLike, returns the number of function results.
-// Depends on the type attribute being correct as checked by verifyType
-unsigned LLVMFuncOp::getNumFuncResults() {
-  // We model LLVM functions that return void as having zero results,
-  // and all others as having one result.
-  // If we modeled a void return as one result, then it would be possible to
-  // attach an MLIR result attribute to it, and it isn't clear what semantics we
-  // would assign to that.
-  if (getType().getReturnType().isa<LLVMVoidType>())
-    return 0;
-  return 1;
-}
-
 // Verifies LLVM- and implementation-specific properties of the LLVM func Op:
 // - functions don't have 'common' linkage
 // - external functions have 'external' or 'extern_weak' linkage;
 // - vararg is (currently) only supported for external functions;
 // - entry block arguments are of LLVM types and match the function signature.
 static LogicalResult verify(LLVMFuncOp op) {
   if (op.getLinkage() == LLVM::Linkage::Common)
     return op.emitOpError()
            << "functions cannot have '"
            << stringifyLinkage(LLVM::Linkage::Common) << "' linkage";
 
+  // Check to see if this function has a void return with a result attribute to
+  // it. It isn't clear what semantics we would assign to that.
+  if (op.getType().getReturnType().isa<LLVMVoidType>() &&
+      !op.getResultAttrs(0).empty()) {
+    return op.emitOpError()
+           << "cannot attach result attributes to functions with a void return";
+  }
+
   if (op.isExternal()) {
     if (op.getLinkage() != LLVM::Linkage::External &&
         op.getLinkage() != LLVM::Linkage::ExternWeak)
       return op.emitOpError()
              << "external functions must have '"
              << stringifyLinkage(LLVM::Linkage::External) << "' or '"
              << stringifyLinkage(LLVM::Linkage::ExternWeak) << "' linkage";
     return success();

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

 LLVMFunctionType::getChecked(function_ref<InFlightDiagnostic()> emitError,
                              Type result, ArrayRef<Type> arguments,
                              bool isVarArg) {
   assert(result && "expected non-null result");
   return Base::getChecked(emitError, result.getContext(), result, arguments,
                           isVarArg);
 }
 
+LLVMFunctionType LLVMFunctionType::clone(TypeRange inputs,
+                                         TypeRange results) const {
+  assert(results.size() == 1 && "expected a single result type");
+  return get(results[0], llvm::to_vector(inputs), isVarArg());
+}
+
 Type LLVMFunctionType::getReturnType() { return getImpl()->getReturnType(); }
+ArrayRef<Type> LLVMFunctionType::getReturnTypes() {
+  return getImpl()->getReturnType();
+}
 
 unsigned LLVMFunctionType::getNumParams() {
   return getImpl()->getArgumentTypes().size();
 }
 
 Type LLVMFunctionType::getParamType(unsigned i) {
   return getImpl()->getArgumentTypes()[i];
 }
 
-bool LLVMFunctionType::isVarArg() { return getImpl()->isVariadic(); }
+bool LLVMFunctionType::isVarArg() const { return getImpl()->isVariadic(); }
 
 ArrayRef<Type> LLVMFunctionType::getParams() {
   return getImpl()->getArgumentTypes();
 }
 
 LogicalResult
 LLVMFunctionType::verify(function_ref<InFlightDiagnostic()> emitError,
                          Type result, ArrayRef<Type> arguments, bool) {

mlir/lib/Dialect/LLVMIR/IR/TypeDetail.h

 /// Type storage for LLVM dialect function types. These are uniqued using the
 /// list of types they contain and the vararg bit.
 struct LLVMFunctionTypeStorage : public TypeStorage {
   using KeyTy = std::tuple<Type, ArrayRef<Type>, bool>;
 
   /// Construct a storage from the given components. The list is expected to be
   /// allocated in the context.
   LLVMFunctionTypeStorage(Type result, ArrayRef<Type> arguments, bool variadic)
-      : argumentTypes(arguments) {
-    returnTypeAndVariadic.setPointerAndInt(result, variadic);
-  }
+      : resultType(result), isVariadicFlag(variadic),
+        numArguments(arguments.size()), argumentTypes(arguments.data()) {}
 
   /// Hook into the type uniquing infrastructure.
   static LLVMFunctionTypeStorage *construct(TypeStorageAllocator &allocator,
                                             const KeyTy &key) {
     return new (allocator.allocate<LLVMFunctionTypeStorage>())
         LLVMFunctionTypeStorage(std::get<0>(key),
                                 allocator.copyInto(std::get<1>(key)),
                                 std::get<2>(key));
   }
 
   static unsigned hashKey(const KeyTy &key) {
     // LLVM doesn't like hashing bools in tuples.
     return llvm::hash_combine(std::get<0>(key), std::get<1>(key),
                               static_cast<int>(std::get<2>(key)));
   }
 
   bool operator==(const KeyTy &key) const {
     return std::make_tuple(getReturnType(), getArgumentTypes(), isVariadic()) ==
            key;
   }
 
   /// Returns the list of function argument types.
-  ArrayRef<Type> getArgumentTypes() const { return argumentTypes; }
+  ArrayRef<Type> getArgumentTypes() const {
+    return ArrayRef<Type>(argumentTypes, numArguments);
+  }
 
   /// Checks whether the function type is variadic.
-  bool isVariadic() const { return returnTypeAndVariadic.getInt(); }
+  bool isVariadic() const { return isVariadicFlag; }
 
   /// Returns the function result type.
-  Type getReturnType() const { return returnTypeAndVariadic.getPointer(); }
+  const Type &getReturnType() const { return resultType; }
 
 private:
-  /// Function result type packed with the variadic bit.
-  llvm::PointerIntPair<Type, 1, bool> returnTypeAndVariadic;
-  /// Argument types.
-  ArrayRef<Type> argumentTypes;
+  /// The result type of the function.
+  Type resultType;
+  /// Flag indicating if the function is variadic.
+  bool isVariadicFlag;
+  /// The argument types of the function.
+  unsigned numArguments;
+  const Type *argumentTypes;
 };
 
 //===----------------------------------------------------------------------===//
 // LLVMPointerTypeStorage.
 //===----------------------------------------------------------------------===//
 
 /// Storage type for LLVM dialect pointer types. These are uniqued by a pair of
 /// element type and address space.

mlir/lib/Dialect/Linalg/IR/LinalgDialect.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Linalg/ComprehensiveBufferize/BufferizableOpInterface.h"
 #include "mlir/Dialect/Linalg/IR/Linalg.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/Parser.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace mlir;
LogicalResult LinalgDialect::verifyOperationAttribute(Operation *op,
   using comprehensive_bufferize::BufferizableOpInterface;
 
   if (attr.getName() == BufferizableOpInterface::kInplaceableAttrName) {
     if (!attr.getValue().isa<BoolAttr>()) {
       return op->emitError()
              << "'" << BufferizableOpInterface::kInplaceableAttrName
              << "' is expected to be a boolean attribute";
     }
-    if (!op->hasTrait<OpTrait::FunctionLike>())
+    if (!isa<FunctionOpInterface>(op))
       return op->emitError() << "expected " << attr.getName()
                              << " to be used on function-like operations";
     return success();
   }
   if (attr.getName() == BufferizableOpInterface::kBufferLayoutAttrName) {
     if (!attr.getValue().isa<AffineMapAttr>()) {
       return op->emitError()
              << "'" << BufferizableOpInterface::kBufferLayoutAttrName
              << "' is expected to be a affine map attribute";
     }
-    if (!op->hasTrait<OpTrait::FunctionLike>())
+    if (!isa<FunctionOpInterface>(op))
       return op->emitError() << "expected " << attr.getName()
                              << " to be used on function-like operations";
     return success();
   }
   if (attr.getName() == LinalgDialect::kMemoizedIndexingMapsAttrName)
     return success();
   return op->emitError() << "attribute '" << attr.getName()
                          << "' not supported by the linalg dialect";
 }

mlir/lib/Dialect/Linalg/Transforms/Detensorize.cpp

matchAndRewrite(GenericOp op, OpAdaptor adaptor,
     rewriter.eraseOp(&*Block::iterator(yieldOp));
 
     return success();
   }
 };
 
 /// A conversion pattern for detensoring internal (non-entry) blocks within a
 /// function.
-struct FunctionNonEntryBlockConversion : public ConversionPattern {
+struct FunctionNonEntryBlockConversion
+    : public OpInterfaceConversionPattern<FunctionOpInterface> {
   FunctionNonEntryBlockConversion(MLIRContext *ctx, TypeConverter &converter,
                                   DenseSet<BlockArgument> blockArgsToDetensor)
-      : ConversionPattern(converter, MatchTraitOpTypeTag(),
-                          TypeID::get<OpTrait::FunctionLike>(), /*benefit=*/1,
-                          ctx),
+      : OpInterfaceConversionPattern(converter, ctx),
         blockArgsToDetensor(std::move(blockArgsToDetensor)) {}
 
   LogicalResult
-  matchAndRewrite(Operation *op, ArrayRef<Value> operands,
+  matchAndRewrite(FunctionOpInterface op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
-    Region &region = function_like_impl::getFunctionBody(op);
+    Region &region = op.getBody();
     SmallVector<TypeConverter::SignatureConversion, 2> conversions;
 
     for (Block &block : llvm::drop_begin(region, 1)) {
       conversions.emplace_back(block.getNumArguments());
       TypeConverter::SignatureConversion &back = conversions.back();
 
       for (BlockArgument blockArgument : block.getArguments()) {
         int idx = blockArgument.getArgNumber();
public:
     ///   %10 = "some.op"(%9)
     ///   br ^bb2(%8 : tensor<i32>)
     /// ...
     ///
     /// if the cost model decides that the linalg.generic op should be
     /// detensored, then:
     /// - opsToDetensor should be = {linalg.generic{add}}.
     /// - blockArgsToDetensor should be = {bb1 -> {0}, bb2 -> {0}}.
-    virtual void compute(Operation *func,
+    virtual void compute(FunctionOpInterface func,
                          DetensorizeTypeConverter typeConverter,
                          DenseSet<Operation *> &opsToDetensor,
                          DenseSet<BlockArgument> &blockArgsToDetensor) = 0;
 
     /// From the blockArgsToDetensor set computed by a CostModel
     /// implementation, this method computes the corresponding branch op
     /// detensoring. The result is a map from a branch op to a subset of indices
     /// of its operands. The indices specify which of the branch op's operands
struct LinalgDetensorize : public LinalgDetensorizeBase<LinalgDetensorize> {
   /// comes from. If the condition value is (indirectly) computed by a linalg op
   /// that can be detensored, the model then continues walking the use-def chain
   /// in order to understand where the linalg op's operands come from. This
   /// leads to discovering a "detensoring component". A detensoring component is
   /// the set of operations + block arguments that are involved in control-flow
   /// AND can be detensored.
   class ControlFlowDetectionModel : public CostModel {
   public:
-    void compute(Operation *func, DetensorizeTypeConverter typeConverter,
+    void compute(FunctionOpInterface func,
+                 DetensorizeTypeConverter typeConverter,
                  DenseSet<Operation *> &opsToDetensor,
                  DenseSet<BlockArgument> &blockArgsToDetensor) override {
       SmallVector<Value> workList;
 
       func->walk([&](CondBranchOp condBr) {
         for (auto operand : condBr.getOperands()) {
           workList.push_back(operand);
         }
void compute(FunctionOpInterface func,
         blockArgsToDetensor.erase(blockArg);
       }
     }
   };
 
   /// Detensorize everything that can detensored.
   class AggressiveDetensoringModel : public CostModel {
   public:
-    void compute(Operation *func, DetensorizeTypeConverter typeConverter,
+    void compute(FunctionOpInterface func,
+                 DetensorizeTypeConverter typeConverter,
                  DenseSet<Operation *> &opsToDetensor,
                  DenseSet<BlockArgument> &blockArgsToDetensor) override {
       func->walk([&](GenericOp genericOp) {
         if (shouldBeDetensored(genericOp, typeConverter))
           opsToDetensor.insert(genericOp);
       });
 
-      for (Block &block :
-           llvm::drop_begin(function_like_impl::getFunctionBody(func), 1))
+      for (Block &block : llvm::drop_begin(func.getBody(), 1))
         for (BlockArgument blockArgument : block.getArguments())
           blockArgsToDetensor.insert(blockArgument);
     }
   };
 
   void runOnOperation() override {
-    assert(getOperation()->hasTrait<OpTrait::FunctionLike>() &&
-           "DetensorizePass can only be run on FunctionLike operations");
     MLIRContext *context = &getContext();
     DetensorizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
     DenseSet<Operation *> opsToDetensor;
     DenseMap<Operation *, DenseSet<int>> detensorableBranchOps;
     DenseSet<BlockArgument> blockArgsToDetensor;
+    FunctionOpInterface funcOp = cast<FunctionOpInterface>(getOperation());
 
     if (aggressiveMode.getValue()) {
       AggressiveDetensoringModel costModel;
-      costModel.compute(getOperation(), typeConverter, opsToDetensor,
+      costModel.compute(funcOp, typeConverter, opsToDetensor,
                         blockArgsToDetensor);
-
     } else {
       ControlFlowDetectionModel costModel;
-      costModel.compute(getOperation(), typeConverter, opsToDetensor,
+      costModel.compute(funcOp, typeConverter, opsToDetensor,
                         blockArgsToDetensor);
     }
 
     detensorableBranchOps =
         CostModel::computeBranchOpDetensoring(blockArgsToDetensor);
 
     target.addDynamicallyLegalOp<GenericOp>(
         [&](GenericOp op) { return !opsToDetensor.count(op); });
 
     target.markUnknownOpDynamicallyLegal([&](Operation *op) {
       // A function is legal if all of its non-entry blocks are legal. We
       // don't legalize the entry block (i.e. the function's signature)
       // since detensoring can't happen along external calling convention
       // boundaries, which we conservatively approximate as all function
       // signatures.
-      if (op->hasTrait<OpTrait::FunctionLike>()) {
-        auto &body = function_like_impl::getFunctionBody(op);
+      if (auto funcOp = dyn_cast<FunctionOpInterface>(op)) {
+        Region &body = funcOp.getBody();
         return llvm::all_of(llvm::drop_begin(body, 1), [&](Block &block) {
           return !llvm::any_of(
               blockArgsToDetensor, [&](BlockArgument blockArgument) {
                 return blockArgument.getOwner() == &block &&
                        !typeConverter.isLegal(blockArgument.getType());
               });
         });
       }

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

 static constexpr const char kCompositeSpecConstituentsName[] = "constituents";
 
 //===----------------------------------------------------------------------===//
 // Common utility functions
 //===----------------------------------------------------------------------===//
 
 /// Returns true if the given op is a function-like op or nested in a
 /// function-like op without a module-like op in the middle.
-static bool isNestedInFunctionLikeOp(Operation *op) {
+static bool isNestedInFunctionOpInterface(Operation *op) {
   if (!op)
     return false;
   if (op->hasTrait<OpTrait::SymbolTable>())
     return false;
-  if (op->hasTrait<OpTrait::FunctionLike>())
+  if (isa<FunctionOpInterface>(op))
     return true;
-  return isNestedInFunctionLikeOp(op->getParentOp());
+  return isNestedInFunctionOpInterface(op->getParentOp());
 }
 
 /// Returns true if the given op is an module-like op that maintains a symbol
 /// table.
 static bool isDirectInModuleLikeOp(Operation *op) {
   return op && op->hasTrait<OpTrait::SymbolTable>();
 }
 
static ParseResult parseFuncOp(OpAsmParser &parser, OperationState &state) {
   // Parse the name as a symbol.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              state.attributes))
     return failure();
 
   // Parse the function signature.
   bool isVariadic = false;
-  if (function_like_impl::parseFunctionSignature(
+  if (function_interface_impl::parseFunctionSignature(
           parser, /*allowVariadic=*/false, entryArgs, argTypes, argAttrs,
           isVariadic, resultTypes, resultAttrs))
     return failure();
 
   auto fnType = builder.getFunctionType(argTypes, resultTypes);
-  state.addAttribute(function_like_impl::getTypeAttrName(),
+  state.addAttribute(FunctionOpInterface::getTypeAttrName(),
                      TypeAttr::get(fnType));
 
   // Parse the optional function control keyword.
   spirv::FunctionControl fnControl;
   if (parseEnumStrAttr(fnControl, parser, state))
     return failure();
 
   // If additional attributes are present, parse them.
   if (parser.parseOptionalAttrDictWithKeyword(state.attributes))
     return failure();
 
   // Add the attributes to the function arguments.
   assert(argAttrs.size() == argTypes.size());
   assert(resultAttrs.size() == resultTypes.size());
-  function_like_impl::addArgAndResultAttrs(builder, state, argAttrs,
+  function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
                                                 resultAttrs);
 
   // Parse the optional function body.
   auto *body = state.addRegion();
   OptionalParseResult result = parser.parseOptionalRegion(
       *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes);
   return failure(result.hasValue() && failed(*result));
 }
 
 static void print(spirv::FuncOp fnOp, OpAsmPrinter &printer) {
   // Print function name, signature, and control.
   printer << " ";
   printer.printSymbolName(fnOp.sym_name());
   auto fnType = fnOp.getType();
-  function_like_impl::printFunctionSignature(printer, fnOp, fnType.getInputs(),
-                                             /*isVariadic=*/false,
-                                             fnType.getResults());
+  function_interface_impl::printFunctionSignature(
+      printer, fnOp, fnType.getInputs(),
+      /*isVariadic=*/false, fnType.getResults());
   printer << " \"" << spirv::stringifyFunctionControl(fnOp.function_control())
           << "\"";
-  function_like_impl::printFunctionAttributes(
+  function_interface_impl::printFunctionAttributes(
       printer, fnOp, fnType.getNumInputs(), fnType.getNumResults(),
       {spirv::attributeName<spirv::FunctionControl>()});
 
   // Print the body if this is not an external function.
   Region &body = fnOp.body();
   if (!body.empty()) {
     printer << ' ';
     printer.printRegion(body, /*printEntryBlockArgs=*/false,

mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp

 //===- TargetAndABI.cpp - SPIR-V target and ABI utilities -----------------===//
 //
 // 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/SPIRV/IR/TargetAndABI.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVTypes.h"
 #include "mlir/IR/Builders.h"
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/SymbolTable.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // TargetEnv
 //===----------------------------------------------------------------------===//
spirv::getEntryPointABIAttr(ArrayRef<int32_t> localSize, MLIRContext *context) {
   return spirv::EntryPointABIAttr::get(
       DenseElementsAttr::get<int32_t>(
           VectorType::get(3, IntegerType::get(context, 32)), localSize)
           .cast<DenseIntElementsAttr>(),
       context);
 }
 
 spirv::EntryPointABIAttr spirv::lookupEntryPointABI(Operation *op) {
-  while (op && !op->hasTrait<OpTrait::FunctionLike>())
+  while (op && !isa<FunctionOpInterface>(op))
     op = op->getParentOp();
   if (!op)
     return {};
 
   if (auto attr = op->getAttrOfType<spirv::EntryPointABIAttr>(
           spirv::getEntryPointABIAttrName()))
     return attr;
 

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

FuncOpConversion::matchAndRewrite(FuncOp funcOp, OpAdaptor adaptor,
   auto newFuncOp = rewriter.create<spirv::FuncOp>(
       funcOp.getLoc(), funcOp.getName(),
       rewriter.getFunctionType(signatureConverter.getConvertedTypes(),
                                resultType ? TypeRange(resultType)
                                           : TypeRange()));
 
   // Copy over all attributes other than the function name and type.
   for (const auto &namedAttr : funcOp->getAttrs()) {
-    if (namedAttr.getName() != function_like_impl::getTypeAttrName() &&
+    if (namedAttr.getName() != FunctionOpInterface::getTypeAttrName() &&
         namedAttr.getName() != SymbolTable::getSymbolAttrName())
       newFuncOp->setAttr(namedAttr.getName(), namedAttr.getValue());
   }
 
   rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                               newFuncOp.end());
   if (failed(rewriter.convertRegionTypes(
           &newFuncOp.getBody(), *getTypeConverter(), &signatureConverter)))

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorPasses.cpp

void runOnOperation() override {
     // rewriting rules, and are therefore marked as legal.
     target.addLegalOp<arith::CmpFOp, arith::CmpIOp, arith::ConstantOp,
                       arith::IndexCastOp, linalg::FillOp, linalg::YieldOp,
                       tensor::ExtractOp>();
     target
         .addLegalDialect<bufferization::BufferizationDialect, LLVM::LLVMDialect,
                          memref::MemRefDialect, scf::SCFDialect>();
     // Populate with rules and apply rewriting rules.
-    populateFunctionLikeTypeConversionPattern<FuncOp>(patterns, converter);
+    populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns,
+                                                             converter);
     populateCallOpTypeConversionPattern(patterns, converter);
     populateSparseTensorConversionPatterns(converter, patterns);
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 

mlir/lib/Dialect/StandardOps/Transforms/FuncBufferize.cpp

struct FuncBufferizePass : public FuncBufferizeBase<FuncBufferizePass> {
   void runOnOperation() override {
     auto module = getOperation();
     auto *context = &getContext();
 
     bufferization::BufferizeTypeConverter typeConverter;
     RewritePatternSet patterns(context);
     ConversionTarget target(*context);
 
-    populateFunctionLikeTypeConversionPattern<FuncOp>(patterns, typeConverter);
+    populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns,
+                                                             typeConverter);
     target.addDynamicallyLegalOp<FuncOp>([&](FuncOp op) {
       return typeConverter.isSignatureLegal(op.getType()) &&
              typeConverter.isLegal(&op.getBody());
     });
     populateCallOpTypeConversionPattern(patterns, typeConverter);
     target.addDynamicallyLegalOp<CallOp>(
         [&](CallOp op) { return typeConverter.isLegal(op); });
 

mlir/lib/IR/BuiltinDialect.cpp

state.addAttribute(SymbolTable::getSymbolAttrName(),
                      builder.getStringAttr(name));
   state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   state.attributes.append(attrs.begin(), attrs.end());
   state.addRegion();
 
   if (argAttrs.empty())
     return;
   assert(type.getNumInputs() == argAttrs.size());
-  function_like_impl::addArgAndResultAttrs(builder, state, argAttrs,
+  function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
                                                 /*resultAttrs=*/llvm::None);
 }
 
 static ParseResult parseFuncOp(OpAsmParser &parser, OperationState &result) {
-  auto buildFuncType = [](Builder &builder, ArrayRef<Type> argTypes,
-                          ArrayRef<Type> results,
-                          function_like_impl::VariadicFlag, std::string &) {
-    return builder.getFunctionType(argTypes, results);
-  };
+  auto buildFuncType =
+      [](Builder &builder, ArrayRef<Type> argTypes, ArrayRef<Type> results,
+         function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
 
-  return function_like_impl::parseFunctionLikeOp(
+  return function_interface_impl::parseFunctionOp(
       parser, result, /*allowVariadic=*/false, buildFuncType);
 }
 
 static void print(FuncOp op, OpAsmPrinter &p) {
   FunctionType fnType = op.getType();
-  function_like_impl::printFunctionLikeOp(
+  function_interface_impl::printFunctionOp(
       p, op, fnType.getInputs(), /*isVariadic=*/false, fnType.getResults());
 }
 
 static LogicalResult verify(FuncOp op) {
   // If this function is external there is nothing to do.
   if (op.isExternal())
     return success();
 

mlir/lib/IR/BuiltinTypes.cpp

 //===- BuiltinTypes.cpp - MLIR Builtin Type Classes -----------------------===//
 //
 // 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/IR/BuiltinTypes.h"
 #include "TypeDetail.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/TensorEncoding.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/TypeSwitch.h"
 

 }
 
 unsigned FunctionType::getNumResults() const { return getImpl()->numResults; }
 
 ArrayRef<Type> FunctionType::getResults() const {
   return getImpl()->getResults();
 }
 
-/// Helper to call a callback once on each index in the range
-/// [0, `totalIndices`), *except* for the indices given in `indices`.
-/// `indices` is allowed to have duplicates and can be in any order.
-inline void iterateIndicesExcept(unsigned totalIndices,
-                                 ArrayRef<unsigned> indices,
-                                 function_ref<void(unsigned)> callback) {
-  llvm::BitVector skipIndices(totalIndices);
-  for (unsigned i : indices)
-    skipIndices.set(i);
-
-  for (unsigned i = 0; i < totalIndices; ++i)
-    if (!skipIndices.test(i))
-      callback(i);
+FunctionType FunctionType::clone(TypeRange inputs, TypeRange results) const {
+  return get(getContext(), inputs, results);
 }
 
 /// Returns a new function type with the specified arguments and results
 /// inserted.
 FunctionType FunctionType::getWithArgsAndResults(
     ArrayRef<unsigned> argIndices, TypeRange argTypes,
     ArrayRef<unsigned> resultIndices, TypeRange resultTypes) {
-  assert(argIndices.size() == argTypes.size());
-  assert(resultIndices.size() == resultTypes.size());
-
-  ArrayRef<Type> newInputTypes = getInputs();
-  SmallVector<Type, 4> newInputTypesBuffer;
-  if (!argIndices.empty()) {
-    const auto *fromIt = newInputTypes.begin();
-    for (auto it : llvm::zip(argIndices, argTypes)) {
-      const auto *toIt = newInputTypes.begin() + std::get<0>(it);
-      newInputTypesBuffer.append(fromIt, toIt);
-      newInputTypesBuffer.push_back(std::get<1>(it));
-      fromIt = toIt;
-    }
-    newInputTypesBuffer.append(fromIt, newInputTypes.end());
-    newInputTypes = newInputTypesBuffer;
-  }
-
-  ArrayRef<Type> newResultTypes = getResults();
-  SmallVector<Type, 4> newResultTypesBuffer;
-  if (!resultIndices.empty()) {
-    const auto *fromIt = newResultTypes.begin();
-    for (auto it : llvm::zip(resultIndices, resultTypes)) {
-      const auto *toIt = newResultTypes.begin() + std::get<0>(it);
-      newResultTypesBuffer.append(fromIt, toIt);
-      newResultTypesBuffer.push_back(std::get<1>(it));
-      fromIt = toIt;
-    }
-    newResultTypesBuffer.append(fromIt, newResultTypes.end());
-    newResultTypes = newResultTypesBuffer;
-  }
-
-  return FunctionType::get(getContext(), newInputTypes, newResultTypes);
+  SmallVector<Type> argStorage, resultStorage;
+  TypeRange newArgTypes = function_interface_impl::insertTypesInto(
+      getInputs(), argIndices, argTypes, argStorage);
+  TypeRange newResultTypes = function_interface_impl::insertTypesInto(
+      getResults(), resultIndices, resultTypes, resultStorage);
+  return clone(newArgTypes, newResultTypes);
 }
 
 /// Returns a new function type without the specified arguments and results.
 FunctionType
 FunctionType::getWithoutArgsAndResults(ArrayRef<unsigned> argIndices,
                                        ArrayRef<unsigned> resultIndices) {
-  ArrayRef<Type> newInputTypes = getInputs();
-  SmallVector<Type, 4> newInputTypesBuffer;
-  if (!argIndices.empty()) {
-    unsigned originalNumArgs = getNumInputs();
-    iterateIndicesExcept(originalNumArgs, argIndices, [&](unsigned i) {
-      newInputTypesBuffer.emplace_back(getInput(i));
-    });
-    newInputTypes = newInputTypesBuffer;
-  }
-
-  ArrayRef<Type> newResultTypes = getResults();
-  SmallVector<Type, 4> newResultTypesBuffer;
-  if (!resultIndices.empty()) {
-    unsigned originalNumResults = getNumResults();
-    iterateIndicesExcept(originalNumResults, resultIndices, [&](unsigned i) {
-      newResultTypesBuffer.emplace_back(getResult(i));
-    });
-    newResultTypes = newResultTypesBuffer;
-  }
-
-  return get(getContext(), newInputTypes, newResultTypes);
+  SmallVector<Type> argStorage, resultStorage;
+  TypeRange newArgTypes = function_interface_impl::filterTypesOut(
+      getInputs(), argIndices, argStorage);
+  TypeRange newResultTypes = function_interface_impl::filterTypesOut(
+      getResults(), resultIndices, resultStorage);
+  return clone(newArgTypes, newResultTypes);
 }
 
 void FunctionType::walkImmediateSubElements(
     function_ref<void(Attribute)> walkAttrsFn,
     function_ref<void(Type)> walkTypesFn) const {
   for (Type type : llvm::concat<const Type>(getInputs(), getResults()))
     walkTypesFn(type);
 }

mlir/lib/IR/CMakeLists.txt

 add_mlir_library(MLIRIR
   AffineExpr.cpp
   AffineMap.cpp
   AsmPrinter.cpp
   Attributes.cpp
   Block.cpp
   Builders.cpp
   BuiltinAttributeInterfaces.cpp
   BuiltinAttributes.cpp
   BuiltinDialect.cpp
   BuiltinTypes.cpp
   BuiltinTypeInterfaces.cpp
   Diagnostics.cpp
   Dialect.cpp
   Dominance.cpp
   FunctionImplementation.cpp
-  FunctionSupport.cpp
+  FunctionInterfaces.cpp
   IntegerSet.cpp
   Location.cpp
   MLIRContext.cpp
   Operation.cpp
   OperationSupport.cpp
   PatternMatch.cpp
   Region.cpp
   RegionKindInterface.cpp

mlir/lib/IR/FunctionImplementation.cpp

 //===- FunctionImplementation.cpp - Utilities for function-like ops -------===//
 //
 // 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/IR/FunctionImplementation.h"
 #include "mlir/IR/Builders.h"
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/IR/SymbolTable.h"
 
 using namespace mlir;
 
-ParseResult mlir::function_like_impl::parseFunctionArgumentList(
+ParseResult mlir::function_interface_impl::parseFunctionArgumentList(
     OpAsmParser &parser, bool allowAttributes, bool allowVariadic,
     SmallVectorImpl<OpAsmParser::OperandType> &argNames,
     SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
     bool &isVariadic) {
   if (parser.parseLParen())
     return failure();
 
   // The argument list either has to consistently have ssa-id's followed by
do {
     if (parser.parseType(resultTypes.back()) ||
         parser.parseOptionalAttrDict(resultAttrs.back())) {
       return failure();
     }
   } while (succeeded(parser.parseOptionalComma()));
   return parser.parseRParen();
 }
 
-/// Parses a function signature using `parser`. The `allowVariadic` argument
-/// indicates whether functions with variadic arguments are supported. The
-/// trailing arguments are populated by this function with names, types and
-/// attributes of the arguments and those of the results.
-ParseResult mlir::function_like_impl::parseFunctionSignature(
+ParseResult mlir::function_interface_impl::parseFunctionSignature(
     OpAsmParser &parser, bool allowVariadic,
     SmallVectorImpl<OpAsmParser::OperandType> &argNames,
     SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
     bool &isVariadic, SmallVectorImpl<Type> &resultTypes,
     SmallVectorImpl<NamedAttrList> &resultAttrs) {
   bool allowArgAttrs = true;
   if (parseFunctionArgumentList(parser, allowArgAttrs, allowVariadic, argNames,
                                 argTypes, argAttrs, isVariadic))
static void addArgAndResultAttrsImpl(Builder &builder, OperationState &result,
                                      ArrayRef<AttrListT> argAttrs,
                                      ArrayRef<AttrListT> resultAttrs,
                                      AttrArrayBuildFnT &&buildAttrArrayFn) {
   auto nonEmptyAttrsFn = [](const AttrListT &attrs) { return !attrs.empty(); };
 
   // Add the attributes to the function arguments.
   if (!argAttrs.empty() && llvm::any_of(argAttrs, nonEmptyAttrsFn)) {
     ArrayAttr attrDicts = builder.getArrayAttr(buildAttrArrayFn(argAttrs));
-    result.addAttribute(function_like_impl::getArgDictAttrName(), attrDicts);
+    result.addAttribute(function_interface_impl::getArgDictAttrName(),
+                        attrDicts);
   }
   // Add the attributes to the function results.
   if (!resultAttrs.empty() && llvm::any_of(resultAttrs, nonEmptyAttrsFn)) {
     ArrayAttr attrDicts = builder.getArrayAttr(buildAttrArrayFn(resultAttrs));
-    result.addAttribute(function_like_impl::getResultDictAttrName(), attrDicts);
+    result.addAttribute(function_interface_impl::getResultDictAttrName(),
+                        attrDicts);
   }
 }
 
-void mlir::function_like_impl::addArgAndResultAttrs(
+void mlir::function_interface_impl::addArgAndResultAttrs(
     Builder &builder, OperationState &result, ArrayRef<DictionaryAttr> argAttrs,
     ArrayRef<DictionaryAttr> resultAttrs) {
   auto buildFn = [](ArrayRef<DictionaryAttr> attrs) {
     return ArrayRef<Attribute>(attrs.data(), attrs.size());
   };
   addArgAndResultAttrsImpl(builder, result, argAttrs, resultAttrs, buildFn);
 }
-void mlir::function_like_impl::addArgAndResultAttrs(
+void mlir::function_interface_impl::addArgAndResultAttrs(
     Builder &builder, OperationState &result, ArrayRef<NamedAttrList> argAttrs,
     ArrayRef<NamedAttrList> resultAttrs) {
   MLIRContext *context = builder.getContext();
   auto buildFn = [=](ArrayRef<NamedAttrList> attrs) {
     return llvm::to_vector<8>(
         llvm::map_range(attrs, [=](const NamedAttrList &attrList) -> Attribute {
           return attrList.getDictionary(context);
         }));
   };
   addArgAndResultAttrsImpl(builder, result, argAttrs, resultAttrs, buildFn);
 }
 
-/// Parser implementation for function-like operations.  Uses `funcTypeBuilder`
-/// to construct the custom function type given lists of input and output types.
-ParseResult mlir::function_like_impl::parseFunctionLikeOp(
+ParseResult mlir::function_interface_impl::parseFunctionOp(
     OpAsmParser &parser, OperationState &result, bool allowVariadic,
     FuncTypeBuilder funcTypeBuilder) {
   SmallVector<OpAsmParser::OperandType, 4> entryArgs;
   SmallVector<NamedAttrList, 4> argAttrs;
   SmallVector<NamedAttrList, 4> resultAttrs;
   SmallVector<Type, 4> argTypes;
   SmallVector<Type, 4> resultTypes;
   auto &builder = parser.getBuilder();
llvm::interleaveComma(llvm::seq<size_t>(0, types.size()), os, [&](size_t i) {
     p.printType(types[i]);
     if (attrs)
       p.printOptionalAttrDict(attrs[i].cast<DictionaryAttr>().getValue());
   });
   if (needsParens)
     os << ')';
 }
 
-/// Print the signature of the function-like operation `op`.  Assumes `op` has
-/// the FunctionLike trait and passed the verification.
-void mlir::function_like_impl::printFunctionSignature(
+void mlir::function_interface_impl::printFunctionSignature(
     OpAsmPrinter &p, Operation *op, ArrayRef<Type> argTypes, bool isVariadic,
     ArrayRef<Type> resultTypes) {
   Region &body = op->getRegion(0);
   bool isExternal = body.empty();
 
   p << '(';
   ArrayAttr argAttrs = op->getAttrOfType<ArrayAttr>(getArgDictAttrName());
   for (unsigned i = 0, e = argTypes.size(); i < e; ++i) {
void mlir::function_interface_impl::printFunctionSignature(
 
   if (!resultTypes.empty()) {
     p.getStream() << " -> ";
     auto resultAttrs = op->getAttrOfType<ArrayAttr>(getResultDictAttrName());
     printFunctionResultList(p, resultTypes, resultAttrs);
   }
 }
 
-/// Prints the list of function prefixed with the "attributes" keyword. The
-/// attributes with names listed in "elided" as well as those used by the
-/// function-like operation internally are not printed. Nothing is printed
-/// if all attributes are elided. Assumes `op` has the `FunctionLike` trait and
-/// passed the verification.
-void mlir::function_like_impl::printFunctionAttributes(
+void mlir::function_interface_impl::printFunctionAttributes(
     OpAsmPrinter &p, Operation *op, unsigned numInputs, unsigned numResults,
     ArrayRef<StringRef> elided) {
   // Print out function attributes, if present.
   SmallVector<StringRef, 2> ignoredAttrs = {
       ::mlir::SymbolTable::getSymbolAttrName(), getTypeAttrName(),
       getArgDictAttrName(), getResultDictAttrName()};
   ignoredAttrs.append(elided.begin(), elided.end());
 
   p.printOptionalAttrDictWithKeyword(op->getAttrs(), ignoredAttrs);
 }
 
-/// Printer implementation for function-like operations.  Accepts lists of
-/// argument and result types to use while printing.
-void mlir::function_like_impl::printFunctionLikeOp(OpAsmPrinter &p,
-                                                   Operation *op,
-                                                   ArrayRef<Type> argTypes,
-                                                   bool isVariadic,
-                                                   ArrayRef<Type> resultTypes) {
+void mlir::function_interface_impl::printFunctionOp(
+    OpAsmPrinter &p, Operation *op, ArrayRef<Type> argTypes, 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))

mlir/lib/IR/FunctionInterfaces.cpp

 //===- FunctionSupport.cpp - Utility types for function-like ops ----------===//
 //
 // 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/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/BitVector.h"
 
 using namespace mlir;
 
 /// Helper to call a callback once on each index in the range
 /// [0, `totalIndices`), *except* for the indices given in `indices`.
 /// `indices` is allowed to have duplicates and can be in any order.
-inline void iterateIndicesExcept(unsigned totalIndices,
+inline static void iterateIndicesExcept(unsigned totalIndices,
                                         ArrayRef<unsigned> indices,
                                         function_ref<void(unsigned)> callback) {
   llvm::BitVector skipIndices(totalIndices);
   for (unsigned i : indices)
     skipIndices.set(i);
 
   for (unsigned i = 0; i < totalIndices; ++i)
     if (!skipIndices.test(i))
       callback(i);
 }
 
 //===----------------------------------------------------------------------===//
+// Tablegen Interface Definitions
+//===----------------------------------------------------------------------===//
+
+#include "mlir/IR/FunctionOpInterfaces.cpp.inc"
+
+//===----------------------------------------------------------------------===//
 // Function Arguments and Results.
 //===----------------------------------------------------------------------===//
 
 static bool isEmptyAttrDict(Attribute attr) {
   return attr.cast<DictionaryAttr>().empty();
 }
 
-DictionaryAttr mlir::function_like_impl::getArgAttrDict(Operation *op,
+DictionaryAttr mlir::function_interface_impl::getArgAttrDict(Operation *op,
                                                              unsigned index) {
   ArrayAttr attrs = op->getAttrOfType<ArrayAttr>(getArgDictAttrName());
   DictionaryAttr argAttrs =
       attrs ? attrs[index].cast<DictionaryAttr>() : DictionaryAttr();
   return argAttrs;
 }
 
-DictionaryAttr mlir::function_like_impl::getResultAttrDict(Operation *op,
-                                                           unsigned index) {
+DictionaryAttr
+mlir::function_interface_impl::getResultAttrDict(Operation *op,
   ArrayAttr attrs = op->getAttrOfType<ArrayAttr>(getResultDictAttrName());
   DictionaryAttr resAttrs =
       attrs ? attrs[index].cast<DictionaryAttr>() : DictionaryAttr();
   return resAttrs;
 }
 
-void mlir::function_like_impl::detail::setArgResAttrDict(
+void mlir::function_interface_impl::detail::setArgResAttrDict(
     Operation *op, StringRef attrName, unsigned numTotalIndices, unsigned index,
     DictionaryAttr attrs) {
   ArrayAttr allAttrs = op->getAttrOfType<ArrayAttr>(attrName);
   if (!allAttrs) {
     if (attrs.empty())
       return;
 
     // If this attribute is not empty, we need to create a new attribute array.

 static void setAllArgResAttrDicts(Operation *op, StringRef attrName,
                                   ArrayRef<Attribute> attrs) {
   if (llvm::all_of(attrs, isEmptyAttrDict))
     op->removeAttr(attrName);
   else
     op->setAttr(attrName, ArrayAttr::get(op->getContext(), attrs));
 }
 
-void mlir::function_like_impl::setAllArgAttrDicts(
+void mlir::function_interface_impl::setAllArgAttrDicts(
     Operation *op, ArrayRef<DictionaryAttr> attrs) {
   setAllArgAttrDicts(op, ArrayRef<Attribute>(attrs.data(), attrs.size()));
 }
-void mlir::function_like_impl::setAllArgAttrDicts(Operation *op,
-                                                  ArrayRef<Attribute> attrs) {
+void mlir::function_interface_impl::setAllArgAttrDicts(
+    Operation *op, ArrayRef<Attribute> attrs) {
   auto wrappedAttrs = llvm::map_range(attrs, [op](Attribute attr) -> Attribute {
     return !attr ? DictionaryAttr::get(op->getContext()) : attr;
   });
   setAllArgResAttrDicts(op, getArgDictAttrName(),
                         llvm::to_vector<8>(wrappedAttrs));
 }
 
-void mlir::function_like_impl::setAllResultAttrDicts(
+void mlir::function_interface_impl::setAllResultAttrDicts(
     Operation *op, ArrayRef<DictionaryAttr> attrs) {
   setAllResultAttrDicts(op, ArrayRef<Attribute>(attrs.data(), attrs.size()));
 }
-void mlir::function_like_impl::setAllResultAttrDicts(
+void mlir::function_interface_impl::setAllResultAttrDicts(
     Operation *op, ArrayRef<Attribute> attrs) {
   auto wrappedAttrs = llvm::map_range(attrs, [op](Attribute attr) -> Attribute {
     return !attr ? DictionaryAttr::get(op->getContext()) : attr;
   });
   setAllArgResAttrDicts(op, getResultDictAttrName(),
                         llvm::to_vector<8>(wrappedAttrs));
 }
 
-void mlir::function_like_impl::insertFunctionArguments(
+void mlir::function_interface_impl::insertFunctionArguments(
     Operation *op, ArrayRef<unsigned> argIndices, TypeRange argTypes,
     ArrayRef<DictionaryAttr> argAttrs, ArrayRef<Optional<Location>> argLocs,
     unsigned originalNumArgs, Type newType) {
   assert(argIndices.size() == argTypes.size());
   assert(argIndices.size() == argAttrs.size() || argAttrs.empty());
   assert(argIndices.size() == argLocs.size() || argLocs.empty());
   if (argIndices.empty())
     return;
void mlir::function_interface_impl::insertFunctionArguments(
 
   // Update the function type and any entry block arguments.
   op->setAttr(getTypeAttrName(), TypeAttr::get(newType));
   for (unsigned i = 0, e = argIndices.size(); i < e; ++i)
     entry.insertArgument(argIndices[i] + i, argTypes[i],
                          argLocs.empty() ? Optional<Location>{} : argLocs[i]);
 }
 
-void mlir::function_like_impl::insertFunctionResults(
+void mlir::function_interface_impl::insertFunctionResults(
     Operation *op, ArrayRef<unsigned> resultIndices, TypeRange resultTypes,
     ArrayRef<DictionaryAttr> resultAttrs, unsigned originalNumResults,
     Type newType) {
   assert(resultIndices.size() == resultTypes.size());
   assert(resultIndices.size() == resultAttrs.size() || resultAttrs.empty());
   if (resultIndices.empty())
     return;
 
if (oldResultAttrs || !resultAttrs.empty()) {
     migrate(originalNumResults);
     setAllResultAttrDicts(op, newResultAttrs);
   }
 
   // Update the function type.
   op->setAttr(getTypeAttrName(), TypeAttr::get(newType));
 }
 
-void mlir::function_like_impl::eraseFunctionArguments(
+void mlir::function_interface_impl::eraseFunctionArguments(
     Operation *op, ArrayRef<unsigned> argIndices, unsigned originalNumArgs,
     Type newType) {
   // There are 3 things that need to be updated:
   // - Function type.
   // - Arg attrs.
   // - Block arguments of entry block.
   Block &entry = op->getRegion(0).front();
 
   // Update the argument attributes of the function.
   if (auto argAttrs = op->getAttrOfType<ArrayAttr>(getArgDictAttrName())) {
     SmallVector<DictionaryAttr, 4> newArgAttrs;
     newArgAttrs.reserve(argAttrs.size());
     iterateIndicesExcept(originalNumArgs, argIndices, [&](unsigned i) {
       newArgAttrs.emplace_back(argAttrs[i].cast<DictionaryAttr>());
     });
     setAllArgAttrDicts(op, newArgAttrs);
   }
 
   // Update the function type and any entry block arguments.
   op->setAttr(getTypeAttrName(), TypeAttr::get(newType));
   entry.eraseArguments(argIndices);
 }
 
-void mlir::function_like_impl::eraseFunctionResults(
+void mlir::function_interface_impl::eraseFunctionResults(
     Operation *op, ArrayRef<unsigned> resultIndices,
     unsigned originalNumResults, Type newType) {
   // There are 2 things that need to be updated:
   // - Function type.
   // - Result attrs.
 
   // Update the result attributes of the function.
   if (auto resAttrs = op->getAttrOfType<ArrayAttr>(getResultDictAttrName())) {
     SmallVector<DictionaryAttr, 4> newResultAttrs;
     newResultAttrs.reserve(resAttrs.size());
     iterateIndicesExcept(originalNumResults, resultIndices, [&](unsigned i) {
       newResultAttrs.emplace_back(resAttrs[i].cast<DictionaryAttr>());
     });
     setAllResultAttrDicts(op, newResultAttrs);
   }
 
   // Update the function type.
   op->setAttr(getTypeAttrName(), TypeAttr::get(newType));
 }
 
+TypeRange mlir::function_interface_impl::insertTypesInto(
+    TypeRange oldTypes, ArrayRef<unsigned> indices, TypeRange newTypes,
+    SmallVectorImpl<Type> &storage) {
+  assert(indices.size() == newTypes.size() &&
+         "mismatch between indice and type count");
+  if (indices.empty())
+    return oldTypes;
+
+  auto fromIt = oldTypes.begin();
+  for (auto it : llvm::zip(indices, newTypes)) {
+    const auto toIt = oldTypes.begin() + std::get<0>(it);
+    storage.append(fromIt, toIt);
+    storage.push_back(std::get<1>(it));
+    fromIt = toIt;
+  }
+  storage.append(fromIt, oldTypes.end());
+  return storage;
+}
+
+TypeRange
+mlir::function_interface_impl::filterTypesOut(TypeRange types,
+                                              ArrayRef<unsigned> indices,
+                                              SmallVectorImpl<Type> &storage) {
+  if (indices.empty())
+    return types;
+  iterateIndicesExcept(types.size(), indices,
+                       [&](unsigned i) { storage.emplace_back(types[i]); });
+  return storage;
+}
+
 //===----------------------------------------------------------------------===//
 // Function type signature.
 //===----------------------------------------------------------------------===//
 
-FunctionType mlir::function_like_impl::getFunctionType(Operation *op) {
-  assert(op->hasTrait<OpTrait::FunctionLike>());
-  return op->getAttrOfType<TypeAttr>(getTypeAttrName())
-      .getValue()
-      .cast<FunctionType>();
-}
-
-void mlir::function_like_impl::setFunctionType(Operation *op,
-                                               FunctionType newType) {
-  assert(op->hasTrait<OpTrait::FunctionLike>());
-  FunctionType oldType = getFunctionType(op);
+void mlir::function_interface_impl::setFunctionType(Operation *op,
+                                                    Type newType) {
+  FunctionOpInterface funcOp = cast<FunctionOpInterface>(op);
+  unsigned oldNumArgs = funcOp.getNumArguments();
+  unsigned oldNumResults = funcOp.getNumResults();
   op->setAttr(getTypeAttrName(), TypeAttr::get(newType));
+  unsigned newNumArgs = funcOp.getNumArguments();
+  unsigned newNumResults = funcOp.getNumResults();
 
   // Functor used to update the argument and result attributes of the function.
   auto updateAttrFn = [&](StringRef attrName, unsigned oldCount,
                           unsigned newCount, auto setAttrFn) {
     if (oldCount == newCount)
       return;
     // The new type has no arguments/results, just drop the attribute.
     if (newCount == 0) {
auto updateAttrFn = [&](StringRef attrName, unsigned oldCount,
     // Otherwise, the new type has more arguments/results. Initialize the new
     // arguments/results with empty attributes.
     SmallVector<Attribute> newAttrs(attrs.begin(), attrs.end());
     newAttrs.resize(newCount);
     setAttrFn(op, newAttrs);
   };
 
   // Update the argument and result attributes.
-  updateAttrFn(function_like_impl::getArgDictAttrName(), oldType.getNumInputs(),
-               newType.getNumInputs(), [&](Operation *op, auto &&attrs) {
-                 setAllArgAttrDicts(op, attrs);
-               });
   updateAttrFn(
-      function_like_impl::getResultDictAttrName(), oldType.getNumResults(),
-      newType.getNumResults(),
+      getArgDictAttrName(), oldNumArgs, newNumArgs,
+      [&](Operation *op, auto &&attrs) { setAllArgAttrDicts(op, attrs); });
+  updateAttrFn(
+      getResultDictAttrName(), oldNumResults, newNumResults,
       [&](Operation *op, auto &&attrs) { setAllResultAttrDicts(op, attrs); });
 }
-
-//===----------------------------------------------------------------------===//
-// Function body.
-//===----------------------------------------------------------------------===//
-
-Region &mlir::function_like_impl::getFunctionBody(Operation *op) {
-  assert(op->hasTrait<OpTrait::FunctionLike>());
-  return op->getRegion(0);
-}

mlir/lib/Tools/mlir-lsp-server/MLIRServer.cpp

void MLIRDocument::findDocumentSymbols(
     Operation *op, std::vector<lsp::DocumentSymbol> &symbols) {
   std::vector<lsp::DocumentSymbol> *childSymbols = &symbols;
 
   // Check for the source information of this operation.
   if (const AsmParserState::OperationDefinition *def = asmState.getOpDef(op)) {
     // If this operation defines a symbol, record it.
     if (SymbolOpInterface symbol = dyn_cast<SymbolOpInterface>(op)) {
       symbols.emplace_back(symbol.getName(),
-                           op->hasTrait<OpTrait::FunctionLike>()
+                           isa<FunctionOpInterface>(op)
                                ? lsp::SymbolKind::Function
                                : lsp::SymbolKind::Class,
                            getRangeFromLoc(sourceMgr, def->scopeLoc),
                            getRangeFromLoc(sourceMgr, def->loc));
       childSymbols = &symbols.back().children;
 
     } else if (op->hasTrait<OpTrait::SymbolTable>()) {
       // Otherwise, if this is a symbol table push an anonymous document symbol.

mlir/lib/Transforms/NormalizeMemRefs.cpp

void NormalizeMemRefs::setCalleesAndCallersNonNormalizable(
 
   LLVM_DEBUG(
       llvm::dbgs() << "@" << funcOp.getName()
                    << " calls or is called by non-normalizable function\n");
   normalizableFuncs.erase(funcOp);
   // Caller of the function.
   Optional<SymbolTable::UseRange> symbolUses = funcOp.getSymbolUses(moduleOp);
   for (SymbolTable::SymbolUse symbolUse : *symbolUses) {
-    // TODO: Extend this for ops that are FunctionLike. This would require
-    // creating an OpInterface for FunctionLike ops.
+    // TODO: Extend this for ops that are FunctionOpInterface. This would
+    // require creating an OpInterface for FunctionOpInterface ops.
     FuncOp parentFuncOp = symbolUse.getUser()->getParentOfType<FuncOp>();
     for (FuncOp &funcOp : normalizableFuncs) {
       if (parentFuncOp == funcOp) {
         setCalleesAndCallersNonNormalizable(funcOp, moduleOp,
                                             normalizableFuncs);
         break;
       }
     }
for (SymbolTable::SymbolUse symbolUse : *symbolUses) {
     if (returnTypeChanged) {
       // Since the return type changed it might lead to a change in function's
       // signature.
       // TODO: If funcOp doesn't return any memref type then no need to update
       // signature.
       // TODO: Further optimization - Check if the memref is indeed part of
       // ReturnOp at the parentFuncOp and only then updation of signature is
       // required.
-      // TODO: Extend this for ops that are FunctionLike. This would require
-      // creating an OpInterface for FunctionLike ops.
+      // TODO: Extend this for ops that are FunctionOpInterface. This would
+      // require creating an OpInterface for FunctionOpInterface ops.
       FuncOp parentFuncOp = newCallOp->getParentOfType<FuncOp>();
       funcOpsToUpdate.insert(parentFuncOp);
     }
   }
   // Because external function's signature is already updated in
   // 'normalizeFuncOpMemRefs()', we don't need to update it here again.
   if (!funcOp.isExternal())
     funcOp.setType(newFuncType);

mlir/lib/Transforms/Utils/DialectConversion.cpp

 //===- DialectConversion.cpp - MLIR dialect conversion generic pass -------===//
 //
 // 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/Transforms/DialectConversion.h"
 #include "mlir/IR/Block.h"
 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinOps.h"
-#include "mlir/IR/FunctionSupport.h"
+#include "mlir/IR/FunctionInterfaces.h"
 #include "mlir/Rewrite/PatternApplicator.h"
 #include "mlir/Transforms/Utils.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/SaveAndRestore.h"
auto TypeConverter::convertBlockSignature(Block *block)
     -> Optional<SignatureConversion> {
   SignatureConversion conversion(block->getNumArguments());
   if (failed(convertSignatureArgs(block->getArgumentTypes(), conversion)))
     return llvm::None;
   return conversion;
 }
 
 //===----------------------------------------------------------------------===//
-// FunctionLikeSignatureConversion
+// FunctionOpInterfaceSignatureConversion
 //===----------------------------------------------------------------------===//
 
 /// Create a default conversion pattern that rewrites the type signature of a
-/// FunctionLike op. This only supports FunctionLike ops which use FunctionType
-/// to represent their type.
+/// FunctionOpInterface op. This only supports ops which use FunctionType to
+/// represent their type.
 namespace {
-struct FunctionLikeSignatureConversion : public ConversionPattern {
-  FunctionLikeSignatureConversion(StringRef functionLikeOpName,
-                                  MLIRContext *ctx, TypeConverter &converter)
+struct FunctionOpInterfaceSignatureConversion : public ConversionPattern {
+  FunctionOpInterfaceSignatureConversion(StringRef functionLikeOpName,
+                                         MLIRContext *ctx,
+                                         TypeConverter &converter)
       : ConversionPattern(converter, functionLikeOpName, /*benefit=*/1, ctx) {}
 
-  /// Hook to implement combined matching and rewriting for FunctionLike ops.
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
-    FunctionType type = function_like_impl::getFunctionType(op);
+    FunctionOpInterface funcOp = cast<FunctionOpInterface>(op);
+    FunctionType type = funcOp.getType().cast<FunctionType>();
 
     // Convert the original function types.
     TypeConverter::SignatureConversion result(type.getNumInputs());
     SmallVector<Type, 1> newResults;
     if (failed(typeConverter->convertSignatureArgs(type.getInputs(), result)) ||
         failed(typeConverter->convertTypes(type.getResults(), newResults)) ||
-        failed(rewriter.convertRegionTypes(
-            &function_like_impl::getFunctionBody(op), *typeConverter, &result)))
+        failed(rewriter.convertRegionTypes(&funcOp.getBody(), *typeConverter,
+                                           &result)))
       return failure();
 
     // Update the function signature in-place.
     auto newType = FunctionType::get(rewriter.getContext(),
                                      result.getConvertedTypes(), newResults);
 
-    rewriter.updateRootInPlace(
-        op, [&] { function_like_impl::setFunctionType(op, newType); });
+    rewriter.updateRootInPlace(op, [&] { funcOp.setType(newType); });
 
     return success();
   }
 };
 } // namespace
 
-void mlir::populateFunctionLikeTypeConversionPattern(
+void mlir::populateFunctionOpInterfaceTypeConversionPattern(
     StringRef functionLikeOpName, RewritePatternSet &patterns,
     TypeConverter &converter) {
-  patterns.add<FunctionLikeSignatureConversion>(
+  patterns.add<FunctionOpInterfaceSignatureConversion>(
       functionLikeOpName, patterns.getContext(), converter);
 }
 
 //===----------------------------------------------------------------------===//
 // ConversionTarget
 //===----------------------------------------------------------------------===//
 
 void ConversionTarget::setOpAction(OperationName op,

mlir/test/Dialect/LLVMIR/func.mlir

module {
   llvm.func @variadic_def(...) {
     llvm.return
   }
 }
 
 // -----
 
 module {
+  // expected-error@+1 {{cannot attach result attributes to functions with a void return}}
+  llvm.func @variadic_def() -> (!llvm.void {llvm.noalias})
+}
+
+// -----
+
+module {
   // expected-error@+1 {{variadic arguments must be in the end of the argument list}}
   llvm.func @variadic_inside(%arg0: i32, ..., %arg1: i32)
 }
 
 // -----
 
 module {
   // expected-error@+1 {{external functions must have 'external' or 'extern_weak' linkage}}

mlir/test/lib/Dialect/Test/TestPatterns.cpp

patterns
              TestCreateBlock, TestCreateIllegalBlock, TestUndoBlockArgReplace,
              TestUndoBlockErase, TestPassthroughInvalidOp, TestSplitReturnType,
              TestChangeProducerTypeI32ToF32, TestChangeProducerTypeF32ToF64,
              TestChangeProducerTypeF32ToInvalid, TestUpdateConsumerType,
              TestNonRootReplacement, TestBoundedRecursiveRewrite,
              TestNestedOpCreationUndoRewrite, TestReplaceEraseOp,
              TestCreateUnregisteredOp>(&getContext());
     patterns.add<TestDropOpSignatureConversion>(&getContext(), converter);
-    mlir::populateFunctionLikeTypeConversionPattern<FuncOp>(patterns, converter);
+    mlir::populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns,
+                                                                   converter);
     mlir::populateCallOpTypeConversionPattern(patterns, converter);
 
     // Define the conversion target used for the test.
     ConversionTarget target(getContext());
     target.addLegalOp<ModuleOp>();
     target.addLegalOp<LegalOpA, LegalOpB, LegalOpC, TestCastOp, TestValidOp,
                       TerminatorOp>();
     target
void runOnOperation() override {
 
     // Initialize the set of rewrite patterns.
     RewritePatternSet patterns(&getContext());
     patterns.add<TestTypeConsumerForward, TestTypeConversionProducer,
                  TestSignatureConversionUndo,
                  TestTestSignatureConversionNoConverter>(converter,
                                                          &getContext());
     patterns.add<TestTypeConversionAnotherProducer>(&getContext());
-    mlir::populateFunctionLikeTypeConversionPattern<FuncOp>(patterns, converter);
+    mlir::populateFunctionOpInterfaceTypeConversionPattern<FuncOp>(patterns,
+                                                                   converter);
 
     if (failed(applyPartialConversion(getOperation(), target,
                                       std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 

mlir/test/lib/IR/TestFunc.cpp

-//===- TestFunctionLike.cpp - Pass to test helpers on FunctionLike --------===//
+//===- TestFunc.cpp - Pass to test helpers on function utilities ----------===//
 //
 // 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/IR/BuiltinOps.h"