[mlir][toy] Define a FuncOp operation in toy and drop the dependence on FuncOp

[rriddle]

Summary

FuncOp is being moved out of the builtin dialect, and defining a custom
toy operation showcases various aspects of defining function-like operation
(e.g. inlining, passes, etc.).

[mehdi_amini]

(some comments from the parent revision apply here but I don't repeat them)

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

122

Interesting, the comment didn't match the implementation: the function wasn't added to the module...

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

230

Is this necessary to get out of toy::FuncOp here?

[rriddle]

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

122

Yeah... I assume this was something from very early on that didn't get adapted as the contents of the function changed. Interestingly enough, the comment is now actually accurate.

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

230

I adapted here because we already lower ReturnOp here, which needs to be lowered at the same time. We also use some FuncOp specific affine optimization passes right afterwards, so we would need to drop out of toy::FuncOp around this point anyways.

mlir/docs/Tutorials/Toy/Ch-2.md

 
 ### Opaque API
 
 MLIR is designed to allow all IR elements, such as attributes, operations, and
 types, to be customized. At the same time, IR elements can always be reduced to
 the above fundamental concepts. This allows MLIR to parse, represent, and
 [round-trip](../../../getting_started/Glossary.md/#round-trip) IR for *any*
 operation. For example, we could place our Toy operation from above into an
-`.mlir` file and round-trip through *mlir-opt* without registering any dialect:
+`.mlir` file and round-trip through *mlir-opt* without registering any `toy`
+related dialect:
 
 ```mlir
 func @toy_func(%tensor: tensor<2x3xf64>) -> tensor<3x2xf64> {
   %t_tensor = "toy.transpose"(%tensor) { inplace = true } : (tensor<2x3xf64>) -> tensor<3x2xf64>
   return %t_tensor : tensor<3x2xf64>
 }
 ```
 
def main() {
   print(d);
 }
 ```
 
 Results in the following IR:
 
 ```mlir
 module {
-  func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
+  "toy.func"() ({
+  ^bb0(%arg0: tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":4:1), %arg1: tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":4:1)):
     %0 = "toy.transpose"(%arg0) : (tensor<*xf64>) -> tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":5:10)
     %1 = "toy.transpose"(%arg1) : (tensor<*xf64>) -> tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":5:25)
     %2 = "toy.mul"(%0, %1) : (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":5:25)
     "toy.return"(%2) : (tensor<*xf64>) -> () loc("test/Examples/Toy/Ch2/codegen.toy":5:3)
-  } loc("test/Examples/Toy/Ch2/codegen.toy":4:1)
-  func @main() {
+  }) {sym_name = "multiply_transpose", type = (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>} : () -> () loc("test/Examples/Toy/Ch2/codegen.toy":4:1)
+  "toy.func"() ({
     %0 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64> loc("test/Examples/Toy/Ch2/codegen.toy":9:17)
     %1 = "toy.reshape"(%0) : (tensor<2x3xf64>) -> tensor<2x3xf64> loc("test/Examples/Toy/Ch2/codegen.toy":9:3)
     %2 = "toy.constant"() {value = dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>} : () -> tensor<6xf64> loc("test/Examples/Toy/Ch2/codegen.toy":10:17)
     %3 = "toy.reshape"(%2) : (tensor<6xf64>) -> tensor<2x3xf64> loc("test/Examples/Toy/Ch2/codegen.toy":10:3)
     %4 = "toy.generic_call"(%1, %3) {callee = @multiply_transpose} : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":11:11)
     %5 = "toy.generic_call"(%3, %1) {callee = @multiply_transpose} : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":12:11)
     "toy.print"(%5) : (tensor<*xf64>) -> () loc("test/Examples/Toy/Ch2/codegen.toy":13:3)
     "toy.return"() : () -> () loc("test/Examples/Toy/Ch2/codegen.toy":8:1)
-  } loc("test/Examples/Toy/Ch2/codegen.toy":8:1)
+  }) {sym_name = "main", type = () -> ()} : () -> () loc("test/Examples/Toy/Ch2/codegen.toy":8:1)
 } loc(unknown)
 ```
 
 One thing to notice here is that all of our Toy operations are printed using the
 generic assembly format. This format is the one shown when breaking down
 `toy.transpose` at the beginning of this chapter. MLIR allows for operations to
 define their own custom assembly format, either
 [declaratively](../../OpDefinitions.md/#declarative-assembly-format) or

 
 The [declarative format](../../OpDefinitions.md/#declarative-assembly-format) has
 many more interesting features, so be sure to check it out before implementing a
 custom format in C++. After beautifying the format of a few of our operations we
 now get a much more readable:
 
 ```mlir
 module {
-  func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
+  toy.func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
     %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":5:10)
     %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":5:25)
     %2 = toy.mul %0, %1 : tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":5:25)
     toy.return %2 : tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":5:3)
   } loc("test/Examples/Toy/Ch2/codegen.toy":4:1)
-  func @main() {
+  toy.func @main() {
     %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64> loc("test/Examples/Toy/Ch2/codegen.toy":9:17)
     %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64> loc("test/Examples/Toy/Ch2/codegen.toy":9:3)
     %2 = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64> loc("test/Examples/Toy/Ch2/codegen.toy":10:17)
     %3 = toy.reshape(%2 : tensor<6xf64>) to tensor<2x3xf64> loc("test/Examples/Toy/Ch2/codegen.toy":10:3)
     %4 = toy.generic_call @multiply_transpose(%1, %3) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":11:11)
     %5 = toy.generic_call @multiply_transpose(%3, %1) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":12:11)
     toy.print %5 : tensor<*xf64> loc("test/Examples/Toy/Ch2/codegen.toy":13:3)
     toy.return loc("test/Examples/Toy/Ch2/codegen.toy":8:1)

mlir/docs/Tutorials/Toy/Ch-3.md

 def transpose_transpose(x) {
   return transpose(transpose(x));
 }
 ```
 
 Which corresponds to the following IR:
 
 ```mlir
-func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
+toy.func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%0 : tensor<*xf64>) to tensor<*xf64>
   toy.return %1 : tensor<*xf64>
 }
 ```
 
 This is a good example of a transformation that is trivial to match on the Toy
 IR but that would be quite hard for LLVM to figure. For example, today Clang

 ```
 
 We also need to update our main file, `toyc.cpp`, to add an optimization
 pipeline. In MLIR, the optimizations are run through a `PassManager` in a
 similar way to LLVM:
 
 ```c++
   mlir::PassManager pm(module.getContext());
-  pm.addNestedPass<mlir::FuncOp>(mlir::createCanonicalizerPass());
+  pm.addNestedPass<mlir::toy::FuncOp>(mlir::createCanonicalizerPass());
 ```
 
 Finally, we can run `toyc-ch3 test/Examples/Toy/Ch3/transpose_transpose.toy 
 -emit=mlir -opt` and observe our pattern in action:
 
 ```mlir
-func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
+toy.func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   toy.return %arg0 : tensor<*xf64>
 }
 ```
 
 As expected, we now directly return the function argument, bypassing any
 transpose operation. However, one of the transposes still hasn't been
 eliminated. That is not ideal! What happened is that our pattern replaced the
 last transform with the function input and left behind the now dead transpose
 input. The Canonicalizer knows to clean up dead operations; however, MLIR
 conservatively assumes that operations may have side-effects. We can fix this by
 adding a new trait, `NoSideEffect`, to our `TransposeOp`:
 
 ```tablegen
 def TransposeOp : Toy_Op<"transpose", [NoSideEffect]> {...}
 ```
 
 Let's retry now `toyc-ch3 test/transpose_transpose.toy -emit=mlir -opt`:
 
 ```mlir
-func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
+toy.func @transpose_transpose(%arg0: tensor<*xf64>) -> tensor<*xf64> {
   toy.return %arg0 : tensor<*xf64>
 }
 ```
 
 Perfect! No `transpose` operation is left - the code is optimal.
 
 In the next section, we use DRR for pattern match optimizations associated with
 the Reshape op.
def main() {
   var b<2,1> = a;
   var c<2,1> = b;
   print(c);
 }
 ```
 
 ```mlir
 module {
-  func @main() {
+  toy.func @main() {
     %0 = toy.constant dense<[1.000000e+00, 2.000000e+00]> : tensor<2xf64>
     %1 = toy.reshape(%0 : tensor<2xf64>) to tensor<2x1xf64>
     %2 = toy.reshape(%1 : tensor<2x1xf64>) to tensor<2x1xf64>
     %3 = toy.reshape(%2 : tensor<2x1xf64>) to tensor<2x1xf64>
     toy.print %3 : tensor<2x1xf64>
     toy.return
   }
 }
 ```
 
 We can try to run `toyc-ch3 test/Examples/Toy/Ch3/trivial_reshape.toy -emit=mlir 
 -opt` and observe our pattern in action:
 
 ```mlir
 module {
-  func @main() {
+  toy.func @main() {
     %0 = toy.constant dense<[[1.000000e+00], [2.000000e+00]]> : tensor<2x1xf64>
     toy.print %0 : tensor<2x1xf64>
     toy.return
   }
 }
 ```
 
 As expected, no reshape operations remain after canonicalization.
 
 Further details on the declarative rewrite method can be found at
 [Table-driven Declarative Rewrite Rule (DRR)](../../DeclarativeRewrites.md).
 
 In this chapter, we saw how to use certain core transformations through always
 available hooks. In the [next chapter](Ch-4.md), we will see how to use generic
 solutions that scale better through Interfaces.

mlir/docs/Tutorials/Toy/Ch-4.md

struct ToyInlinerInterface : public DialectInlinerInterface {
   /// This hook checks to see if the given operation is legal to inline into the
   /// given region. For Toy this hook can simply return true, as all Toy
   /// operations are inlinable.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 
+  /// This hook cheks if the given 'src' region can be inlined into the 'dest'
+  /// region. The regions here are the bodies of the callable functions. For
+  /// Toy, any function can be inlined, so we simply return true.
+  bool isLegalToInline(Region *dest, Region *src, bool wouldBeCloned,
+                       BlockAndValueMapping &valueMapping) const final {
+    return true;
+  }
+
   /// This hook is called when a terminator operation has been inlined. The only
   /// terminator that we have in the Toy dialect is the return
   /// operation(toy.return). We handle the return by replacing the values
   /// previously returned by the call operation with the operands of the
   /// return.
   void handleTerminator(Operation *op,
                         ArrayRef<Value> valuesToRepl) const final {
     // Only "toy.return" needs to be handled here.
     auto returnOp = cast<ReturnOp>(op);
 
     // Replace the values directly with the return operands.
     assert(returnOp.getNumOperands() == valuesToRepl.size());
     for (const auto &it : llvm::enumerate(returnOp.getOperands()))
       valuesToRepl[it.index()].replaceAllUsesWith(it.value());
   }
 };
 ```
 
 Besides, the inliner will only discard private-visible unused function
 definitions. We also have to set the visibility of functions (except the
 main function) in the MLIR generator.
 
 ```c++
 /// Emit a new function and add it to the MLIR module.
-mlir::FuncOp mlirGen(FunctionAST &funcAST) {
+mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
   ...
   // If this function isn't main, then set the visibility to private.
   if (funcAST.getProto()->getName() != "main")
     function.setPrivate();
 
   return function;
 }
 ```
 
 We then register our dialect interface directly on the Toy dialect, similarly to
 how we did for operations.
 
 ```c++
 void ToyDialect::initialize() {
   addInterfaces<ToyInlinerInterface>();
 }
 ```
 
 Next, we need to provide a way for the inliner to know that `toy.generic_call`
-represents a call to a function. MLIR provides an
-[operation interface](../../Interfaces.md/#attributeoperationtype-interfaces) that can be used
-to mark an operation as being "call-like". Unlike dialect interfaces, operation
-interfaces provide a more refined granularity of information that is specific
-and core to a single operation. The interface that we will be adding here is the
-`CallOpInterface`.
+represents a call, and `toy.func` represents a function. MLIR provides
+[operation interfaces](../../Interfaces.md/#attributeoperationtype-interfaces) that can be used
+to mark an operation as being "call-like" or "callable-like". Unlike dialect interfaces,
+operation interfaces provide a more refined granularity of information that is specific
+and core to a single operation. The interfaces that we will be adding here is the
+`CallOpInterface` and `CallableOpInterface`.
 
 To add this interface we just need to include the definition into our operation
 specification file (`Ops.td`):
 
 ```tablegen
 include "mlir/Interfaces/CallInterfaces.td"
 ```
 
 and add it to the traits list of `GenericCallOp`:
 
 ```tablegen
+def FuncOp : Toy_Op<"func",
+    [DeclareOpInterfaceMethods<CallableOpInterface>]> {
+  ...
+}
+
 def GenericCallOp : Toy_Op<"generic_call",
     [DeclareOpInterfaceMethods<CallOpInterface>]> {
   ...
 }
 ```
 
 In the above we also use the `DeclareOpInterfaceMethods` directive to
 auto-declare all of the interface methods in the class declaration of
 GenericCallOp. This means that we just need to provide a definition:
 
 ```c++
+/// Returns the region on the function operation that is callable.
+Region *FuncOp::getCallableRegion() { return &getBody(); }
+
+/// Returns the results types that the callable region produces when
+/// executed.
+ArrayRef<Type> FuncOp::getCallableResults() { return getType().getResults(); }
+
+// ....
+
 /// Return the callee of the generic call operation, this is required by the
 /// call interface.
 CallInterfaceCallable GenericCallOp::getCallableForCallee() {
   return getAttrOfType<SymbolRefAttr>("callee");
 }
 
 /// Get the argument operands to the called function, this is required by the
 /// call interface.
 Operation::operand_range GenericCallOp::getArgOperands() { return inputs(); }
 ```
 
 Now that the inliner has been informed about the Toy dialect, we can add the
 inliner pass to the pass manager for Toy:
 
 ```c++
   pm.addPass(mlir::createInlinerPass());
 ```
 
 Now let's look at a working example:
 
 ```mlir
-func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
+toy.func @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>
   %2 = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
   %3 = toy.reshape(%2 : tensor<6xf64>) to tensor<2x3xf64>
   %4 = toy.generic_call @multiply_transpose(%1, %3) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   %5 = toy.generic_call @multiply_transpose(%3, %1) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   toy.print %5 : tensor<*xf64>
   toy.return
let description = [{
     without changing any data elements. The source and destination types
     must both be tensor types with the same element type. If both are ranked,
     then shape is required to match. The operation is invalid if converting
     to a mismatching constant dimension.
   }];
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor:$output);
+  let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 }
 ```
 
 Note that the definition of this cast operation adds a `CastOpInterface` to the
 traits list. This interface provides several utilities for cast-like operation,
 such as folding identity casts and verification. We hook into this interface by
 providing a definition for the `areCastCompatible` method:
 
Operation *materializeCallConversion(OpBuilder &builder, Value input,
     return builder.create<CastOp>(conversionLoc, resultType, input);
   }
 };
 ```
 
 If we run the working example through the pipeline again, we get the expected:
 
 ```mlir
-func @main() {
-  %0 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64>
-  %1 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64>
-  %2 = "toy.cast"(%1) : (tensor<2x3xf64>) -> tensor<*xf64>
-  %3 = "toy.cast"(%0) : (tensor<2x3xf64>) -> tensor<*xf64>
-  %4 = "toy.transpose"(%2) : (tensor<*xf64>) -> tensor<*xf64>
-  %5 = "toy.transpose"(%3) : (tensor<*xf64>) -> tensor<*xf64>
-  %6 = "toy.mul"(%4, %5) : (tensor<*xf64>, tensor<*xf64>) -> tensor<*xf64>
+toy.func @main() {
+  %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
+  %1 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
+  %2 = toy.cast %1 : tensor<2x3xf64> to tensor<*xf64>
+  %3 = toy.cast %0 : tensor<2x3xf64> to tensor<*xf64>
+  %4 = toy.transpose(%2 : tensor<*xf64>) to tensor<*xf64>
+  %5 = toy.transpose(%3 : tensor<*xf64>) to tensor<*xf64>
+  %6 = toy.mul %4, %5 : tensor<*xf64>
   toy.print %6 : tensor<*xf64>
   toy.return
 }
 ```
 
 NOTE: The generic inliner will also perform simplifications, so the output may
 be a bit cleaner than expected.
 

 ```c++
 /// Infer the output shape of the MulOp, this is required by the shape inference
 /// interface.
 void MulOp::inferShapes() { getResult().setType(getOperand(0).getType()); }
 ```
 
 At this point, each of the necessary Toy operations provide a mechanism by which
 to infer their output shapes. The ShapeInferencePass will operate on functions:
-it will run on each Function in isolation. MLIR also supports general
+it will run on each function in isolation. MLIR also supports general
 [OperationPasses](../../PassManagement.md#operation-pass) that run on any
-isolated operation (i.e. other function-like operations), but here our module
-only contains functions, so there is no need to generalize to all operations.
+isolated operation, but here our module only contains functions, so there is no
+need to generalize to all operations.
 
 Implementing such a pass is done by creating a class inheriting from
 `mlir::OperationPass<FuncOp>` and overriding the `runOnOperation()` method.
 
 ```c++
 class ShapeInferencePass
     : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
   void runOnOperation() override {

 
 ```c++
   pm.addPass(mlir::createShapeInferencePass());
 ```
 
 If we rerun our original example, we now get the following:
 
 ```mlir
-func @main() {
-  %0 = "toy.constant"() {value = dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>} : () -> tensor<2x3xf64>
-  %1 = "toy.transpose"(%0) : (tensor<2x3xf64>) -> tensor<3x2xf64>
-  %2 = "toy.mul"(%1, %1) : (tensor<3x2xf64>, tensor<3x2xf64>) -> tensor<3x2xf64>
+toy.func @main() {
+  %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
+  %1 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
+  %2 = toy.mul %1, %1 : tensor<3x2xf64>
   toy.print %2 : tensor<3x2xf64>
   toy.return
 }
 ```
 
 You can build `toyc-ch4` and try yourself: `toyc-ch4
 test/Examples/Toy/Ch4/codegen.toy -emit=mlir -opt`.
 
 In the [next chapter](Ch-5.md), we will start the process of code generation by
 targeting a lower level dialect for optimizing some of the more compute-heavy
 Toy operations.

mlir/docs/Tutorials/Toy/Ch-5.md

 
 ```c++
 void ToyToAffineLoweringPass::runOnOperation() {
   ...
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our *illegal*
   // operations were not converted successfully.
-  mlir::FuncOp function = getOperation();
-  if (mlir::failed(mlir::applyPartialConversion(function, target, patterns)))
+  if (mlir::failed(mlir::applyPartialConversion(getOperation(), target, patterns)))
     signalPassFailure();
 }
 ```
 
 ### Design Considerations With Partial Lowering
 
 Before diving into the result of our lowering, this is a good time to discuss
 potential design considerations when it comes to partial lowering. In our

 }
 ```
 
 ## Complete Toy Example
 
 Let's take a concrete example:
 
 ```mlir
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
   %3 = toy.mul %2, %2 : tensor<3x2xf64>
   toy.print %3 : tensor<3x2xf64>
   toy.return
 }
 ```
 

mlir/docs/Tutorials/Toy/Ch-6.md

```c++
   mlir::ModuleOp module = getOperation();
   if (mlir::failed(mlir::applyFullConversion(module, target, patterns)))
     signalPassFailure();
 ```
 
 Looking back at our current working example:
 
 ```mlir
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
   %3 = toy.mul %2, %2 : tensor<3x2xf64>
   toy.print %3 : tensor<3x2xf64>
   toy.return
 }
 ```
 

mlir/docs/Tutorials/Toy/Ch-7.md

 def multiply_transpose(Struct value) {
 }
 ```
 
 Which generates the following:
 
 ```mlir
 module {
-  func @multiply_transpose(%arg0: !toy.struct<tensor<*xf64>, tensor<*xf64>>) {
+  toy.func @multiply_transpose(%arg0: !toy.struct<tensor<*xf64>, tensor<*xf64>>) {
     toy.return
   }
 }
 ```
 
 ### Operating on `StructType`
 
 Now that the `struct` type has been defined, and we can round-trip it through
def main() {
   print(c);
 }
 ```
 
 and finally get a full MLIR module:
 
 ```mlir
 module {
-  func @multiply_transpose(%arg0: !toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64> {
+  toy.func @multiply_transpose(%arg0: !toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64> {
     %0 = toy.struct_access %arg0[0] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
     %1 = toy.transpose(%0 : tensor<*xf64>) to tensor<*xf64>
     %2 = toy.struct_access %arg0[1] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
     %3 = toy.transpose(%2 : tensor<*xf64>) to tensor<*xf64>
     %4 = toy.mul %1, %3 : tensor<*xf64>
     toy.return %4 : tensor<*xf64>
   }
-  func @main() {
+  toy.func @main() {
     %0 = toy.struct_constant [
       dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>,
       dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
     ] : !toy.struct<tensor<*xf64>, tensor<*xf64>>
     %1 = toy.generic_call @multiply_transpose(%0) : (!toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64>
     toy.print %1 : tensor<*xf64>
     toy.return
   }
 }
 ```
 
 #### Optimizing Operations on `StructType`
 
 Now that we have a few operations operating on `StructType`, we also have many
 new constant folding opportunities.
 
 After inlining, the MLIR module in the previous section looks something like:
 
 ```mlir
 module {
-  func @main() {
+  toy.func @main() {
     %0 = toy.struct_constant [
       dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>,
       dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
     ] : !toy.struct<tensor<*xf64>, tensor<*xf64>>
     %1 = toy.struct_access %0[0] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
     %2 = toy.transpose(%1 : tensor<*xf64>) to tensor<*xf64>
     %3 = toy.struct_access %0[1] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
     %4 = toy.transpose(%3 : tensor<*xf64>) to tensor<*xf64>

 }
 ```
 
 With this, we can now generate code that can be generated to LLVM without any
 changes to our pipeline.
 
 ```mlir
 module {
-  func @main() {
+  toy.func @main() {
     %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
     %1 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
     %2 = toy.mul %1, %1 : tensor<3x2xf64>
     toy.print %2 : tensor<3x2xf64>
     toy.return
   }
 }
 ```
 
 You can build `toyc-ch7` and try yourself: `toyc-ch7
 test/Examples/Toy/Ch7/struct-codegen.toy -emit=mlir`. More details on defining
 custom types can be found in
 [DefiningAttributesAndTypes](../DefiningAttributesAndTypes.md).

mlir/examples/toy/Ch2/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/FunctionInterfaces.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

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

 //===- Ops.td - Toy dialect operation definitions ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
 include "mlir/IR/OpBase.td"
+include "mlir/IR/FunctionInterfaces.td"
+include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "::mlir::toy";
 }
def AddOp : Toy_Op<"add"> {
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
     OpBuilder<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+def FuncOp : Toy_Op<"func", [
+    FunctionOpInterface, IsolatedFromAbove, Symbol
+  ]> {
+  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
+    toy.func @main() {
+      %0 = toy.constant dense<5.500000e+00> : tensor<f64>
+      %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
+      toy.print %1 : tensor<2x2xf64>
+      toy.return
+    }
+    ```
+  }];
+
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<FunctionType>:$type
+  );
+  let regions = (region AnyRegion:$body);
+
+  let builders = [OpBuilder<(ins
+    "StringRef":$name, "FunctionType":$type,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
+  >];
+  let extraClassDeclaration = [{
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    //===------------------------------------------------------------------===//
+    // FunctionOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+
+    /// Verify the type attribute of this function. Returns failure and emits
+    /// an error if the attribute is invalid.
+    LogicalResult verifyType() {
+      auto type = getTypeAttr().getValue();
+      if (!type.isa<FunctionType>())
+        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
+                           "' attribute of function type");
+      return success();
+    }
+  }];
+  let hasCustomAssemblyFormat = 1;
+  let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 def GenericCallOp : Toy_Op<"generic_call"> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to
     be specialized for the shape of its arguments. The callee name is attached

mlir/examples/toy/Ch2/mlir/Dialect.cpp

 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
 #include "toy/Dialect.cpp.inc"
 
 //===----------------------------------------------------------------------===//
void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
   // Generic call always returns an unranked Tensor initially.
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
   state.addOperands(arguments);
   state.addAttribute("callee",
                      mlir::SymbolRefAttr::get(builder.getContext(), callee));
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+void FuncOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
+                   llvm::StringRef name, mlir::FunctionType type,
+                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  // FunctionOpInterface provides a convenient `build` method that will populate
+  // the state of our FuncOp, and create an entry block.
+  buildWithEntryBlock(builder, state, name, type, attrs, type.getInputs());
+}
+
+mlir::ParseResult FuncOp::parse(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result) {
+  // Dispatch to the FunctionOpInterface provided utility method that parses the
+  // function operation.
+  auto buildFuncType =
+      [](mlir::Builder &builder, llvm::ArrayRef<mlir::Type> argTypes,
+         llvm::ArrayRef<mlir::Type> results,
+         mlir::function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
+
+  return mlir::function_interface_impl::parseFunctionOp(
+      parser, result, /*allowVariadic=*/false, buildFuncType);
+}
+
+void FuncOp::print(mlir::OpAsmPrinter &p) {
+  // Dispatch to the FunctionOpInterface provided utility method that prints the
+  // function operation.
+  mlir::function_interface_impl::printFunctionOp(p, *this,
+                                                 /*isVariadic=*/false);
+}
+
+mlir::LogicalResult FuncOp::verify() {
+  // Verify that the argument list of the function and the arg list of the entry
+  // block line up. The trait already verified that the number of arguments is
+  // the same between the signature and the block.
+  llvm::ArrayRef<mlir::Type> fnInputTypes = getType().getInputs();
+  mlir::Block &entryBlock = front();
+  for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i) {
+    if (fnInputTypes[i] != entryBlock.getArgument(i).getType()) {
+      return emitOpError("type of entry block argument #")
+             << i << '(' << entryBlock.getArgument(i).getType()
+             << ") must match the type of the corresponding argument in "
+             << "function signature(" << fnInputTypes[i] << ')';
+    }
+  }
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
 void MulOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                   mlir::Value lhs, mlir::Value rhs) {
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
   state.addOperands({lhs, rhs});
 }

mlir/examples/toy/Ch2/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &f : moduleAST) {
-      auto func = mlirGen(f);
-      if (!func)
-        return nullptr;
-      theModule.push_back(func);
-    }
+    for (FunctionAST &f : moduleAST)
+      mlirGen(f);
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
     if (failed(mlir::verify(theModule))) {
       theModule.emitError("module verification error");
       return nullptr;
     }
mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();
     symbolTable.insert(var, value);
     return mlir::success();
   }
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
-  mlir::FuncOp mlirGen(PrototypeAST &proto) {
+  mlir::toy::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
     llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
                                               getType(VarType{}));
     auto funcType = builder.getFunctionType(argTypes, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), funcType);
+    return builder.create<mlir::toy::FuncOp>(location, proto.getName(),
+                                             funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
-  mlir::FuncOp mlirGen(FunctionAST &funcAST) {
+  mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
     ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
-    mlir::FuncOp function(mlirGen(*funcAST.getProto()));
+    builder.setInsertionPointToEnd(theModule.getBody());
+    mlir::toy::FuncOp function = mlirGen(*funcAST.getProto());
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
-    // In MLIR the entry block of the function is special: it must have the same
-    // argument list as the function itself.
-    auto &entryBlock = *function.addEntryBlock();
+    mlir::Block &entryBlock = function.front();
     auto protoArgs = funcAST.getProto()->getArgs();
 
     // Declare all the function arguments in the symbol table.
     for (const auto nameValue :
          llvm::zip(protoArgs, entryBlock.getArguments())) {
       if (failed(declare(std::get<0>(nameValue)->getName(),
                          std::get<1>(nameValue))))
         return nullptr;

mlir/examples/toy/Ch3/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/FunctionInterfaces.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

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

 //===- Ops.td - Toy dialect operation definitions ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
+include "mlir/IR/FunctionInterfaces.td"
+include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
   let cppNamespace = "::mlir::toy";
 }
def AddOp : Toy_Op<"add", [NoSideEffect]> {
 
   // Allow building an AddOp with from the two input operands.
   let builders = [
     OpBuilder<(ins "Value":$lhs, "Value":$rhs)>
   ];
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+def FuncOp : Toy_Op<"func", [
+    FunctionOpInterface, IsolatedFromAbove, Symbol
+  ]> {
+  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
+    toy.func @main() {
+      %0 = toy.constant dense<5.500000e+00> : tensor<f64>
+      %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
+      toy.print %1 : tensor<2x2xf64>
+      toy.return
+    }
+    ```
+  }];
+
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<FunctionType>:$type
+  );
+  let regions = (region AnyRegion:$body);
+
+  let builders = [OpBuilder<(ins
+    "StringRef":$name, "FunctionType":$type,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
+  >];
+  let extraClassDeclaration = [{
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    //===------------------------------------------------------------------===//
+    // FunctionOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+
+    /// Verify the type attribute of this function. Returns failure and emits
+    /// an error if the attribute is invalid.
+    LogicalResult verifyType() {
+      auto type = getTypeAttr().getValue();
+      if (!type.isa<FunctionType>())
+        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
+                           "' attribute of function type");
+      return success();
+    }
+  }];
+  let hasCustomAssemblyFormat = 1;
+  let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 def GenericCallOp : Toy_Op<"generic_call"> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to
     be specialized for the shape of its arguments. The callee name is attached

mlir/examples/toy/Ch3/mlir/Dialect.cpp

 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
 #include "toy/Dialect.cpp.inc"
 
 //===----------------------------------------------------------------------===//

 mlir::ParseResult AddOp::parse(mlir::OpAsmParser &parser,
                                mlir::OperationState &result) {
   return parseBinaryOp(parser, result);
 }
 
 void AddOp::print(mlir::OpAsmPrinter &p) { printBinaryOp(p, *this); }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+void FuncOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
+                   llvm::StringRef name, mlir::FunctionType type,
+                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  // FunctionOpInterface provides a convenient `build` method that will populate
+  // the state of our FuncOp, and create an entry block.
+  buildWithEntryBlock(builder, state, name, type, attrs, type.getInputs());
+}
+
+mlir::ParseResult FuncOp::parse(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result) {
+  // Dispatch to the FunctionOpInterface provided utility method that parses the
+  // function operation.
+  auto buildFuncType =
+      [](mlir::Builder &builder, llvm::ArrayRef<mlir::Type> argTypes,
+         llvm::ArrayRef<mlir::Type> results,
+         mlir::function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
+
+  return mlir::function_interface_impl::parseFunctionOp(
+      parser, result, /*allowVariadic=*/false, buildFuncType);
+}
+
+void FuncOp::print(mlir::OpAsmPrinter &p) {
+  // Dispatch to the FunctionOpInterface provided utility method that prints the
+  // function operation.
+  mlir::function_interface_impl::printFunctionOp(p, *this,
+                                                 /*isVariadic=*/false);
+}
+
+mlir::LogicalResult FuncOp::verify() {
+  // Verify that the argument list of the function and the arg list of the entry
+  // block line up. The trait already verified that the number of arguments is
+  // the same between the signature and the block.
+  llvm::ArrayRef<mlir::Type> fnInputTypes = getType().getInputs();
+  mlir::Block &entryBlock = front();
+  for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i) {
+    if (fnInputTypes[i] != entryBlock.getArgument(i).getType()) {
+      return emitOpError("type of entry block argument #")
+             << i << '(' << entryBlock.getArgument(i).getType()
+             << ") must match the type of the corresponding argument in "
+             << "function signature(" << fnInputTypes[i] << ')';
+    }
+  }
+
+  return success();
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                           StringRef callee, ArrayRef<mlir::Value> arguments) {
   // Generic call always returns an unranked Tensor initially.
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
   state.addOperands(arguments);

mlir/examples/toy/Ch3/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &f : moduleAST) {
-      auto func = mlirGen(f);
-      if (!func)
-        return nullptr;
-      theModule.push_back(func);
-    }
+    for (FunctionAST &f : moduleAST)
+      mlirGen(f);
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
     if (failed(mlir::verify(theModule))) {
       theModule.emitError("module verification error");
       return nullptr;
     }
mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();
     symbolTable.insert(var, value);
     return mlir::success();
   }
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
-  mlir::FuncOp mlirGen(PrototypeAST &proto) {
+  mlir::toy::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
     llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
                                               getType(VarType{}));
     auto funcType = builder.getFunctionType(argTypes, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), funcType);
+    return builder.create<mlir::toy::FuncOp>(location, proto.getName(),
+                                             funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
-  mlir::FuncOp mlirGen(FunctionAST &funcAST) {
+  mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
     ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
-    mlir::FuncOp function(mlirGen(*funcAST.getProto()));
+    builder.setInsertionPointToEnd(theModule.getBody());
+    mlir::toy::FuncOp function = mlirGen(*funcAST.getProto());
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
-    // In MLIR the entry block of the function is special: it must have the same
-    // argument list as the function itself.
-    auto &entryBlock = *function.addEntryBlock();
+    mlir::Block &entryBlock = function.front();
     auto protoArgs = funcAST.getProto()->getArgs();
 
     // Declare all the function arguments in the symbol table.
     for (const auto nameValue :
          llvm::zip(protoArgs, entryBlock.getArguments())) {
       if (failed(declare(std::get<0>(nameValue)->getName(),
                          std::get<1>(nameValue))))
         return nullptr;

mlir/examples/toy/Ch3/toyc.cpp

if (int error = loadMLIR(sourceMgr, context, module))
     return error;
 
   if (enableOpt) {
     mlir::PassManager pm(&context);
     // Apply any generic pass manager command line options and run the pipeline.
     applyPassManagerCLOptions(pm);
 
     // Add a run of the canonicalizer to optimize the mlir module.
-    pm.addNestedPass<mlir::FuncOp>(mlir::createCanonicalizerPass());
+    pm.addNestedPass<mlir::toy::FuncOp>(mlir::createCanonicalizerPass());
     if (mlir::failed(pm.run(*module)))
       return 4;
   }
 
   module->dump();
   return 0;
 }
 

mlir/examples/toy/Ch4/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/FunctionInterfaces.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

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

 //===- Ops.td - Toy dialect operation definitions ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
+include "mlir/IR/FunctionInterfaces.td"
+include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
def CastOp : Toy_Op<"cast", [
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor:$output);
 
   let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+def FuncOp : Toy_Op<"func", [
+    DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
+    IsolatedFromAbove, Symbol
+  ]> {
+  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
+    toy.func @main() {
+      %0 = toy.constant dense<5.500000e+00> : tensor<f64>
+      %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
+      toy.print %1 : tensor<2x2xf64>
+      toy.return
+    }
+    ```
+  }];
+
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<FunctionType>:$type
+  );
+  let regions = (region AnyRegion:$body);
+
+  let builders = [OpBuilder<(ins
+    "StringRef":$name, "FunctionType":$type,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
+  >];
+  let extraClassDeclaration = [{
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    //===------------------------------------------------------------------===//
+    // FunctionOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+
+    /// Verify the type attribute of this function. Returns failure and emits
+    /// an error if the attribute is invalid.
+    LogicalResult verifyType() {
+      auto type = getTypeAttr().getValue();
+      if (!type.isa<FunctionType>())
+        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
+                           "' attribute of function type");
+      return success();
+    }
+  }];
+  let hasCustomAssemblyFormat = 1;
+  let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 def GenericCallOp : Toy_Op<"generic_call",
     [DeclareOpInterfaceMethods<CallOpInterface>]> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to

mlir/examples/toy/Ch4/mlir/Dialect.cpp

 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
 #include "toy/Dialect.cpp.inc"
 
struct ToyInlinerInterface : public DialectInlinerInterface {
   }
 
   /// All operations within toy can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 
+  // All functions within toy can be inlined.
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
+    return true;
+  }
+
   //===--------------------------------------------------------------------===//
   // Transformation Hooks
   //===--------------------------------------------------------------------===//
 
   /// Handle the given inlined terminator(toy.return) by replacing it with a new
   /// operation as necessary.
   void handleTerminator(Operation *op,
                         ArrayRef<Value> valuesToRepl) const final {
bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   TensorType output = outputs.front().dyn_cast<TensorType>();
   if (!input || !output || input.getElementType() != output.getElementType())
     return false;
   // The shape is required to match if both types are ranked.
   return !input.hasRank() || !output.hasRank() || input == output;
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+void FuncOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
+                   llvm::StringRef name, mlir::FunctionType type,
+                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  // FunctionOpInterface provides a convenient `build` method that will populate
+  // the state of our FuncOp, and create an entry block.
+  buildWithEntryBlock(builder, state, name, type, attrs, type.getInputs());
+}
+
+mlir::ParseResult FuncOp::parse(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result) {
+  // Dispatch to the FunctionOpInterface provided utility method that parses the
+  // function operation.
+  auto buildFuncType =
+      [](mlir::Builder &builder, llvm::ArrayRef<mlir::Type> argTypes,
+         llvm::ArrayRef<mlir::Type> results,
+         mlir::function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
+
+  return mlir::function_interface_impl::parseFunctionOp(
+      parser, result, /*allowVariadic=*/false, buildFuncType);
+}
+
+void FuncOp::print(mlir::OpAsmPrinter &p) {
+  // Dispatch to the FunctionOpInterface provided utility method that prints the
+  // function operation.
+  mlir::function_interface_impl::printFunctionOp(p, *this,
+                                                 /*isVariadic=*/false);
+}
+
+mlir::LogicalResult FuncOp::verify() {
+  // Verify that the argument list of the function and the arg list of the entry
+  // block line up. The trait already verified that the number of arguments is
+  // the same between the signature and the block.
+  llvm::ArrayRef<mlir::Type> fnInputTypes = getType().getInputs();
+  mlir::Block &entryBlock = front();
+  for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i) {
+    if (fnInputTypes[i] != entryBlock.getArgument(i).getType()) {
+      return emitOpError("type of entry block argument #")
+             << i << '(' << entryBlock.getArgument(i).getType()
+             << ") must match the type of the corresponding argument in "
+             << "function signature(" << fnInputTypes[i] << ')';
+    }
+  }
+
+  return success();
+}
+
+/// Returns the region on the function operation that is callable.
+mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
+
+/// Returns the results types that the callable region produces when
+/// executed.
+llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
+  return getType().getResults();
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                           StringRef callee, ArrayRef<mlir::Value> arguments) {
   // Generic call always returns an unranked Tensor initially.
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
   state.addOperands(arguments);

mlir/examples/toy/Ch4/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &f : moduleAST) {
-      auto func = mlirGen(f);
-      if (!func)
-        return nullptr;
-      theModule.push_back(func);
-    }
+    for (FunctionAST &f : moduleAST)
+      mlirGen(f);
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
     if (failed(mlir::verify(theModule))) {
       theModule.emitError("module verification error");
       return nullptr;
     }
mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();
     symbolTable.insert(var, value);
     return mlir::success();
   }
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
-  mlir::FuncOp mlirGen(PrototypeAST &proto) {
+  mlir::toy::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
     llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
                                               getType(VarType{}));
     auto funcType = builder.getFunctionType(argTypes, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), funcType);
+    return builder.create<mlir::toy::FuncOp>(location, proto.getName(),
+                                             funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
-  mlir::FuncOp mlirGen(FunctionAST &funcAST) {
+  mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
     ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
-    mlir::FuncOp function(mlirGen(*funcAST.getProto()));
+    builder.setInsertionPointToEnd(theModule.getBody());
+    mlir::toy::FuncOp function = mlirGen(*funcAST.getProto());
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
-    // In MLIR the entry block of the function is special: it must have the same
-    // argument list as the function itself.
-    auto &entryBlock = *function.addEntryBlock();
+    mlir::Block &entryBlock = function.front();
     auto protoArgs = funcAST.getProto()->getArgs();
 
     // Declare all the function arguments in the symbol table.
     for (const auto nameValue :
          llvm::zip(protoArgs, entryBlock.getArguments())) {
       if (failed(declare(std::get<0>(nameValue)->getName(),
                          std::get<1>(nameValue))))
         return nullptr;

mlir/examples/toy/Ch4/mlir/ShapeInferencePass.cpp

 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
 public:
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {

mlir/examples/toy/Ch4/toyc.cpp

if (enableOpt) {
     // Apply any generic pass manager command line options and run the pipeline.
     applyPassManagerCLOptions(pm);
 
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
-    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
+    mlir::OpPassManager &optPM = pm.nest<mlir::toy::FuncOp>();
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 
     if (mlir::failed(pm.run(*module)))
       return 4;
   }
 

mlir/examples/toy/Ch5/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/FunctionInterfaces.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

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

 //===- Ops.td - Toy dialect operation definitions ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
+include "mlir/IR/FunctionInterfaces.td"
+include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
def CastOp : Toy_Op<"cast", [
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor:$output);
 
   let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+def FuncOp : Toy_Op<"func", [
+    DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
+    IsolatedFromAbove, Symbol
+  ]> {
+  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
+    toy.func @main() {
+      %0 = toy.constant dense<5.500000e+00> : tensor<f64>
+      %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
+      toy.print %1 : tensor<2x2xf64>
+      toy.return
+    }
+    ```
+  }];
+
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<FunctionType>:$type
+  );
+  let regions = (region AnyRegion:$body);
+
+  let builders = [OpBuilder<(ins
+    "StringRef":$name, "FunctionType":$type,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
+  >];
+  let extraClassDeclaration = [{
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    //===------------------------------------------------------------------===//
+    // FunctionOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+
+    /// Verify the type attribute of this function. Returns failure and emits
+    /// an error if the attribute is invalid.
+    LogicalResult verifyType() {
+      auto type = getTypeAttr().getValue();
+      if (!type.isa<FunctionType>())
+        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
+                           "' attribute of function type");
+      return success();
+    }
+  }];
+  let hasCustomAssemblyFormat = 1;
+  let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 def GenericCallOp : Toy_Op<"generic_call",
     [DeclareOpInterfaceMethods<CallOpInterface>]> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to

mlir/examples/toy/Ch5/mlir/Dialect.cpp

 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
 #include "toy/Dialect.cpp.inc"
 
struct ToyInlinerInterface : public DialectInlinerInterface {
   }
 
   /// All operations within toy can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 
+  // All functions within toy can be inlined.
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
+    return true;
+  }
+
   //===--------------------------------------------------------------------===//
   // Transformation Hooks
   //===--------------------------------------------------------------------===//
 
   /// Handle the given inlined terminator(toy.return) by replacing it with a new
   /// operation as necessary.
   void handleTerminator(Operation *op,
                         ArrayRef<Value> valuesToRepl) const final {
bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   TensorType output = outputs.front().dyn_cast<TensorType>();
   if (!input || !output || input.getElementType() != output.getElementType())
     return false;
   // The shape is required to match if both types are ranked.
   return !input.hasRank() || !output.hasRank() || input == output;
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+void FuncOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
+                   llvm::StringRef name, mlir::FunctionType type,
+                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  // FunctionOpInterface provides a convenient `build` method that will populate
+  // the state of our FuncOp, and create an entry block.
+  buildWithEntryBlock(builder, state, name, type, attrs, type.getInputs());
+}
+
+mlir::ParseResult FuncOp::parse(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result) {
+  // Dispatch to the FunctionOpInterface provided utility method that parses the
+  // function operation.
+  auto buildFuncType =
+      [](mlir::Builder &builder, llvm::ArrayRef<mlir::Type> argTypes,
+         llvm::ArrayRef<mlir::Type> results,
+         mlir::function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
+
+  return mlir::function_interface_impl::parseFunctionOp(
+      parser, result, /*allowVariadic=*/false, buildFuncType);
+}
+
+void FuncOp::print(mlir::OpAsmPrinter &p) {
+  // Dispatch to the FunctionOpInterface provided utility method that prints the
+  // function operation.
+  mlir::function_interface_impl::printFunctionOp(p, *this,
+                                                 /*isVariadic=*/false);
+}
+
+mlir::LogicalResult FuncOp::verify() {
+  // Verify that the argument list of the function and the arg list of the entry
+  // block line up. The trait already verified that the number of arguments is
+  // the same between the signature and the block.
+  llvm::ArrayRef<mlir::Type> fnInputTypes = getType().getInputs();
+  mlir::Block &entryBlock = front();
+  for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i) {
+    if (fnInputTypes[i] != entryBlock.getArgument(i).getType()) {
+      return emitOpError("type of entry block argument #")
+             << i << '(' << entryBlock.getArgument(i).getType()
+             << ") must match the type of the corresponding argument in "
+             << "function signature(" << fnInputTypes[i] << ')';
+    }
+  }
+
+  return success();
+}
+
+/// Returns the region on the function operation that is callable.
+mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
+
+/// Returns the results types that the callable region produces when
+/// executed.
+llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
+  return getType().getResults();
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                           StringRef callee, ArrayRef<mlir::Value> arguments) {
   // Generic call always returns an unranked Tensor initially.
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
   state.addOperands(arguments);

mlir/examples/toy/Ch5/mlir/LowerToAffineLoops.cpp

 //====- LowerToAffineLoops.cpp - Partial lowering from Toy to Affine+Std --===//
 //
 // 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 implements a partial lowering of Toy operations to a combination of
 // affine loops, memref operations and standard operations. This lowering
 // expects that all calls have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/IR/BuiltinDialect.h"
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Pass/Pass.h"
LogicalResult matchAndRewrite(toy::ConstantOp op,
 
     // Replace this operation with the generated alloc.
     rewriter.replaceOp(op, alloc);
     return success();
   }
 };
 
 //===----------------------------------------------------------------------===//
+// ToyToAffine RewritePatterns: Func operations
+//===----------------------------------------------------------------------===//
+
+struct FuncOpLowering : public OpConversionPattern<toy::FuncOp> {
+  using OpConversionPattern<toy::FuncOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const final {
+    // We only lower the main function as we expect that all other functions
+    // have been inlined.
+    if (op.getName() != "main")
+      return failure();
+
+    // Verify that the given main has no inputs and results.
+    if (op.getNumArguments() || op.getType().getNumResults()) {
+      return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) {
+        diag << "expected 'main' to have 0 inputs and 0 results";
+      });
+    }
+
+    // Create a new non-toy function, with the same region.
+    auto func =
+        rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(), op.getType());
+    rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end());
+    rewriter.eraseOp(op);
+    return success();
+  }
+};
+
+//===----------------------------------------------------------------------===//
 // ToyToAffine RewritePatterns: Print operations
 //===----------------------------------------------------------------------===//
 
 struct PrintOpLowering : public OpConversionPattern<toy::PrintOp> {
   using OpConversionPattern<toy::PrintOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(toy::PrintOp op, OpAdaptor adaptor,

 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
-    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<FuncOp>> {
+    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {
-  FuncOp function = getOperation();
-
-  // We only lower the main function as we expect that all other functions have
-  // been inlined.
-  if (function.getName() != "main")
-    return;
-
-  // Verify that the given main has no inputs and results.
-  if (function.getNumArguments() || function.getType().getNumResults()) {
-    function.emitError("expected 'main' to have 0 inputs and 0 results");
-    return signalPassFailure();
-  }
-
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects.
-  target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
-                         func::FuncDialect, memref::MemRefDialect>();
+  target
+      .addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
   // to be updated though (as we convert from TensorType to MemRefType), so we
   // only treat it as `legal` if its operands are legal.
   target.addIllegalDialect<toy::ToyDialect>();
   target.addDynamicallyLegalOp<toy::PrintOp>([](toy::PrintOp op) {
     return llvm::none_of(op->getOperandTypes(),
                          [](Type type) { return type.isa<TensorType>(); });
   });
 
   // Now that the conversion target has been defined, we just need to provide
   // the set of patterns that will lower the Toy operations.
   RewritePatternSet patterns(&getContext());
-  patterns.add<AddOpLowering, ConstantOpLowering, MulOpLowering,
+  patterns.add<AddOpLowering, ConstantOpLowering, FuncOpLowering, MulOpLowering,
                PrintOpLowering, ReturnOpLowering, TransposeOpLowering>(
       &getContext());
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our `illegal`
   // operations were not converted successfully.
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
 /// Create a pass for lowering operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<Pass> mlir::toy::createLowerToAffinePass() {
   return std::make_unique<ToyToAffineLoweringPass>();
 }

mlir/examples/toy/Ch5/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &f : moduleAST) {
-      auto func = mlirGen(f);
-      if (!func)
-        return nullptr;
-      theModule.push_back(func);
-    }
+    for (FunctionAST &f : moduleAST)
+      mlirGen(f);
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
     if (failed(mlir::verify(theModule))) {
       theModule.emitError("module verification error");
       return nullptr;
     }
mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();
     symbolTable.insert(var, value);
     return mlir::success();
   }
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
-  mlir::FuncOp mlirGen(PrototypeAST &proto) {
+  mlir::toy::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
     llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
                                               getType(VarType{}));
     auto funcType = builder.getFunctionType(argTypes, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), funcType);
+    return builder.create<mlir::toy::FuncOp>(location, proto.getName(),
+                                             funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
-  mlir::FuncOp mlirGen(FunctionAST &funcAST) {
+  mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
     ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
-    mlir::FuncOp function(mlirGen(*funcAST.getProto()));
+    builder.setInsertionPointToEnd(theModule.getBody());
+    mlir::toy::FuncOp function = mlirGen(*funcAST.getProto());
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
-    // In MLIR the entry block of the function is special: it must have the same
-    // argument list as the function itself.
-    auto &entryBlock = *function.addEntryBlock();
+    mlir::Block &entryBlock = function.front();
     auto protoArgs = funcAST.getProto()->getArgs();
 
     // Declare all the function arguments in the symbol table.
     for (const auto nameValue :
          llvm::zip(protoArgs, entryBlock.getArguments())) {
       if (failed(declare(std::get<0>(nameValue)->getName(),
                          std::get<1>(nameValue))))
         return nullptr;

mlir/examples/toy/Ch5/mlir/ShapeInferencePass.cpp

 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
 public:
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {

mlir/examples/toy/Ch5/toyc.cpp

int dumpMLIR() {
   bool isLoweringToAffine = emitAction >= Action::DumpMLIRAffine;
 
   if (enableOpt || isLoweringToAffine) {
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
-    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
+    mlir::OpPassManager &optPM = pm.nest<mlir::toy::FuncOp>();
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
   }
 
   if (isLoweringToAffine) {
-    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
+    // Partially lower the toy dialect.
+    pm.addPass(mlir::toy::createLowerToAffinePass());
 
-    // Partially lower the toy dialect with a few cleanups afterwards.
-    optPM.addPass(mlir::toy::createLowerToAffinePass());
+    // Add a few cleanups post lowering.
+    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 
     // Add optimizations if enabled.
     if (enableOpt) {
       optPM.addPass(mlir::createLoopFusionPass());
       optPM.addPass(mlir::createAffineScalarReplacementPass());
     }

mlir/examples/toy/Ch6/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/FunctionInterfaces.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
 /// Include the auto-generated header file containing the declaration of the toy
 /// dialect.
 #include "toy/Dialect.h.inc"
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

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

 //===- Ops.td - Toy dialect operation definitions ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
+include "mlir/IR/FunctionInterfaces.td"
+include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
def CastOp : Toy_Op<"cast", [
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor:$output);
 
   let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+def FuncOp : Toy_Op<"func", [
+    DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
+    IsolatedFromAbove, Symbol
+  ]> {
+  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
+    toy.func @main() {
+      %0 = toy.constant dense<5.500000e+00> : tensor<f64>
+      %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
+      toy.print %1 : tensor<2x2xf64>
+      toy.return
+    }
+    ```
+  }];
+
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<FunctionType>:$type
+  );
+  let regions = (region AnyRegion:$body);
+
+  let builders = [OpBuilder<(ins
+    "StringRef":$name, "FunctionType":$type,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
+  >];
+  let extraClassDeclaration = [{
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    //===------------------------------------------------------------------===//
+    // FunctionOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+
+    /// Verify the type attribute of this function. Returns failure and emits
+    /// an error if the attribute is invalid.
+    LogicalResult verifyType() {
+      auto type = getTypeAttr().getValue();
+      if (!type.isa<FunctionType>())
+        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
+                           "' attribute of function type");
+      return success();
+    }
+  }];
+  let hasCustomAssemblyFormat = 1;
+  let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 def GenericCallOp : Toy_Op<"generic_call",
     [DeclareOpInterfaceMethods<CallOpInterface>]> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to

mlir/examples/toy/Ch6/mlir/Dialect.cpp

 // operation verification.
 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
+#include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
 #include "toy/Dialect.cpp.inc"
 
struct ToyInlinerInterface : public DialectInlinerInterface {
   }
 
   /// All operations within toy can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 
+  // All functions within toy can be inlined.
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
+    return true;
+  }
+
   //===--------------------------------------------------------------------===//
   // Transformation Hooks
   //===--------------------------------------------------------------------===//
 
   /// Handle the given inlined terminator(toy.return) by replacing it with a new
   /// operation as necessary.
   void handleTerminator(Operation *op,
                         ArrayRef<Value> valuesToRepl) const final {
bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   TensorType output = outputs.front().dyn_cast<TensorType>();
   if (!input || !output || input.getElementType() != output.getElementType())
     return false;
   // The shape is required to match if both types are ranked.
   return !input.hasRank() || !output.hasRank() || input == output;
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+void FuncOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
+                   llvm::StringRef name, mlir::FunctionType type,
+                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  // FunctionOpInterface provides a convenient `build` method that will populate
+  // the state of our FuncOp, and create an entry block.
+  buildWithEntryBlock(builder, state, name, type, attrs, type.getInputs());
+}
+
+mlir::ParseResult FuncOp::parse(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result) {
+  // Dispatch to the FunctionOpInterface provided utility method that parses the
+  // function operation.
+  auto buildFuncType =
+      [](mlir::Builder &builder, llvm::ArrayRef<mlir::Type> argTypes,
+         llvm::ArrayRef<mlir::Type> results,
+         mlir::function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
+
+  return mlir::function_interface_impl::parseFunctionOp(
+      parser, result, /*allowVariadic=*/false, buildFuncType);
+}
+
+void FuncOp::print(mlir::OpAsmPrinter &p) {
+  // Dispatch to the FunctionOpInterface provided utility method that prints the
+  // function operation.
+  mlir::function_interface_impl::printFunctionOp(p, *this,
+                                                 /*isVariadic=*/false);
+}
+
+mlir::LogicalResult FuncOp::verify() {
+  // Verify that the argument list of the function and the arg list of the entry
+  // block line up. The trait already verified that the number of arguments is
+  // the same between the signature and the block.
+  llvm::ArrayRef<mlir::Type> fnInputTypes = getType().getInputs();
+  mlir::Block &entryBlock = front();
+  for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i) {
+    if (fnInputTypes[i] != entryBlock.getArgument(i).getType()) {
+      return emitOpError("type of entry block argument #")
+             << i << '(' << entryBlock.getArgument(i).getType()
+             << ") must match the type of the corresponding argument in "
+             << "function signature(" << fnInputTypes[i] << ')';
+    }
+  }
+
+  return success();
+}
+
+/// Returns the region on the function operation that is callable.
+mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
+
+/// Returns the results types that the callable region produces when
+/// executed.
+llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
+  return getType().getResults();
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                           StringRef callee, ArrayRef<mlir::Value> arguments) {
   // Generic call always returns an unranked Tensor initially.
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
   state.addOperands(arguments);

mlir/examples/toy/Ch6/mlir/LowerToAffineLoops.cpp

 //====- LowerToAffineLoops.cpp - Partial lowering from Toy to Affine+Std --===//
 //
 // 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 implements a partial lowering of Toy operations to a combination of
 // affine loops, memref operations and standard operations. This lowering
 // expects that all calls have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/IR/BuiltinDialect.h"
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Pass/Pass.h"
LogicalResult matchAndRewrite(toy::ConstantOp op,
 
     // Replace this operation with the generated alloc.
     rewriter.replaceOp(op, alloc);
     return success();
   }
 };
 
 //===----------------------------------------------------------------------===//
+// ToyToAffine RewritePatterns: Func operations
+//===----------------------------------------------------------------------===//
+
+struct FuncOpLowering : public OpConversionPattern<toy::FuncOp> {
+  using OpConversionPattern<toy::FuncOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const final {
+    // We only lower the main function as we expect that all other functions
+    // have been inlined.
+    if (op.getName() != "main")
+      return failure();
+
+    // Verify that the given main has no inputs and results.
+    if (op.getNumArguments() || op.getType().getNumResults()) {
+      return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) {
+        diag << "expected 'main' to have 0 inputs and 0 results";
+      });
+    }
+
+    // Create a new non-toy function, with the same region.
+    auto func =
+        rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(), op.getType());
+    rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end());
+    rewriter.eraseOp(op);
+    return success();
+  }
+};
+
+//===----------------------------------------------------------------------===//
 // ToyToAffine RewritePatterns: Print operations
 //===----------------------------------------------------------------------===//
 
 struct PrintOpLowering : public OpConversionPattern<toy::PrintOp> {
   using OpConversionPattern<toy::PrintOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(toy::PrintOp op, OpAdaptor adaptor,

 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
-    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<FuncOp>> {
+    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {
-  auto function = getOperation();
-
-  // We only lower the main function as we expect that all other functions have
-  // been inlined.
-  if (function.getName() != "main")
-    return;
-
-  // Verify that the given main has no inputs and results.
-  if (function.getNumArguments() || function.getType().getNumResults()) {
-    function.emitError("expected 'main' to have 0 inputs and 0 results");
-    return signalPassFailure();
-  }
-
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects.
-  target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
-                         func::FuncDialect, memref::MemRefDialect>();
+  target
+      .addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
   // to be updated though (as we convert from TensorType to MemRefType), so we
   // only treat it as `legal` if its operands are legal.
   target.addIllegalDialect<toy::ToyDialect>();
   target.addDynamicallyLegalOp<toy::PrintOp>([](toy::PrintOp op) {
     return llvm::none_of(op->getOperandTypes(),
                          [](Type type) { return type.isa<TensorType>(); });
   });
 
   // Now that the conversion target has been defined, we just need to provide
   // the set of patterns that will lower the Toy operations.
   RewritePatternSet patterns(&getContext());
-  patterns.add<AddOpLowering, ConstantOpLowering, MulOpLowering,
+  patterns.add<AddOpLowering, ConstantOpLowering, FuncOpLowering, MulOpLowering,
                PrintOpLowering, ReturnOpLowering, TransposeOpLowering>(
       &getContext());
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our `illegal`
   // operations were not converted successfully.
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
 /// Create a pass for lowering operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<Pass> mlir::toy::createLowerToAffinePass() {
   return std::make_unique<ToyToAffineLoweringPass>();
 }

mlir/examples/toy/Ch6/mlir/MLIRGen.cpp

public:
 
   /// Public API: convert the AST for a Toy module (source file) to an MLIR
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
-    for (FunctionAST &f : moduleAST) {
-      auto func = mlirGen(f);
-      if (!func)
-        return nullptr;
-      theModule.push_back(func);
-    }
+    for (FunctionAST &f : moduleAST)
+      mlirGen(f);
 
     // Verify the module after we have finished constructing it, this will check
     // the structural properties of the IR and invoke any specific verifiers we
     // have on the Toy operations.
     if (failed(mlir::verify(theModule))) {
       theModule.emitError("module verification error");
       return nullptr;
     }
mlir::LogicalResult declare(llvm::StringRef var, mlir::Value value) {
     if (symbolTable.count(var))
       return mlir::failure();
     symbolTable.insert(var, value);
     return mlir::success();
   }
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
-  mlir::FuncOp mlirGen(PrototypeAST &proto) {
+  mlir::toy::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     // Arguments type are uniformly unranked tensors.
     llvm::SmallVector<mlir::Type, 4> argTypes(proto.getArgs().size(),
                                               getType(VarType{}));
     auto funcType = builder.getFunctionType(argTypes, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), funcType);
+    return builder.create<mlir::toy::FuncOp>(location, proto.getName(),
+                                             funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
-  mlir::FuncOp mlirGen(FunctionAST &funcAST) {
+  mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
     ScopedHashTableScope<llvm::StringRef, mlir::Value> varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
-    mlir::FuncOp function(mlirGen(*funcAST.getProto()));
+    builder.setInsertionPointToEnd(theModule.getBody());
+    mlir::toy::FuncOp function = mlirGen(*funcAST.getProto());
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
-    // In MLIR the entry block of the function is special: it must have the same
-    // argument list as the function itself.
-    auto &entryBlock = *function.addEntryBlock();
+    mlir::Block &entryBlock = function.front();
     auto protoArgs = funcAST.getProto()->getArgs();
 
     // Declare all the function arguments in the symbol table.
     for (const auto nameValue :
          llvm::zip(protoArgs, entryBlock.getArguments())) {
       if (failed(declare(std::get<0>(nameValue)->getName(),
                          std::get<1>(nameValue))))
         return nullptr;

mlir/examples/toy/Ch6/mlir/ShapeInferencePass.cpp

 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
 public:
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {

mlir/examples/toy/Ch6/toyc.cpp

int loadAndProcessMLIR(mlir::MLIRContext &context,
   bool isLoweringToLLVM = emitAction >= Action::DumpMLIRLLVM;
 
   if (enableOpt || isLoweringToAffine) {
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
-    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
+    mlir::OpPassManager &optPM = pm.nest<mlir::toy::FuncOp>();
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
   }
 
   if (isLoweringToAffine) {
-    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
+    // Partially lower the toy dialect.
+    pm.addPass(mlir::toy::createLowerToAffinePass());
 
-    // Partially lower the toy dialect with a few cleanups afterwards.
-    optPM.addPass(mlir::toy::createLowerToAffinePass());
+    // Add a few cleanups post lowering.
+    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 
     // Add optimizations if enabled.
     if (enableOpt) {
       optPM.addPass(mlir::createLoopFusionPass());
       optPM.addPass(mlir::createAffineScalarReplacementPass());
     }

mlir/examples/toy/Ch7/include/toy/Dialect.h

 //===- Dialect.h - Dialect definition for the Toy IR ----------------------===//
 //
 // 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 implements the IR Dialect for the Toy language.
 // See docs/Tutorials/Toy/Ch-2.md for more information.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TUTORIAL_TOY_DIALECT_H_
 #define MLIR_TUTORIAL_TOY_DIALECT_H_
 
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/Dialect.h"
+#include "mlir/IR/FunctionInterfaces.h"
+#include "mlir/IR/SymbolTable.h"
+#include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/CastInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "toy/ShapeInferenceInterface.h"
 
 namespace mlir {
 namespace toy {
 namespace detail {
 struct StructTypeStorage;

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

 //===- Ops.td - Toy dialect operation definitions ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the operations of the Toy dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef TOY_OPS
 #define TOY_OPS
 
+include "mlir/IR/FunctionInterfaces.td"
+include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/CastInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
def CastOp : Toy_Op<"cast", [
 
   let arguments = (ins F64Tensor:$input);
   let results = (outs F64Tensor:$output);
 
   let assemblyFormat = "$input attr-dict `:` type($input) `to` type($output)";
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+def FuncOp : Toy_Op<"func", [
+    DeclareOpInterfaceMethods<CallableOpInterface>, FunctionOpInterface,
+    IsolatedFromAbove, Symbol
+  ]> {
+  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
+    toy.func @main() {
+      %0 = toy.constant dense<5.500000e+00> : tensor<f64>
+      %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
+      toy.print %1 : tensor<2x2xf64>
+      toy.return
+    }
+    ```
+  }];
+
+  let arguments = (ins
+    SymbolNameAttr:$sym_name,
+    TypeAttrOf<FunctionType>:$type
+  );
+  let regions = (region AnyRegion:$body);
+
+  let builders = [OpBuilder<(ins
+    "StringRef":$name, "FunctionType":$type,
+    CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)
+  >];
+  let extraClassDeclaration = [{
+    /// Returns the type of this function.
+    /// FIXME: We should drive this via the ODS `type` param.
+    FunctionType getType() { 
+      return getTypeAttr().getValue().cast<FunctionType>();
+    }
+
+    //===------------------------------------------------------------------===//
+    // FunctionOpInterface Methods
+    //===------------------------------------------------------------------===//
+
+    /// Returns the argument types of this function.
+    ArrayRef<Type> getArgumentTypes() { return type().getInputs(); }
+
+    /// Returns the result types of this function.
+    ArrayRef<Type> getResultTypes() { return type().getResults(); }
+
+    /// Verify the type attribute of this function. Returns failure and emits
+    /// an error if the attribute is invalid.
+    LogicalResult verifyType() {
+      auto type = getTypeAttr().getValue();
+      if (!type.isa<FunctionType>())
+        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
+                           "' attribute of function type");
+      return success();
+    }
+  }];
+  let hasCustomAssemblyFormat = 1;
+  let skipDefaultBuilders = 1;
+  let hasVerifier = 1;
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 def GenericCallOp : Toy_Op<"generic_call",
     [DeclareOpInterfaceMethods<CallOpInterface>]> {
   let summary = "generic call operation";
   let description = [{
     Generic calls represent calls to a user defined function that needs to

mlir/examples/toy/Ch7/mlir/Dialect.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "toy/Dialect.h"
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/FunctionImplementation.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/Transforms/InliningUtils.h"
 
 using namespace mlir;
 using namespace mlir::toy;
 
 #include "toy/Dialect.cpp.inc"
 
struct ToyInlinerInterface : public DialectInlinerInterface {
   }
 
   /// All operations within toy can be inlined.
   bool isLegalToInline(Operation *, Region *, bool,
                        BlockAndValueMapping &) const final {
     return true;
   }
 
+  // All functions within toy can be inlined.
+  bool isLegalToInline(Region *, Region *, bool,
+                       BlockAndValueMapping &) const final {
+    return true;
+  }
+
   //===--------------------------------------------------------------------===//
   // Transformation Hooks
   //===--------------------------------------------------------------------===//
 
   /// Handle the given inlined terminator(toy.return) by replacing it with a new
   /// operation as necessary.
   void handleTerminator(Operation *op,
                         ArrayRef<Value> valuesToRepl) const final {
bool CastOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   TensorType output = outputs.front().dyn_cast<TensorType>();
   if (!input || !output || input.getElementType() != output.getElementType())
     return false;
   // The shape is required to match if both types are ranked.
   return !input.hasRank() || !output.hasRank() || input == output;
 }
 
 //===----------------------------------------------------------------------===//
+// FuncOp
+//===----------------------------------------------------------------------===//
+
+void FuncOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
+                   llvm::StringRef name, mlir::FunctionType type,
+                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
+  // FunctionOpInterface provides a convenient `build` method that will populate
+  // the state of our FuncOp, and create an entry block.
+  buildWithEntryBlock(builder, state, name, type, attrs, type.getInputs());
+}
+
+mlir::ParseResult FuncOp::parse(mlir::OpAsmParser &parser,
+                                mlir::OperationState &result) {
+  // Dispatch to the FunctionOpInterface provided utility method that parses the
+  // function operation.
+  auto buildFuncType =
+      [](mlir::Builder &builder, llvm::ArrayRef<mlir::Type> argTypes,
+         llvm::ArrayRef<mlir::Type> results,
+         mlir::function_interface_impl::VariadicFlag,
+         std::string &) { return builder.getFunctionType(argTypes, results); };
+
+  return mlir::function_interface_impl::parseFunctionOp(
+      parser, result, /*allowVariadic=*/false, buildFuncType);
+}
+
+void FuncOp::print(mlir::OpAsmPrinter &p) {
+  // Dispatch to the FunctionOpInterface provided utility method that prints the
+  // function operation.
+  mlir::function_interface_impl::printFunctionOp(p, *this,
+                                                 /*isVariadic=*/false);
+}
+
+mlir::LogicalResult FuncOp::verify() {
+  // Verify that the argument list of the function and the arg list of the entry
+  // block line up. The trait already verified that the number of arguments is
+  // the same between the signature and the block.
+  llvm::ArrayRef<mlir::Type> fnInputTypes = getType().getInputs();
+  mlir::Block &entryBlock = front();
+  for (unsigned i = 0, e = entryBlock.getNumArguments(); i != e; ++i) {
+    if (fnInputTypes[i] != entryBlock.getArgument(i).getType()) {
+      return emitOpError("type of entry block argument #")
+             << i << '(' << entryBlock.getArgument(i).getType()
+             << ") must match the type of the corresponding argument in "
+             << "function signature(" << fnInputTypes[i] << ')';
+    }
+  }
+
+  return success();
+}
+
+/// Returns the region on the function operation that is callable.
+mlir::Region *FuncOp::getCallableRegion() { return &getBody(); }
+
+/// Returns the results types that the callable region produces when
+/// executed.
+llvm::ArrayRef<mlir::Type> FuncOp::getCallableResults() {
+  return getType().getResults();
+}
+
+//===----------------------------------------------------------------------===//
 // GenericCallOp
 //===----------------------------------------------------------------------===//
 
 void GenericCallOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                           StringRef callee, ArrayRef<mlir::Value> arguments) {
   // Generic call always returns an unranked Tensor initially.
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));
   state.addOperands(arguments);

mlir/examples/toy/Ch7/mlir/LowerToAffineLoops.cpp

 //====- LowerToAffineLoops.cpp - Partial lowering from Toy to Affine+Std --===//
 //
 // 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 implements a partial lowering of Toy operations to a combination of
 // affine loops, memref operations and standard operations. This lowering
 // expects that all calls have been inlined, and all shapes have been resolved.
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/IR/BuiltinDialect.h"
 #include "toy/Dialect.h"
 #include "toy/Passes.h"
 
 #include "mlir/Dialect/Affine/IR/AffineOps.h"
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/Func/IR/FuncOps.h"
 #include "mlir/Dialect/MemRef/IR/MemRef.h"
 #include "mlir/Pass/Pass.h"
LogicalResult matchAndRewrite(toy::ConstantOp op,
 
     // Replace this operation with the generated alloc.
     rewriter.replaceOp(op, alloc);
     return success();
   }
 };
 
 //===----------------------------------------------------------------------===//
+// ToyToAffine RewritePatterns: Func operations
+//===----------------------------------------------------------------------===//
+
+struct FuncOpLowering : public OpConversionPattern<toy::FuncOp> {
+  using OpConversionPattern<toy::FuncOp>::OpConversionPattern;
+
+  LogicalResult
+  matchAndRewrite(toy::FuncOp op, OpAdaptor adaptor,
+                  ConversionPatternRewriter &rewriter) const final {
+    // We only lower the main function as we expect that all other functions
+    // have been inlined.
+    if (op.getName() != "main")
+      return failure();
+
+    // Verify that the given main has no inputs and results.
+    if (op.getNumArguments() || op.getType().getNumResults()) {
+      return rewriter.notifyMatchFailure(op, [](Diagnostic &diag) {
+        diag << "expected 'main' to have 0 inputs and 0 results";
+      });
+    }
+
+    // Create a new non-toy function, with the same region.
+    auto func =
+        rewriter.create<mlir::FuncOp>(op.getLoc(), op.getName(), op.getType());
+    rewriter.inlineRegionBefore(op.getRegion(), func.getBody(), func.end());
+    rewriter.eraseOp(op);
+    return success();
+  }
+};
+
+//===----------------------------------------------------------------------===//
 // ToyToAffine RewritePatterns: Print operations
 //===----------------------------------------------------------------------===//
 
 struct PrintOpLowering : public OpConversionPattern<toy::PrintOp> {
   using OpConversionPattern<toy::PrintOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(toy::PrintOp op, OpAdaptor adaptor,

 // ToyToAffineLoweringPass
 //===----------------------------------------------------------------------===//
 
 /// This is a partial lowering to affine loops of the toy operations that are
 /// computationally intensive (like matmul for example...) while keeping the
 /// rest of the code in the Toy dialect.
 namespace {
 struct ToyToAffineLoweringPass
-    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<FuncOp>> {
+    : public PassWrapper<ToyToAffineLoweringPass, OperationPass<ModuleOp>> {
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<AffineDialect, func::FuncDialect, memref::MemRefDialect>();
   }
   void runOnOperation() final;
 };
 } // namespace
 
 void ToyToAffineLoweringPass::runOnOperation() {
-  auto function = getOperation();
-
-  // We only lower the main function as we expect that all other functions have
-  // been inlined.
-  if (function.getName() != "main")
-    return;
-
-  // Verify that the given main has no inputs and results.
-  if (function.getNumArguments() || function.getType().getNumResults()) {
-    function.emitError("expected 'main' to have 0 inputs and 0 results");
-    return signalPassFailure();
-  }
-
   // The first thing to define is the conversion target. This will define the
   // final target for this lowering.
   ConversionTarget target(getContext());
 
   // We define the specific operations, or dialects, that are legal targets for
   // this lowering. In our case, we are lowering to a combination of the
   // `Affine`, `Arithmetic`, `Func`, and `MemRef` dialects.
-  target.addLegalDialect<AffineDialect, arith::ArithmeticDialect,
-                         func::FuncDialect, memref::MemRefDialect>();
+  target
+      .addLegalDialect<AffineDialect, BuiltinDialect, arith::ArithmeticDialect,
 
   // We also define the Toy dialect as Illegal so that the conversion will fail
   // if any of these operations are *not* converted. Given that we actually want
   // a partial lowering, we explicitly mark the Toy operations that don't want
   // to lower, `toy.print`, as `legal`. `toy.print` will still need its operands
   // to be updated though (as we convert from TensorType to MemRefType), so we
   // only treat it as `legal` if its operands are legal.
   target.addIllegalDialect<toy::ToyDialect>();
   target.addDynamicallyLegalOp<toy::PrintOp>([](toy::PrintOp op) {
     return llvm::none_of(op->getOperandTypes(),
                          [](Type type) { return type.isa<TensorType>(); });
   });
 
   // Now that the conversion target has been defined, we just need to provide
   // the set of patterns that will lower the Toy operations.
   RewritePatternSet patterns(&getContext());
-  patterns.add<AddOpLowering, ConstantOpLowering, MulOpLowering,
+  patterns.add<AddOpLowering, ConstantOpLowering, FuncOpLowering, MulOpLowering,
                PrintOpLowering, ReturnOpLowering, TransposeOpLowering>(
       &getContext());
 
   // With the target and rewrite patterns defined, we can now attempt the
   // conversion. The conversion will signal failure if any of our `illegal`
   // operations were not converted successfully.
   if (failed(
           applyPartialConversion(getOperation(), target, std::move(patterns))))
     signalPassFailure();
 }
 
 /// Create a pass for lowering operations in the `Affine` and `Std` dialects,
 /// for a subset of the Toy IR (e.g. matmul).
 std::unique_ptr<Pass> mlir::toy::createLowerToAffinePass() {
   return std::make_unique<ToyToAffineLoweringPass>();
 }

mlir/examples/toy/Ch7/mlir/MLIRGen.cpp

public:
   /// Module operation.
   mlir::ModuleOp mlirGen(ModuleAST &moduleAST) {
     // We create an empty MLIR module and codegen functions one at a time and
     // add them to the module.
     theModule = mlir::ModuleOp::create(builder.getUnknownLoc());
 
     for (auto &record : moduleAST) {
       if (FunctionAST *funcAST = llvm::dyn_cast<FunctionAST>(record.get())) {
-        auto func = mlirGen(*funcAST);
+        mlir::toy::FuncOp func = mlirGen(*funcAST);
         if (!func)
           return nullptr;
-
-        theModule.push_back(func);
         functionMap.insert({func.getName(), func});
       } else if (StructAST *str = llvm::dyn_cast<StructAST>(record.get())) {
         if (failed(mlirGen(*str)))
           return nullptr;
       } else {
         llvm_unreachable("unknown record type");
       }
     }
private:
   /// scope is destroyed and the mappings created in this scope are dropped.
   llvm::ScopedHashTable<StringRef, std::pair<mlir::Value, VarDeclExprAST *>>
       symbolTable;
   using SymbolTableScopeT =
       llvm::ScopedHashTableScope<StringRef,
                                  std::pair<mlir::Value, VarDeclExprAST *>>;
 
   /// A mapping for the functions that have been code generated to MLIR.
-  llvm::StringMap<mlir::FuncOp> functionMap;
+  llvm::StringMap<mlir::toy::FuncOp> functionMap;
 
   /// A mapping for named struct types to the underlying MLIR type and the
   /// original AST node.
   llvm::StringMap<std::pair<mlir::Type, StructAST *>> structMap;
 
   /// Helper conversion for a Toy AST location to an MLIR location.
   mlir::Location loc(const Location &loc) {
     return mlir::FileLineColLoc::get(builder.getStringAttr(*loc.file), loc.line,
mlir::LogicalResult mlirGen(StructAST &str) {
     }
 
     structMap.try_emplace(str.getName(), StructType::get(elementTypes), &str);
     return mlir::success();
   }
 
   /// Create the prototype for an MLIR function with as many arguments as the
   /// provided Toy AST prototype.
-  mlir::FuncOp mlirGen(PrototypeAST &proto) {
+  mlir::toy::FuncOp mlirGen(PrototypeAST &proto) {
     auto location = loc(proto.loc());
 
     // This is a generic function, the return type will be inferred later.
     llvm::SmallVector<mlir::Type, 4> argTypes;
     argTypes.reserve(proto.getArgs().size());
     for (auto &arg : proto.getArgs()) {
       mlir::Type type = getType(arg->getType(), arg->loc());
       if (!type)
         return nullptr;
       argTypes.push_back(type);
     }
     auto funcType = builder.getFunctionType(argTypes, llvm::None);
-    return mlir::FuncOp::create(location, proto.getName(), funcType);
+    return builder.create<mlir::toy::FuncOp>(location, proto.getName(),
+                                             funcType);
   }
 
   /// Emit a new function and add it to the MLIR module.
-  mlir::FuncOp mlirGen(FunctionAST &funcAST) {
+  mlir::toy::FuncOp mlirGen(FunctionAST &funcAST) {
     // Create a scope in the symbol table to hold variable declarations.
     SymbolTableScopeT varScope(symbolTable);
 
     // Create an MLIR function for the given prototype.
-    mlir::FuncOp function(mlirGen(*funcAST.getProto()));
+    builder.setInsertionPointToEnd(theModule.getBody());
+    mlir::toy::FuncOp function = mlirGen(*funcAST.getProto());
     if (!function)
       return nullptr;
 
     // Let's start the body of the function now!
-    // In MLIR the entry block of the function is special: it must have the same
-    // argument list as the function itself.
-    auto &entryBlock = *function.addEntryBlock();
+    mlir::Block &entryBlock = function.front();
     auto protoArgs = funcAST.getProto()->getArgs();
 
     // Declare all the function arguments in the symbol table.
     for (const auto nameValue :
          llvm::zip(protoArgs, entryBlock.getArguments())) {
       if (failed(declare(*std::get<0>(nameValue), std::get<1>(nameValue))))
         return nullptr;
     }
mlir::Value mlirGen(CallExprAST &call) {
     // Otherwise this is a call to a user-defined function. Calls to
     // user-defined functions are mapped to a custom call that takes the callee
     // name as an attribute.
     auto calledFuncIt = functionMap.find(callee);
     if (calledFuncIt == functionMap.end()) {
       emitError(location) << "no defined function found for '" << callee << "'";
       return nullptr;
     }
-    mlir::FuncOp calledFunc = calledFuncIt->second;
+    mlir::toy::FuncOp calledFunc = calledFuncIt->second;
     return builder.create<GenericCallOp>(
         location, calledFunc.getType().getResult(0),
         mlir::SymbolRefAttr::get(builder.getContext(), callee), operands);
   }
 
   /// Emit a print expression. It emits specific operations for two builtins:
   /// transpose(x) and print(x).
   mlir::LogicalResult mlirGen(PrintExprAST &call) {

mlir/examples/toy/Ch7/mlir/ShapeInferencePass.cpp

 ///     a) find an operation to process: the next ready operation in the
 ///        worklist has all of its arguments non-generic,
 ///     b) if no operation is found, break out of the loop,
 ///     c) remove the operation from the worklist,
 ///     d) infer the shape of its output from the argument types.
 ///   3) If the worklist is empty, the algorithm succeeded.
 ///
 class ShapeInferencePass
-    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<FuncOp>> {
+    : public mlir::PassWrapper<ShapeInferencePass, OperationPass<toy::FuncOp>> {
 public:
   void runOnOperation() override {
     auto f = getOperation();
 
     // Populate the worklist with the operations that need shape inference:
     // these are operations that return a dynamic shape.
     llvm::SmallPtrSet<mlir::Operation *, 16> opWorklist;
     f.walk([&](mlir::Operation *op) {

mlir/examples/toy/Ch7/toyc.cpp

int loadAndProcessMLIR(mlir::MLIRContext &context,
   bool isLoweringToLLVM = emitAction >= Action::DumpMLIRLLVM;
 
   if (enableOpt || isLoweringToAffine) {
     // Inline all functions into main and then delete them.
     pm.addPass(mlir::createInlinerPass());
 
     // Now that there is only one function, we can infer the shapes of each of
     // the operations.
-    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
+    mlir::OpPassManager &optPM = pm.nest<mlir::toy::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::toy::createShapeInferencePass());
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
   }
 
   if (isLoweringToAffine) {
-    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
+    // Partially lower the toy dialect.
+    pm.addPass(mlir::toy::createLowerToAffinePass());
 
-    // Partially lower the toy dialect with a few cleanups afterwards.
-    optPM.addPass(mlir::toy::createLowerToAffinePass());
+    // Add a few cleanups post lowering.
+    mlir::OpPassManager &optPM = pm.nest<mlir::FuncOp>();
     optPM.addPass(mlir::createCanonicalizerPass());
     optPM.addPass(mlir::createCSEPass());
 
     // Add optimizations if enabled.
     if (enableOpt) {
       optPM.addPass(mlir::createLoopFusionPass());
       optPM.addPass(mlir::createAffineScalarReplacementPass());
     }

mlir/test/Examples/Toy/Ch2/codegen.toy

 # RUN: toyc-ch2 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func @multiply_transpose(
-# CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
+# CHECK-LABEL: toy.func @multiply_transpose(
+# CHECK-SAME:                               [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch2/invalid.mlir

 // RUN: not toyc-ch2 %s -emit=mlir 2>&1
 
 // The following IR is not "valid":
 // - toy.print should not return a value.
 // - toy.print should take an argument.
 // - There should be a block terminator.
-func @main() {
+toy.func @main() {
   %0 = "toy.print"()  : () -> tensor<2x3xf64>
 }

mlir/test/Examples/Toy/Ch2/scalar.toy

 # RUN: toyc-ch2 %s -emit=mlir 2>&1 | FileCheck %s
 
 def main() {
   var a<2, 2> = 5.5;
   print(a);
 }
 
-# CHECK-LABEL: func @main() {
+# CHECK-LABEL: toy.func @main() {
 # CHECK-NEXT:    %0 = toy.constant dense<5.500000e+00> : tensor<f64>
 # CHECK-NEXT:    %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
 # CHECK-NEXT:    toy.print %1 : tensor<2x2xf64>
 # CHECK-NEXT:    toy.return
 # CHECK-NEXT:  }
 

mlir/test/Examples/Toy/Ch3/codegen.toy

 # RUN: toyc-ch3 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func @multiply_transpose(
-# CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
+# CHECK-LABEL: toy.func @multiply_transpose(
+# CHECK-SAME:                               [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch3/invalid.mlir

 // RUN: not toyc-ch3 %s -emit=mlir 2>&1
 
 // The following IR is not "valid":
 // - toy.print should not return a value.
 // - toy.print should take an argument.
 // - There should be a block terminator.
-func @main() {
+toy.func @main() {
   %0 = "toy.print"()  : () -> tensor<2x3xf64>
 }

mlir/test/Examples/Toy/Ch3/scalar.toy

 # RUN: toyc-ch3 %s -emit=mlir 2>&1 | FileCheck %s
 
 def main() {
   var a<2, 2> = 5.5;
   print(a);
 }
 
-# CHECK-LABEL: func @main() {
+# CHECK-LABEL: toy.func @main() {
 # CHECK-NEXT:    %0 = toy.constant dense<5.500000e+00> : tensor<f64>
 # CHECK-NEXT:    %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
 # CHECK-NEXT:    toy.print %1 : tensor<2x2xf64>
 # CHECK-NEXT:    toy.return
 # CHECK-NEXT:  }
 

mlir/test/Examples/Toy/Ch3/transpose_transpose.toy

 # RUN: toyc-ch3 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def transpose_transpose(x) {
   return transpose(transpose(x));
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b = transpose_transpose(a);
   print(b);
 }
 
-# CHECK-LABEL: func @transpose_transpose(
-# CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>) -> tensor<*xf64>
+# CHECK-LABEL: toy.func @transpose_transpose(
+# CHECK-SAME:                                [[VAL_0:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_0]] : tensor<*xf64>
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_1:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_2:%.*]] = toy.generic_call @transpose_transpose([[VAL_1]]) : (tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_2]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return
 No newline at end of file

mlir/test/Examples/Toy/Ch3/trivial_reshape.toy

 # RUN: toyc-ch3 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 def main() {
   var a<2,1> = [1, 2];
   var b<2,1> = a;
   var c<2,1> = b;
   print(c);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_0:%.*]] = toy.constant
 # CHECK-SAME:     dense<[
 # CHECK-SAME:     [1.000000e+00], [2.000000e+00]
 # CHECK-SAME:     ]> : tensor<2x1xf64>
 # CHECK-NEXT:    toy.print [[VAL_0]] : tensor<2x1xf64>
 # CHECK-NEXT:    toy.return
 No newline at end of file

mlir/test/Examples/Toy/Ch4/codegen.toy

 # RUN: toyc-ch4 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func private @multiply_transpose(
+# CHECK-LABEL: toy.func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch4/invalid.mlir

 // RUN: not toyc-ch4 %s -emit=mlir 2>&1
 
 // The following IR is not "valid":
 // - toy.print should not return a value.
 // - toy.print should take an argument.
 // - There should be a block terminator.
-func @main() {
+toy.func @main() {
   %0 = "toy.print"()  : () -> tensor<2x3xf64>
 }

mlir/test/Examples/Toy/Ch4/scalar.toy

 # RUN: toyc-ch4 %s -emit=mlir 2>&1 | FileCheck %s
 
 def main() {
   var a<2, 2> = 5.5;
   print(a);
 }
 
-# CHECK-LABEL: func @main() {
+# CHECK-LABEL: toy.func @main() {
 # CHECK-NEXT:    %0 = toy.constant dense<5.500000e+00> : tensor<f64>
 # CHECK-NEXT:    %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
 # CHECK-NEXT:    toy.print %1 : tensor<2x2xf64>
 # CHECK-NEXT:    toy.return
 # CHECK-NEXT:  }
 

mlir/test/Examples/Toy/Ch4/shape_inference.mlir

 // RUN: toyc-ch4 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
+toy.func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>
   %2 = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
   %3 = toy.reshape(%2 : tensor<6xf64>) to tensor<2x3xf64>
   %4 = toy.generic_call @multiply_transpose(%1, %3) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   %5 = toy.generic_call @multiply_transpose(%3, %1) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   toy.print %5 : tensor<*xf64>
   toy.return
 }
 
-// CHECK-NOT: func private @multiply_transpose
+// CHECK-NOT: toy.func private @multiply_transpose
 // CHECK-NOT: tensor<*xf64>
 
-// CHECK-LABEL: func @main()
+// CHECK-LABEL: toy.func @main()
 // CHECK:         [[VAL_0:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 // CHECK:         [[VAL_1:%.*]] = toy.transpose([[VAL_0]] : tensor<2x3xf64>) to tensor<3x2xf64>
 // CHECK:         [[VAL_2:%.*]] = toy.mul [[VAL_1]], [[VAL_1]] : tensor<3x2xf64>
 // CHECK:         toy.print [[VAL_2]] : tensor<3x2xf64>
 // CHECK:         toy.return

mlir/test/Examples/Toy/Ch4/transpose_transpose.toy

 # RUN: toyc-ch4 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def transpose_transpose(x) {
   return transpose(transpose(x));
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b = transpose_transpose(a);
   print(b);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_1:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    toy.print [[VAL_1]] : tensor<2x3xf64>
 # CHECK-NEXT:    toy.return
 No newline at end of file

mlir/test/Examples/Toy/Ch4/trivial_reshape.toy

 # RUN: toyc-ch4 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 def main() {
   var a<2,1> = [1, 2];
   var b<2,1> = a;
   var c<2,1> = b;
   print(c);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_0:%.*]] = toy.constant
 # CHECK-SAME:     dense<[
 # CHECK-SAME:     [1.000000e+00], [2.000000e+00]
 # CHECK-SAME:     ]> : tensor<2x1xf64>
 # CHECK-NEXT:    toy.print [[VAL_0]] : tensor<2x1xf64>
 # CHECK-NEXT:    toy.return
 No newline at end of file

mlir/test/Examples/Toy/Ch5/affine-lowering.mlir

 // RUN: toyc-ch5 %s -emit=mlir-affine 2>&1 | FileCheck %s
 // RUN: toyc-ch5 %s -emit=mlir-affine -opt 2>&1 | FileCheck %s --check-prefix=OPT
 
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
   %3 = toy.mul %2, %2 : tensor<3x2xf64>
   toy.print %3 : tensor<3x2xf64>
   toy.return
 }
 
 // CHECK-LABEL: func @main()

mlir/test/Examples/Toy/Ch5/codegen.toy

 # RUN: toyc-ch5 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func private @multiply_transpose(
+# CHECK-LABEL: toy.func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch5/invalid.mlir

 // RUN: not toyc-ch5 %s -emit=mlir 2>&1
 
 // The following IR is not "valid":
 // - toy.print should not return a value.
 // - toy.print should take an argument.
 // - There should be a block terminator.
-func @main() {
+toy.func @main() {
   %0 = "toy.print"()  : () -> tensor<2x3xf64>
 }

mlir/test/Examples/Toy/Ch5/shape_inference.mlir

 // RUN: toyc-ch5 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
+toy.func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>
   %2 = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
   %3 = toy.reshape(%2 : tensor<6xf64>) to tensor<2x3xf64>
   %4 = toy.generic_call @multiply_transpose(%1, %3) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   %5 = toy.generic_call @multiply_transpose(%3, %1) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   toy.print %5 : tensor<*xf64>
   toy.return
 }
 
-// CHECK-NOT: func @multiply_transpose
+// CHECK-NOT: toy.func @multiply_transpose
 // CHECK-NOT: tensor<*xf64>
 
-// CHECK-LABEL: func @main()
+// CHECK-LABEL: toy.func @main()
 // CHECK:         [[VAL_0:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 // CHECK:         [[VAL_1:%.*]] = toy.transpose([[VAL_0]] : tensor<2x3xf64>) to tensor<3x2xf64>
 // CHECK:         [[VAL_2:%.*]] = toy.mul [[VAL_1]], [[VAL_1]] : tensor<3x2xf64>
 // CHECK:         toy.print [[VAL_2]] : tensor<3x2xf64>
 // CHECK:         toy.return

mlir/test/Examples/Toy/Ch5/transpose_transpose.toy

 # RUN: toyc-ch5 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def transpose_transpose(x) {
   return transpose(transpose(x));
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b = transpose_transpose(a);
   print(b);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_1:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    toy.print [[VAL_1]] : tensor<2x3xf64>
 # CHECK-NEXT:    toy.return
 No newline at end of file

mlir/test/Examples/Toy/Ch5/trivial_reshape.toy

 # RUN: toyc-ch5 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 def main() {
   var a<2,1> = [1, 2];
   var b<2,1> = a;
   var c<2,1> = b;
   print(c);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_0:%.*]] = toy.constant
 # CHECK-SAME:     dense<[
 # CHECK-SAME:     [1.000000e+00], [2.000000e+00]
 # CHECK-SAME:     ]> : tensor<2x1xf64>
 # CHECK-NEXT:    toy.print [[VAL_0]] : tensor<2x1xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch6/affine-lowering.mlir

 // RUN: toyc-ch6 %s -emit=mlir-affine 2>&1 | FileCheck %s
 // RUN: toyc-ch6 %s -emit=mlir-affine -opt 2>&1 | FileCheck %s --check-prefix=OPT
 
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
   %3 = toy.mul %2, %2 : tensor<3x2xf64>
   toy.print %3 : tensor<3x2xf64>
   toy.return
 }
 
 // CHECK-LABEL: func @main()

mlir/test/Examples/Toy/Ch6/codegen.toy

 # RUN: toyc-ch6 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func private @multiply_transpose(
+# CHECK-LABEL: toy.func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch6/invalid.mlir

 // RUN: not toyc-ch6 %s -emit=mlir 2>&1
 
 // The following IR is not "valid":
 // - toy.print should not return a value.
 // - toy.print should take an argument.
 // - There should be a block terminator.
-func @main() {
+toy.func @main() {
   %0 = "toy.print"()  : () -> tensor<2x3xf64>
 }

mlir/test/Examples/Toy/Ch6/llvm-lowering.mlir

 // RUN: toyc-ch6 %s -emit=llvm -opt
 
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
   %3 = toy.mul %2, %2 : tensor<3x2xf64>
   toy.print %3 : tensor<3x2xf64>
   toy.return
 }
 
 // CHECK-LABEL: define void @main()

mlir/test/Examples/Toy/Ch6/scalar.toy

 # RUN: toyc-ch6 %s -emit=mlir 2>&1 | FileCheck %s
 
 def main() {
   var a<2, 2> = 5.5;
   print(a);
 }
 
-# CHECK-LABEL: func @main() {
+# CHECK-LABEL: toy.func @main() {
 # CHECK-NEXT:    %0 = toy.constant dense<5.500000e+00> : tensor<f64>
 # CHECK-NEXT:    %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
 # CHECK-NEXT:    toy.print %1 : tensor<2x2xf64>
 # CHECK-NEXT:    toy.return
 # CHECK-NEXT:  }
 

mlir/test/Examples/Toy/Ch6/shape_inference.mlir

 // RUN: toyc-ch6 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
+toy.func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>
   %2 = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
   %3 = toy.reshape(%2 : tensor<6xf64>) to tensor<2x3xf64>
   %4 = toy.generic_call @multiply_transpose(%1, %3) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   %5 = toy.generic_call @multiply_transpose(%3, %1) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   toy.print %5 : tensor<*xf64>
   toy.return
 }
 
-// CHECK-NOT: func @multiply_transpose
+// CHECK-NOT: toy.func @multiply_transpose
 // CHECK-NOT: tensor<*xf64>
 
-// CHECK-LABEL: func @main()
+// CHECK-LABEL: toy.func @main()
 // CHECK:         [[VAL_0:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 // CHECK:         [[VAL_1:%.*]] = toy.transpose([[VAL_0]] : tensor<2x3xf64>) to tensor<3x2xf64>
 // CHECK:         [[VAL_2:%.*]] = toy.mul [[VAL_1]], [[VAL_1]] : tensor<3x2xf64>
 // CHECK:         toy.print [[VAL_2]] : tensor<3x2xf64>
 // CHECK:         toy.return

mlir/test/Examples/Toy/Ch6/transpose_transpose.toy

 # RUN: toyc-ch6 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def transpose_transpose(x) {
   return transpose(transpose(x));
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b = transpose_transpose(a);
   print(b);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_1:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    toy.print [[VAL_1]] : tensor<2x3xf64>
 # CHECK-NEXT:    toy.return
 No newline at end of file

mlir/test/Examples/Toy/Ch6/trivial_reshape.toy

 # RUN: toyc-ch6 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 def main() {
   var a<2,1> = [1, 2];
   var b<2,1> = a;
   var c<2,1> = b;
   print(c);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_0:%.*]] = toy.constant
 # CHECK-SAME:     dense<[
 # CHECK-SAME:     [1.000000e+00], [2.000000e+00]
 # CHECK-SAME:     ]> : tensor<2x1xf64>
 # CHECK-NEXT:    toy.print [[VAL_0]] : tensor<2x1xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch7/affine-lowering.mlir

 // RUN: toyc-ch7 %s -emit=mlir-affine 2>&1 | FileCheck %s
 // RUN: toyc-ch7 %s -emit=mlir-affine -opt 2>&1 | FileCheck %s --check-prefix=OPT
 
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
   %3 = toy.mul %2, %2 : tensor<3x2xf64>
   toy.print %3 : tensor<3x2xf64>
   toy.return
 }
 
 // CHECK-LABEL: func @main()

mlir/test/Examples/Toy/Ch7/codegen.toy

 # RUN: toyc-ch7 %s -emit=mlir 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def multiply_transpose(a, b) {
   return transpose(a) * transpose(b);
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b<2, 3> = [1, 2, 3, 4, 5, 6];
   var c = multiply_transpose(a, b);
   var d = multiply_transpose(b, a);
   print(d);
 }
 
-# CHECK-LABEL: func private @multiply_transpose(
+# CHECK-LABEL: toy.func private @multiply_transpose(
 # CHECK-SAME:                           [[VAL_0:%.*]]: tensor<*xf64>, [[VAL_1:%.*]]: tensor<*xf64>) -> tensor<*xf64>
 # CHECK:         [[VAL_2:%.*]] = toy.transpose([[VAL_0]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_3:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:    [[VAL_4:%.*]] = toy.mul [[VAL_2]], [[VAL_3]] :  tensor<*xf64>
 # CHECK-NEXT:    toy.return [[VAL_4]] : tensor<*xf64>
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_5:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_6:%.*]] = toy.reshape([[VAL_5]] : tensor<2x3xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_7:%.*]] = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
 # CHECK-NEXT:    [[VAL_8:%.*]] = toy.reshape([[VAL_7]] : tensor<6xf64>) to tensor<2x3xf64>
 # CHECK-NEXT:    [[VAL_9:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]], [[VAL_8]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    [[VAL_10:%.*]] = toy.generic_call @multiply_transpose([[VAL_8]], [[VAL_6]]) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
 # CHECK-NEXT:    toy.print [[VAL_10]] : tensor<*xf64>
 # CHECK-NEXT:    toy.return

mlir/test/Examples/Toy/Ch7/invalid.mlir

 // RUN: not toyc-ch7 %s -emit=mlir 2>&1
 
 // The following IR is not "valid":
 // - toy.print should not return a value.
 // - toy.print should take an argument.
 // - There should be a block terminator.
-func @main() {
+toy.func @main() {
   %0 = "toy.print"()  : () -> tensor<2x3xf64>
 }

mlir/test/Examples/Toy/Ch7/llvm-lowering.mlir

 // RUN: toyc-ch7 %s -emit=llvm -opt
 
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %2 = toy.transpose(%0 : tensor<2x3xf64>) to tensor<3x2xf64>
   %3 = toy.mul %2, %2 : tensor<3x2xf64>
   toy.print %3 : tensor<3x2xf64>
   toy.return
 }
 
 // CHECK-LABEL: define void @main()

mlir/test/Examples/Toy/Ch7/scalar.toy

 # RUN: toyc-ch7 %s -emit=mlir 2>&1 | FileCheck %s
 
 def main() {
   var a<2, 2> = 5.5;
   print(a);
 }
 
-# CHECK-LABEL: func @main() {
+# CHECK-LABEL: toy.func @main() {
 # CHECK-NEXT:    %0 = toy.constant dense<5.500000e+00> : tensor<f64>
 # CHECK-NEXT:    %1 = toy.reshape(%0 : tensor<f64>) to tensor<2x2xf64>
 # CHECK-NEXT:    toy.print %1 : tensor<2x2xf64>
 # CHECK-NEXT:    toy.return
 # CHECK-NEXT:  }
 

mlir/test/Examples/Toy/Ch7/shape_inference.mlir

 // RUN: toyc-ch7 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 // Check the result of inlining+shape inference on an input module.
 
-func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
+toy.func private @multiply_transpose(%arg0: tensor<*xf64>, %arg1: tensor<*xf64>) -> tensor<*xf64> {
   %0 = toy.transpose(%arg0 : tensor<*xf64>) to tensor<*xf64>
   %1 = toy.transpose(%arg1 : tensor<*xf64>) to tensor<*xf64>
   %2 = toy.mul %0, %1 : tensor<*xf64>
   toy.return %2 : tensor<*xf64>
 }
-func @main() {
+toy.func @main() {
   %0 = toy.constant dense<[[1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
   %1 = toy.reshape(%0 : tensor<2x3xf64>) to tensor<2x3xf64>
   %2 = toy.constant dense<[1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00]> : tensor<6xf64>
   %3 = toy.reshape(%2 : tensor<6xf64>) to tensor<2x3xf64>
   %4 = toy.generic_call @multiply_transpose(%1, %3) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   %5 = toy.generic_call @multiply_transpose(%3, %1) : (tensor<2x3xf64>, tensor<2x3xf64>) -> tensor<*xf64>
   toy.print %5 : tensor<*xf64>
   toy.return

mlir/test/Examples/Toy/Ch7/struct-codegen.toy

def main() {
   # We initialize struct values using a composite initializer.
   Struct value = {[[1, 2, 3], [4, 5, 6]], [[1, 2, 3], [4, 5, 6]]};
 
   # We pass these arguments to functions like we do with variables.
   var c = multiply_transpose(value);
   print(c);
 }
 
-# CHECK-LABEL:   func private @multiply_transpose(
+# CHECK-LABEL:   toy.func private @multiply_transpose(
 # CHECK-SAME:                             [[VAL_0:%.*]]: !toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_1:%.*]] = toy.struct_access [[VAL_0]][0] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_2:%.*]] = toy.transpose([[VAL_1]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:      [[VAL_3:%.*]] = toy.struct_access [[VAL_0]][1] : !toy.struct<tensor<*xf64>, tensor<*xf64>> -> tensor<*xf64>
 # CHECK-NEXT:      [[VAL_4:%.*]] = toy.transpose([[VAL_3]] : tensor<*xf64>) to tensor<*xf64>
 # CHECK-NEXT:      [[VAL_5:%.*]] = toy.mul [[VAL_2]], [[VAL_4]] : tensor<*xf64>
 # CHECK-NEXT:      toy.return [[VAL_5]] : tensor<*xf64>
 
-# CHECK-LABEL:   func @main()
+# CHECK-LABEL:   toy.func @main()
 # CHECK-NEXT:      [[VAL_6:%.*]] = toy.struct_constant [dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>, dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>] : !toy.struct<tensor<*xf64>, tensor<*xf64>>
 # CHECK-NEXT:      [[VAL_7:%.*]] = toy.generic_call @multiply_transpose([[VAL_6]]) : (!toy.struct<tensor<*xf64>, tensor<*xf64>>) -> tensor<*xf64>
 # CHECK-NEXT:      toy.print [[VAL_7]] : tensor<*xf64>
 # CHECK-NEXT:      toy.return
 
-# OPT-LABEL:   func @main()
+# OPT-LABEL:   toy.func @main()
 # OPT-NEXT:      [[VAL_0:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # OPT-NEXT:      [[VAL_1:%.*]] = toy.transpose([[VAL_0]] : tensor<2x3xf64>) to tensor<3x2xf64>
 # OPT-NEXT:      [[VAL_2:%.*]] = toy.mul [[VAL_1]], [[VAL_1]] : tensor<3x2xf64>
 # OPT-NEXT:      toy.print [[VAL_2]] : tensor<3x2xf64>
 # OPT-NEXT:      toy.return

mlir/test/Examples/Toy/Ch7/struct-opt.mlir

 // RUN: toyc-ch7 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
-func @main() {
+toy.func @main() {
   %0 = toy.struct_constant [
     [dense<4.000000e+00> : tensor<2x2xf64>], dense<4.000000e+00> : tensor<2x2xf64>
   ] : !toy.struct<!toy.struct<tensor<*xf64>>, tensor<*xf64>>
   %1 = toy.struct_access %0[0] : !toy.struct<!toy.struct<tensor<*xf64>>, tensor<*xf64>> -> !toy.struct<tensor<*xf64>>
   %2 = toy.struct_access %1[0] : !toy.struct<tensor<*xf64>> -> tensor<*xf64>
   toy.print %2 : tensor<*xf64>
   toy.return
 }
 
-// CHECK-LABEL: func @main
+// CHECK-LABEL: toy.func @main
 // CHECK-NEXT: %[[CST:.*]] = toy.constant dense<4.0
 // CHECK-NEXT: toy.print %[[CST]]

mlir/test/Examples/Toy/Ch7/transpose_transpose.toy

 # RUN: toyc-ch7 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 # User defined generic function that operates on unknown shaped arguments
 def transpose_transpose(x) {
   return transpose(transpose(x));
 }
 
 def main() {
   var a<2, 3> = [[1, 2, 3], [4, 5, 6]];
   var b = transpose_transpose(a);
   print(b);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_1:%.*]] = toy.constant dense<{{\[\[}}1.000000e+00, 2.000000e+00, 3.000000e+00], [4.000000e+00, 5.000000e+00, 6.000000e+00]]> : tensor<2x3xf64>
 # CHECK-NEXT:    toy.print [[VAL_1]] : tensor<2x3xf64>
 # CHECK-NEXT:    toy.return
 No newline at end of file

mlir/test/Examples/Toy/Ch7/trivial_reshape.toy

 # RUN: toyc-ch7 %s -emit=mlir -opt 2>&1 | FileCheck %s
 
 def main() {
   var a<2,1> = [1, 2];
   var b<2,1> = a;
   var c<2,1> = b;
   print(c);
 }
 
-# CHECK-LABEL: func @main()
+# CHECK-LABEL: toy.func @main()
 # CHECK-NEXT:    [[VAL_0:%.*]] = toy.constant
 # CHECK-SAME:     dense<[
 # CHECK-SAME:     [1.000000e+00], [2.000000e+00]
 # CHECK-SAME:     ]> : tensor<2x1xf64>
 # CHECK-NEXT:    toy.print [[VAL_0]] : tensor<2x1xf64>
 # CHECK-NEXT:    toy.return