[MLIR] Fix several misc issues in in Toy tutorial

[jurahul]

Summary

• Fix comments in several places
• Eliminate extra ' in AST dump and adjust tests accordingly

[rriddle]

Thanks!

[jpienaar]

Thanks!

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

-   [Chapter #2](Ch-2.md): Traversing the AST to emit a dialect in MLIR,
     introducing base MLIR concepts. Here we show how to start attaching
     semantics to our custom operations in MLIR.
 -   [Chapter #3](Ch-3.md): High-level language-specific optimization using
     pattern rewriting system.
 -   [Chapter #4](Ch-4.md): Writing generic dialect-independent transformations
     with Interfaces. Here we will show how to plug dialect specific information
     into generic transformations like shape inference and inlining.
 -   [Chapter #5](Ch-5.md): Partially lowering to lower-level dialects. We'll
-    convert some our high level language specific semantics towards a generic
+    convert some of our high level language specific semantics towards a generic
     affine oriented dialect for optimization.
 -   [Chapter #6](Ch-6.md): Lowering to LLVM and code generation. Here we'll
     target LLVM IR for code generation, and detail more of the lowering
     framework.
 -   [Chapter #7](Ch-7.md): Extending Toy: Adding support for a composite type.
     We'll demonstrate how to add a custom type to MLIR, and how it fits in the
     existing pipeline.
 

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

 systems. Unregistered operations must be treated conservatively by
 transformations and analyses, and they are much harder to construct
 and manipulate.
 
 This handling can be observed by crafting what should be an invalid IR for Toy
 and seeing it round-trip without tripping the verifier:
 
 ```mlir
-// RUN: toyc %s -emit=mlir
-
 func @main() {
   %0 = "toy.print"() : () -> tensor<2x3xf64>
 }
 ```
 
 There are multiple problems here: the `toy.print` operation is not a terminator;
 it should take an operand; and it shouldn't return any values. In the next
 section, we will register our dialect and operations with MLIR, plug into the

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

matchAndRewrite(TransposeOp op,
     mlir::Value transposeInput = op.getOperand();
     TransposeOp transposeInputOp = transposeInput.getDefiningOp<TransposeOp>();
 
     // Input defined by another transpose? If not, no match.
     if (!transposeInputOp)
       return failure();
 
     // Otherwise, we have a redundant transpose. Use the rewriter.
-    rewriter.replaceOp(op, {transposeInputOp.getOperand()}, {transposeInputOp});
+    rewriter.replaceOp(op, {transposeInputOp.getOperand()});
     return success();
   }
 };
 ```
 
 The implementation of this rewriter is in `ToyCombine.cpp`. The
 [canonicalization pass](../../Canonicalization.md) applies transformations
 defined by operations in a greedy, iterative manner. To ensure that the

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

func @main() {
   affine.for %arg0 = 0 to 3 {
     affine.for %arg1 = 0 to 2 {
       %3 = affine.load %2[%arg1, %arg0] : memref<2x3xf64>
       affine.store %3, %1[%arg0, %arg1] : memref<3x2xf64>
     }
   }
 
   // Multiply and store into the output buffer.
-  affine.for %arg0 = 0 to 2 {
-    affine.for %arg1 = 0 to 3 {
+  affine.for %arg0 = 0 to 3 {
+    affine.for %arg1 = 0 to 2 {
       %3 = affine.load %1[%arg0, %arg1] : memref<3x2xf64>
       %4 = affine.load %1[%arg0, %arg1] : memref<3x2xf64>
       %5 = mulf %3, %4 : f64
       affine.store %5, %0[%arg0, %arg1] : memref<3x2xf64>
     }
   }
 
   // Print the value held by the buffer.

mlir/examples/toy/Ch1/parser/AST.cpp

void ASTDumper::dump(const VarType &type) {
   llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
-  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
+  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "\n";
   indent();
   llvm::errs() << "Params: [";
   llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.

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

def GenericCallOp : Toy_Op<"generic_call"> {
 
   // The generic call operation takes a symbol reference attribute as the
   // callee, and inputs for the call.
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<F64Tensor>:$inputs);
 
   // The generic call operation returns a single value of TensorType.
   let results = (outs F64Tensor);
 
-  // The return operation only emits the input in the format if it is present.
+  // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, "
               "StringRef callee, ArrayRef<Value> arguments">

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

static mlir::LogicalResult verify(ReturnOp op) {
   auto inputType = *op.operand_type_begin();
   auto resultType = results.front();
 
   // Check that the result type of the function matches the operand type.
   if (inputType == resultType || inputType.isa<mlir::UnrankedTensorType>() ||
       resultType.isa<mlir::UnrankedTensorType>())
     return mlir::success();
 
-  return op.emitError() << "type of return operand ("
-                        << *op.operand_type_begin()
+  return op.emitError() << "type of return operand (" << inputType
                         << ") doesn't match function result type ("
-                        << results.front() << ")";
+                        << resultType << ")";
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 
 void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                         mlir::Value value) {
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));

mlir/examples/toy/Ch2/parser/AST.cpp

void ASTDumper::dump(const VarType &type) {
   llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
-  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
+  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "\n";
   indent();
   llvm::errs() << "Params: [";
   llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.

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

def GenericCallOp : Toy_Op<"generic_call"> {
 
   // The generic call operation takes a symbol reference attribute as the
   // callee, and inputs for the call.
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<F64Tensor>:$inputs);
 
   // The generic call operation returns a single value of TensorType.
   let results = (outs F64Tensor);
 
-  // The return operation only emits the input in the format if it is present.
+  // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, "
               "StringRef callee, ArrayRef<Value> arguments">

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

static mlir::LogicalResult verify(ReturnOp op) {
   auto inputType = *op.operand_type_begin();
   auto resultType = results.front();
 
   // Check that the result type of the function matches the operand type.
   if (inputType == resultType || inputType.isa<mlir::UnrankedTensorType>() ||
       resultType.isa<mlir::UnrankedTensorType>())
     return mlir::success();
 
-  return op.emitError() << "type of return operand ("
-                        << *op.operand_type_begin()
+  return op.emitError() << "type of return operand (" << inputType
                         << ") doesn't match function result type ("
-                        << results.front() << ")";
+                        << resultType << ")";
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 
 void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                         mlir::Value value) {
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));

mlir/examples/toy/Ch3/parser/AST.cpp

void ASTDumper::dump(const VarType &type) {
   llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
-  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
+  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "\n";
   indent();
   llvm::errs() << "Params: [";
   llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.

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

def GenericCallOp : Toy_Op<"generic_call",
 
   // The generic call operation takes a symbol reference attribute as the
   // callee, and inputs for the call.
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<F64Tensor>:$inputs);
 
   // The generic call operation returns a single value of TensorType.
   let results = (outs F64Tensor);
 
-  // The return operation only emits the input in the format if it is present.
+  // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, "
               "StringRef callee, ArrayRef<Value> arguments">

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

static mlir::LogicalResult verify(ReturnOp op) {
   auto inputType = *op.operand_type_begin();
   auto resultType = results.front();
 
   // Check that the result type of the function matches the operand type.
   if (inputType == resultType || inputType.isa<mlir::UnrankedTensorType>() ||
       resultType.isa<mlir::UnrankedTensorType>())
     return mlir::success();
 
-  return op.emitError() << "type of return operand ("
-                        << *op.operand_type_begin()
+  return op.emitError() << "type of return operand (" << inputType
                         << ") doesn't match function result type ("
-                        << results.front() << ")";
+                        << resultType << ")";
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 
 void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                         mlir::Value value) {
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));

mlir/examples/toy/Ch4/parser/AST.cpp

void ASTDumper::dump(const VarType &type) {
   llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
-  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
+  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "\n";
   indent();
   llvm::errs() << "Params: [";
   llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.

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

def GenericCallOp : Toy_Op<"generic_call",
 
   // The generic call operation takes a symbol reference attribute as the
   // callee, and inputs for the call.
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<F64Tensor>:$inputs);
 
   // The generic call operation returns a single value of TensorType.
   let results = (outs F64Tensor);
 
-  // The return operation only emits the input in the format if it is present.
+  // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, "
               "StringRef callee, ArrayRef<Value> arguments">

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

static mlir::LogicalResult verify(ReturnOp op) {
   auto inputType = *op.operand_type_begin();
   auto resultType = results.front();
 
   // Check that the result type of the function matches the operand type.
   if (inputType == resultType || inputType.isa<mlir::UnrankedTensorType>() ||
       resultType.isa<mlir::UnrankedTensorType>())
     return mlir::success();
 
-  return op.emitError() << "type of return operand ("
-                        << *op.operand_type_begin()
+  return op.emitError() << "type of return operand (" << inputType
                         << ") doesn't match function result type ("
-                        << results.front() << ")";
+                        << resultType << ")";
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 
 void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                         mlir::Value value) {
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));

mlir/examples/toy/Ch5/parser/AST.cpp

void ASTDumper::dump(const VarType &type) {
   llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
-  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
+  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "\n";
   indent();
   llvm::errs() << "Params: [";
   llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.

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

def GenericCallOp : Toy_Op<"generic_call",
 
   // The generic call operation takes a symbol reference attribute as the
   // callee, and inputs for the call.
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<F64Tensor>:$inputs);
 
   // The generic call operation returns a single value of TensorType.
   let results = (outs F64Tensor);
 
-  // The return operation only emits the input in the format if it is present.
+  // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, "
               "StringRef callee, ArrayRef<Value> arguments">

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

static mlir::LogicalResult verify(ReturnOp op) {
   auto inputType = *op.operand_type_begin();
   auto resultType = results.front();
 
   // Check that the result type of the function matches the operand type.
   if (inputType == resultType || inputType.isa<mlir::UnrankedTensorType>() ||
       resultType.isa<mlir::UnrankedTensorType>())
     return mlir::success();
 
-  return op.emitError() << "type of return operand ("
-                        << *op.operand_type_begin()
+  return op.emitError() << "type of return operand (" << inputType
                         << ") doesn't match function result type ("
-                        << results.front() << ")";
+                        << resultType << ")";
 }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 
 void TransposeOp::build(mlir::OpBuilder &builder, mlir::OperationState &state,
                         mlir::Value value) {
   state.addTypes(UnrankedTensorType::get(builder.getF64Type()));

mlir/examples/toy/Ch6/parser/AST.cpp

void ASTDumper::dump(const VarType &type) {
   llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
-  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
+  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "\n";
   indent();
   llvm::errs() << "Params: [";
   llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.

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

def GenericCallOp : Toy_Op<"generic_call",
   // The generic call operation takes a symbol reference attribute as the
   // callee, and inputs for the call.
   let arguments = (ins FlatSymbolRefAttr:$callee, Variadic<Toy_Type>:$inputs);
 
   // The generic call operation returns a single value of TensorType or
   // StructType.
   let results = (outs Toy_Type);
 
-  // The return operation only emits the input in the format if it is present.
+  // Specialize assembly printing and parsing using a declarative format.
   let assemblyFormat = [{
     $callee `(` $inputs `)` attr-dict `:` functional-type($inputs, results)
   }];
 
   // Add custom build methods for the generic call operation.
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &state, "
               "StringRef callee, ArrayRef<Value> arguments">

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

static mlir::LogicalResult verify(ReturnOp op) {
   auto inputType = *op.operand_type_begin();
   auto resultType = results.front();
 
   // Check that the result type of the function matches the operand type.
   if (inputType == resultType || inputType.isa<mlir::UnrankedTensorType>() ||
       resultType.isa<mlir::UnrankedTensorType>())
     return mlir::success();
 
-  return op.emitError() << "type of return operand ("
-                        << *op.operand_type_begin()
+  return op.emitError() << "type of return operand (" << inputType
                         << ") doesn't match function result type ("
-                        << results.front() << ")";
+                        << resultType << ")";
 }
 
 //===----------------------------------------------------------------------===//
 // StructAccessOp
 
 void StructAccessOp::build(mlir::OpBuilder &b, mlir::OperationState &state,
                            mlir::Value input, size_t index) {
   // Extract the result type from the input type.

mlir/examples/toy/Ch7/parser/AST.cpp

else
     llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
-  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
+  llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "\n";
   indent();
   llvm::errs() << "Params: [";
   llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.

mlir/include/mlir/ExecutionEngine/OptUtils.h

 namespace llvm {
 class Module;
 class Error;
 class TargetMachine;
 } // namespace llvm
 
 namespace mlir {
 
-/// Initialize LLVM passes that can be when running MLIR code using
+/// Initialize LLVM passes that can be used when running MLIR code using
 /// ExecutionEngine.
 void initializeLLVMPasses();
 
 /// Create a module transformer function for MLIR ExecutionEngine that runs
 /// LLVM IR passes corresponding to the given speed and size optimization
 /// levels (e.g. -O2 or -Os). If not null, `targetMachine` is used to
 /// initialize passes that provide target-specific information to the LLVM
 /// optimizer. `targetMachine` must outlive the returned std::function.

mlir/test/Examples/Toy/Ch1/ast.toy

def main() {
   # Finally, calling into `multiply_transpose` with incompatible shape will
   # trigger a shape inference error.
   var f = multiply_transpose(transpose(a), c);
 }
 
 
 # CHECK: Module:
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1'
+# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
 # CHECK-NEXT:       Params: [a, b]
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         Return
 # CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
 # CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
 # CHECK-NEXT:             ]
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
 # CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
 # CHECK-NEXT:             ]
 # CHECK-NEXT:       } // Block
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1'
+# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
 # CHECK-NEXT:       Params: []
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
 # CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
 # CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
 # CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
 # CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
 # CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11

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

def main() {
   # Finally, calling into `multiply_transpose` with incompatible shape will
   # trigger a shape inference error.
   var f = multiply_transpose(transpose(a), c);
 }
 
 
 # CHECK: Module:
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1'
+# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
 # CHECK-NEXT:       Params: [a, b]
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         Return
 # CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
 # CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
 # CHECK-NEXT:             ]
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
 # CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
 # CHECK-NEXT:             ]
 # CHECK-NEXT:       } // Block
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1'
+# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
 # CHECK-NEXT:       Params: []
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
 # CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
 # CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
 # CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
 # CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
 # CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11

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

def main() {
   # Finally, calling into `multiply_transpose` with incompatible shape will
   # trigger a shape inference error.
   var f = multiply_transpose(transpose(a), c);
 }
 
 
 # CHECK: Module:
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1'
+# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
 # CHECK-NEXT:       Params: [a, b]
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         Return
 # CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
 # CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
 # CHECK-NEXT:             ]
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
 # CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
 # CHECK-NEXT:             ]
 # CHECK-NEXT:       } // Block
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1'
+# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
 # CHECK-NEXT:       Params: []
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
 # CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
 # CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
 # CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
 # CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
 # CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11

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

def main() {
   # Finally, calling into `multiply_transpose` with incompatible shape will
   # trigger a shape inference error.
   var f = multiply_transpose(transpose(a), c);
 }
 
 
 # CHECK: Module:
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1'
+# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
 # CHECK-NEXT:       Params: [a, b]
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         Return
 # CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
 # CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
 # CHECK-NEXT:             ]
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
 # CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
 # CHECK-NEXT:             ]
 # CHECK-NEXT:       } // Block
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1'
+# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
 # CHECK-NEXT:       Params: []
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
 # CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
 # CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
 # CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
 # CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
 # CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11

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

def main() {
   # Finally, calling into `multiply_transpose` with incompatible shape will
   # trigger a shape inference error.
   var f = multiply_transpose(transpose(a), c);
 }
 
 
 # CHECK: Module:
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1'
+# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
 # CHECK-NEXT:       Params: [a, b]
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         Return
 # CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
 # CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
 # CHECK-NEXT:             ]
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
 # CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
 # CHECK-NEXT:             ]
 # CHECK-NEXT:       } // Block
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1'
+# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
 # CHECK-NEXT:       Params: []
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
 # CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
 # CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
 # CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
 # CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
 # CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11

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

def main() {
   # Finally, calling into `multiply_transpose` with incompatible shape will
   # trigger a shape inference error.
   var f = multiply_transpose(transpose(a), c);
 }
 
 
 # CHECK: Module:
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1'
+# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
 # CHECK-NEXT:       Params: [a, b]
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         Return
 # CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
 # CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
 # CHECK-NEXT:             ]
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
 # CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
 # CHECK-NEXT:             ]
 # CHECK-NEXT:       } // Block
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1'
+# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
 # CHECK-NEXT:       Params: []
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
 # CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
 # CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
 # CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
 # CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
 # CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11

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

def main() {
   # Finally, calling into `multiply_transpose` with incompatible shape will
   # trigger a shape inference error.
   var f = multiply_transpose(transpose(a), c);
 }
 
 
 # CHECK: Module:
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1'
+# CHECK-NEXT:       Proto 'multiply_transpose' @{{.*}}ast.toy:4:1
 # CHECK-NEXT:       Params: [a, b]
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         Return
 # CHECK-NEXT:           BinOp: * @{{.*}}ast.toy:5:25
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:10
 # CHECK-NEXT:               var: a @{{.*}}ast.toy:5:20
 # CHECK-NEXT:             ]
 # CHECK-NEXT:             Call 'transpose' [ @{{.*}}ast.toy:5:25
 # CHECK-NEXT:               var: b @{{.*}}ast.toy:5:35
 # CHECK-NEXT:             ]
 # CHECK-NEXT:       } // Block
 # CHECK-NEXT:     Function
-# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1'
+# CHECK-NEXT:       Proto 'main' @{{.*}}ast.toy:8:1
 # CHECK-NEXT:       Params: []
 # CHECK-NEXT:       Block {
 # CHECK-NEXT:         VarDecl a<> @{{.*}}ast.toy:11:3
 # CHECK-NEXT:           Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}ast.toy:11:11
 # CHECK-NEXT:         VarDecl b<2, 3> @{{.*}}ast.toy:15:3
 # CHECK-NEXT:           Literal: <6>[ 1.000000e+00, 2.000000e+00, 3.000000e+00, 4.000000e+00, 5.000000e+00, 6.000000e+00] @{{.*}}ast.toy:15:17
 # CHECK-NEXT:         VarDecl c<> @{{.*}}ast.toy:19:3
 # CHECK-NEXT:           Call 'multiply_transpose' [ @{{.*}}ast.toy:19:11

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

 
 # CHECK:  Module:
 # CHECK-NEXT:    Struct: Struct @{{.*}}struct-ast.toy:3:1
 # CHECK-NEXT:  Variables: [
 # CHECK-NEXT:    VarDecl a<> @{{.*}}struct-ast.toy:4:3
 # CHECK-NEXT:    VarDecl b<> @{{.*}}struct-ast.toy:5:3
 # CHECK-NEXT:  ]
 # CHECK-NEXT:Function
-# CHECK-NEXT:  Proto 'multiply_transpose' @{{.*}}struct-ast.toy:9:1'
+# CHECK-NEXT:  Proto 'multiply_transpose' @{{.*}}struct-ast.toy:9:1
 # CHECK-NEXT:  Params: [value]
 # CHECK-NEXT:  Block {
 # CHECK-NEXT:    Return
 # CHECK-NEXT:      BinOp: * @{{.*}}struct-ast.toy:11:31
 # CHECK-NEXT:        Call 'transpose' [ @{{.*}}struct-ast.toy:11:10
 # CHECK-NEXT:          BinOp: . @{{.*}}struct-ast.toy:11:26
 # CHECK-NEXT:            var: value @{{.*}}struct-ast.toy:11:20
 # CHECK-NEXT:            var: a @{{.*}}struct-ast.toy:11:26
 # CHECK-NEXT:        ]
 # CHECK-NEXT:        Call 'transpose' [ @{{.*}}struct-ast.toy:11:31
 # CHECK-NEXT:          BinOp: . @{{.*}}struct-ast.toy:11:47
 # CHECK-NEXT:            var: value @{{.*}}struct-ast.toy:11:41
 # CHECK-NEXT:            var: b @{{.*}}struct-ast.toy:11:47
 # CHECK-NEXT:        ]
 # CHECK-NEXT:  }
 # CHECK-NEXT:Function
-# CHECK-NEXT:  Proto 'main' @{{.*}}struct-ast.toy:14:1'
+# CHECK-NEXT:  Proto 'main' @{{.*}}struct-ast.toy:14:1
 # CHECK-NEXT:  Params: []
 # CHECK-NEXT:  Block {
 # CHECK-NEXT:    VarDecl value<Struct> @{{.*}}struct-ast.toy:16:3
 # CHECK-NEXT:      Struct Literal:             Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}struct-ast.toy:16:19
 # CHECK-NEXT:        Literal: <2, 3>[ <3>[ 1.000000e+00, 2.000000e+00, 3.000000e+00], <3>[ 4.000000e+00, 5.000000e+00, 6.000000e+00]] @{{.*}}struct-ast.toy:16:43
 # CHECK-NEXT:       @{{.*}}struct-ast.toy:16:18
 # CHECK-NEXT:    VarDecl c<> @{{.*}}struct-ast.toy:19:3
 # CHECK-NEXT:      Call 'multiply_transpose' [ @{{.*}}struct-ast.toy:19:11
 # CHECK-NEXT:        var: value @{{.*}}struct-ast.toy:19:30
 # CHECK-NEXT:      ]
 # CHECK-NEXT:    Print [ @{{.*}}struct-ast.toy:20:3
 # CHECK-NEXT:      var: c @{{.*}}struct-ast.toy:20:9
 # CHECK-NEXT:    ]
 # CHECK-NEXT:  }
 No newline at end of file