[mlir] Make FunctionOpInterface inherit SymbolOpInterface

[rriddle]

Summary

This lets users of FunctionOpInterface finally have the
name/visibility accessors from SymbolOpInterface. This also
lets us remove the clunky "getName" method from FunctionOpInterface.

[jpienaar]

mlir/include/mlir/IR/FunctionInterfaces.td

17

I'd include both of these rather than rely on transitivity (tblgen side I try to keep things dead simple, and while good to keep things minimal, explicit is less surprising).

[rriddle]

mlir/include/mlir/IR/FunctionInterfaces.td

17

Why? I don't follow that anywhere else in tablegen, and it also breaks from our existing C++ coding style.

mlir/examples/toy/Ch2/include/toy/Ops.td

def AddOp : Toy_Op<"add"> {
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Toy_Op<"func", [
-    FunctionOpInterface, IsolatedFromAbove, Symbol
+    FunctionOpInterface, IsolatedFromAbove
   ]> {
   let summary = "user defined function operation";
   let description = [{
     The "toy.func" operation represents a user defined function. These are
     callable SSA-region operations that contain toy computations.
 
     Example:
 

mlir/examples/toy/Ch3/include/toy/Ops.td

def AddOp : Toy_Op<"add", [Pure]> {
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Toy_Op<"func", [
-    FunctionOpInterface, IsolatedFromAbove, Symbol
+    FunctionOpInterface, IsolatedFromAbove
   ]> {
   let summary = "user defined function operation";
   let description = [{
     The "toy.func" operation represents a user defined function. These are
     callable SSA-region operations that contain toy computations.
 
     Example:
 

mlir/examples/toy/Ch4/include/toy/Ops.td

 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Toy_Op<"func", [
     DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
-    IsolatedFromAbove, Symbol
+    IsolatedFromAbove
   ]> {
   let summary = "user defined function operation";
   let description = [{
     The "toy.func" operation represents a user defined function. These are
     callable SSA-region operations that contain toy computations.
 
     Example:
 

mlir/examples/toy/Ch5/include/toy/Ops.td

 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Toy_Op<"func", [
     DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
-    IsolatedFromAbove, Symbol
+    IsolatedFromAbove
   ]> {
   let summary = "user defined function operation";
   let description = [{
     The "toy.func" operation represents a user defined function. These are
     callable SSA-region operations that contain toy computations.
 
     Example:
 

mlir/examples/toy/Ch6/include/toy/Ops.td

 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Toy_Op<"func", [
     DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
-    IsolatedFromAbove, Symbol
+    IsolatedFromAbove
   ]> {
   let summary = "user defined function operation";
   let description = [{
     The "toy.func" operation represents a user defined function. These are
     callable SSA-region operations that contain toy computations.
 
     Example:
 

mlir/examples/toy/Ch7/include/toy/Ops.td

 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Toy_Op<"func", [
     DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
-    IsolatedFromAbove, Symbol
+    IsolatedFromAbove
   ]> {
   let summary = "user defined function operation";
   let description = [{
     The "toy.func" operation represents a user defined function. These are
     callable SSA-region operations that contain toy computations.
 
     Example:
 

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

let extraClassDeclaration = [{
     using BodyBuilderFn =
         function_ref<void(OpBuilder &, Location, ValueRange)>;
 
   }];
 }
 
 def Async_FuncOp : Async_Op<"func",
     [CallableOpInterface, FunctionOpInterface,
-     IsolatedFromAbove, OpAsmOpInterface, Symbol]> {
+     IsolatedFromAbove, OpAsmOpInterface]> {
   let summary = "async function operation";
   let description = [{
     An async function is like a normal function, but supports non-blocking
     await. Internally, async function is lowered to the LLVM coroutinue with
     async runtime intrinsic. It can return an async token and/or async values.
     The token represents the execution state of async function and can be used
     when users want to express dependencies on some side effects, e.g.,
     the token becomes available once every thing in the func body is executed.

mlir/include/mlir/Dialect/Func/IR/FuncOps.td

 }
 
 //===----------------------------------------------------------------------===//
 // FuncOp
 //===----------------------------------------------------------------------===//
 
 def FuncOp : Func_Op<"func", [
   AffineScope, AutomaticAllocationScope, CallableOpInterface,
-  FunctionOpInterface, IsolatedFromAbove, OpAsmOpInterface, Symbol
+  FunctionOpInterface, IsolatedFromAbove, OpAsmOpInterface
 ]> {
   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

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

let description = [{
     ```
   }];
 
   let assemblyFormat = "attr-dict `:` type($result)";
 }
 
 def GPU_GPUFuncOp : GPU_Op<"func", [
     HasParent<"GPUModuleOp">, AutomaticAllocationScope, FunctionOpInterface,
-    IsolatedFromAbove, Symbol
+    IsolatedFromAbove
   ]> {
   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

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

def LLVM_GlobalDtorsOp : LLVM_Op<"mlir.global_dtors", [
 
   }];
   let assemblyFormat = "attr-dict";
   let hasVerifier = 1;
 }
 
 def LLVM_LLVMFuncOp : LLVM_Op<"func", [
     AutomaticAllocationScope, IsolatedFromAbove, FunctionOpInterface,
-    CallableOpInterface, Symbol
+    CallableOpInterface
   ]> {
   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

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

def PDLInterp_ForEachOp
   let hasVerifier = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // pdl_interp::FuncOp
 //===----------------------------------------------------------------------===//
 
 def PDLInterp_FuncOp : PDLInterp_Op<"func", [
-    FunctionOpInterface, IsolatedFromAbove, Symbol
+    FunctionOpInterface, IsolatedFromAbove
   ]> {
   let summary = "PDL Interpreter Function Operation";
   let description = [{
     `pdl_interp.func` operations act as interpreter functions. These are
     callable SSA-region operations that contain other interpreter operations.
     Interpreter functions are used for both the matching and the rewriting
     portion of the interpreter.
 

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

let builders = [
     OpBuilder<(ins "spirv::FuncOp":$function,
       "spirv::ExecutionMode":$executionMode, "ArrayRef<int32_t>":$params)>];
 }
 
 // -----
 
 def SPIRV_FuncOp : SPIRV_Op<"func", [
     AutomaticAllocationScope, DeclareOpInterfaceMethods<CallableOpInterface>,
-    FunctionOpInterface, InModuleScope, IsolatedFromAbove, Symbol
+    FunctionOpInterface, InModuleScope, IsolatedFromAbove
   ]> {
   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

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

def Shape_FunctionLibraryOp : Shape_Op<"function_library",
 
   let builders = [OpBuilder<(ins "StringRef":$name)>];
   let skipDefaultBuilders = 1;
   let hasCustomAssemblyFormat = 1;
 }
 
 def Shape_FuncOp : Shape_Op<"func",
     [AffineScope, AutomaticAllocationScope, CallableOpInterface,
-     FunctionOpInterface, IsolatedFromAbove, OpAsmOpInterface, Symbol]> {
+     FunctionOpInterface, IsolatedFromAbove, OpAsmOpInterface]> {
   let summary = "Shape function";
   let description = [{
     An operation with a name containing a single `SSACFG` region which
     represents a shape transfer function or helper function for shape transfer
     function.
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name,

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"
+include "mlir/IR/SymbolInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // FunctionOpInterface
 //===----------------------------------------------------------------------===//
 
-def FunctionOpInterface : OpInterface<"FunctionOpInterface"> {
+def FunctionOpInterface : OpInterface<"FunctionOpInterface", [Symbol]> {
   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.
InterfaceMethod<[{
       invariants.
     }],
     "::mlir::LogicalResult", "verifyType", (ins),
     /*methodBody=*/[{}], /*defaultImplementation=*/[{
       return success();
     }]>,
   ];
 
-  let extraClassDeclaration = [{
-    //===------------------------------------------------------------------===//
-    // Name
-    //===------------------------------------------------------------------===//
-
-    /// Return the name of the function.
-    StringRef getName() { return SymbolTable::getSymbolName(*this); }
-  }];
   let extraTraitClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // Builders
     //===------------------------------------------------------------------===//
 
     /// Build the function with the given name, attributes, and type. This
     /// builder also inserts an entry block into the function body with the
     /// given argument types.

mlir/test/Dialect/Func/invalid.mlir

 // -----
 
 // expected-error @+1 {{@ identifier expected to start with letter or '_'}}
 func.func @$invalid_function_name()
 
 // -----
 
 // expected-error @+1 {{arguments may only have dialect attributes}}
-func.func @invalid_func_arg_attr(i1 {non_dialect_attr = 10})
+func.func private @invalid_func_arg_attr(i1 {non_dialect_attr = 10})
 
 // -----
 
 // expected-error @+1 {{results may only have dialect attributes}}
-func.func @invalid_func_result_attr() -> (i1 {non_dialect_attr = 10})
+func.func private @invalid_func_result_attr() -> (i1 {non_dialect_attr = 10})
 
 // -----
 
 func.func @foo() {} // expected-error {{expected non-empty function body}}