[mlir][IR] Remove references to BuiltinOps from IR/

[rriddle]

Summary

There isn't a good reason for anything within IR to specifically reference any of the builtin operations. The only place that had a good reason in the past was AsmPrinter, but the behavior there doesn't need to hardcode ModuleOp anymore.

[mehdi_amini]

Nice cleanup!

mlir/include/mlir/IR/Builders.h

 #define MLIR_IR_BUILDERS_H
 
 #include "mlir/IR/OpDefinition.h"
 
 namespace mlir {
 
 class AffineExpr;
 class BlockAndValueMapping;
-class ModuleOp;
 class UnknownLoc;
 class FileLineColLoc;
 class Type;
 class PrimitiveType;
 class IntegerType;
 class FunctionType;
 class MemRefType;
 class VectorType;

 class AffineMap;
 class UnitAttr;
 
 /// This class is a general helper class for creating context-global objects
 /// like types, attributes, and affine expressions.
 class Builder {
 public:
   explicit Builder(MLIRContext *context) : context(context) {}
-  explicit Builder(ModuleOp module);
+  explicit Builder(Operation *op) : Builder(op->getContext()) {}
 
   MLIRContext *getContext() const { return context; }
 
   Identifier getIdentifier(StringRef str);
 
   // Locations.
   Location getUnknownLoc();
   Location getFileLineColLoc(Identifier filename, unsigned line,

mlir/include/mlir/IR/BuiltinOps.td

]> {
   let builders = [OpBuilderDAG<(ins CArg<"Optional<StringRef>", "{}">:$name)>];
   let extraClassDeclaration = [{
     /// Construct a module from the given location with an optional name.
     static ModuleOp create(Location loc, Optional<StringRef> name = llvm::None);
 
     /// Return the name of this module if present.
     Optional<StringRef> getName() { return sym_name(); }
 
-    /// Print this module in the custom top-level form.
-    void print(raw_ostream &os, OpPrintingFlags flags = llvm::None);
-    void print(raw_ostream &os, AsmState &state,
-               OpPrintingFlags flags = llvm::None);
-    void dump();
-
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
     /// A ModuleOp may optionally define a symbol.
     bool isOptionalSymbol() { return true; }
   }];
   let verifier = [{ return ::verify(*this); }];

mlir/include/mlir/IR/MLIRContext.h

 class DiagnosticEngine;
 class Dialect;
 class DialectRegistry;
 class InFlightDiagnostic;
 class Location;
 class MLIRContextImpl;
 class StorageUniquer;
 
-/// MLIRContext is the top-level object for a collection of MLIR modules.  It
+/// MLIRContext is the top-level object for a collection of MLIR operations. It
 /// holds immortal uniqued objects like types, and the tables used to unique
 /// them.
 ///
 /// MLIRContext gets a redundant "MLIR" prefix because otherwise it ends up with
 /// a very generic name ("Context") and because it is uncommon for clients to
 /// interact with it.
 ///
 class MLIRContext {

mlir/lib/Conversion/PDLToPDLInterp/PredicateTree.h

 #ifndef MLIR_LIB_CONVERSION_PDLTOPDLINTERP_PREDICATETREE_H_
 #define MLIR_LIB_CONVERSION_PDLTOPDLINTERP_PREDICATETREE_H_
 
 #include "Predicate.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "llvm/ADT/MapVector.h"
 
 namespace mlir {
+class ModuleOp;
+
 namespace pdl_to_pdl_interp {
 
 class MatcherNode;
 
 /// A PositionalPredicate is a predicate that is associated with a specific
 /// positional value.
 struct PositionalPredicate {
   PositionalPredicate(Position *pos,

mlir/lib/IR/AsmPrinter.cpp

 // the various print() methods on the core IR objects.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/AsmState.h"
 #include "mlir/IR/Attributes.h"
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/ADT/APFloat.h"

 namespace {
 /// This class contains the logic for printing operations, regions, and blocks.
 class OperationPrinter : public ModulePrinter, private OpAsmPrinter {
 public:
   explicit OperationPrinter(raw_ostream &os, OpPrintingFlags flags,
                             AsmStateImpl &state)
       : ModulePrinter(os, flags, &state) {}
 
-  /// Print the given top-level module.
-  void print(ModuleOp op);
+  /// Print the given top-level operation.
+  void printTopLevelOperation(Operation *op);
+
   /// Print the given operation with its indent and location.
   void print(Operation *op);
   /// Print the bare location, not including indentation/location/etc.
   void printOperation(Operation *op);
   /// Print the given operation in the generic form.
   void printGenericOp(Operation *op) override;
 
   /// Print the name of the given block.
private:
   /// The number of spaces used for indenting nested operations.
   const static unsigned indentWidth = 2;
 
   // This is the current indentation level for nested structures.
   unsigned currentIndent = 0;
 };
 } // end anonymous namespace
 
-void OperationPrinter::print(ModuleOp op) {
+void OperationPrinter::printTopLevelOperation(Operation *op) {
   // Output the aliases at the top level that can't be deferred.
   state->getAliasState().printNonDeferredAliases(os, newLine);
 
   // Print the module.
-  print(op.getOperation());
+  print(op);
   os << newLine;
 
   // Output the aliases at the top level that can be deferred.
   state->getAliasState().printDeferredAliases(os, newLine);
 }
 
 void OperationPrinter::print(Operation *op) {
   // Track the location of this operation.
void Value::printAsOperand(raw_ostream &os, AsmState &state) {
   // Currently, region arguments can be shadowed when printing the main
   // operation. If the IR hasn't been printed, this will produce the old SSA
   // name and not the shadowed name.
   state.getImpl().getSSANameState().printValueID(*this, /*printResultNo=*/true,
                                                  os);
 }
 
 void Operation::print(raw_ostream &os, OpPrintingFlags flags) {
+  // If this is a top level operation, we also print aliases.
+  if (!getParent() && !flags.shouldUseLocalScope()) {
+    AsmState state(this);
+    state.getImpl().initializeAliases(this, flags);
+    print(os, state, flags);
+    return;
+  }
+
   // Find the operation to number from based upon the provided flags.
   Operation *printedOp = this;
   bool shouldUseLocalScope = flags.shouldUseLocalScope();
   do {
     // If we are printing local scope, stop at the first operation that is
     // isolated from above.
     if (shouldUseLocalScope && printedOp->isKnownIsolatedFromAbove())
       break;
 
     // Otherwise, traverse up to the next parent.
     Operation *parentOp = printedOp->getParentOp();
     if (!parentOp)
       break;
     printedOp = parentOp;
   } while (true);
 
   AsmState state(printedOp);
   print(os, state, flags);
 }
 void Operation::print(raw_ostream &os, AsmState &state, OpPrintingFlags flags) {
-  OperationPrinter(os, flags, state.getImpl()).print(this);
+  OperationPrinter printer(os, flags, state.getImpl());
+  if (!getParent() && !flags.shouldUseLocalScope())
+    printer.printTopLevelOperation(this);
+  else
+    printer.print(this);
 }
 
 void Operation::dump() {
   print(llvm::errs(), OpPrintingFlags().useLocalScope());
   llvm::errs() << "\n";
 }
 
 void Block::print(raw_ostream &os) {
void Block::printAsOperand(raw_ostream &os, bool printType) {
   }
   AsmState state(parentOp);
   printAsOperand(os, state);
 }
 void Block::printAsOperand(raw_ostream &os, AsmState &state) {
   OperationPrinter printer(os, /*flags=*/llvm::None, state.getImpl());
   printer.printBlockName(this);
 }
-
-void ModuleOp::print(raw_ostream &os, OpPrintingFlags flags) {
-  AsmState state(*this);
-
-  // Don't populate aliases when printing at local scope.
-  if (!flags.shouldUseLocalScope())
-    state.getImpl().initializeAliases(*this, flags);
-  print(os, state, flags);
-}
-void ModuleOp::print(raw_ostream &os, AsmState &state, OpPrintingFlags flags) {
-  OperationPrinter(os, flags, state.getImpl()).print(*this);
-}
-
-void ModuleOp::dump() { print(llvm::errs()); }

mlir/lib/IR/Attributes.cpp

 //===- Attributes.cpp - MLIR Affine Expr Classes --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Attributes.h"
 #include "AttributeDetail.h"
 #include "mlir/IR/AffineMap.h"
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/DecodeAttributesInterfaces.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Endian.h"

mlir/lib/IR/Builders.cpp

 //===- Builders.cpp - Helpers for constructing MLIR Classes ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/BlockAndValueMapping.h"
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/StandardTypes.h"
-#include "llvm/Support/raw_ostream.h"
-using namespace mlir;
+#include "mlir/IR/SymbolTable.h"
 
-Builder::Builder(ModuleOp module) : context(module.getContext()) {}
+using namespace mlir;
 
 Identifier Builder::getIdentifier(StringRef str) {
   return Identifier::get(str, context);
 }
 
 //===----------------------------------------------------------------------===//
 // Locations.
 //===----------------------------------------------------------------------===//

mlir/lib/IR/MLIRContext.cpp

 #include "AttributeDetail.h"
 #include "IntegerSetDetail.h"
 #include "LocationDetail.h"
 #include "TypeDetail.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinDialect.h"
-#include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/IntegerSet.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Support/ThreadLocalCache.h"

mlir/test/EDSC/builder-api-test.cpp

TEST_FUNC(builder_dynamic_for_func_args) {
   // CHECK-DAG:    [[rf4:%[0-9]+]] = mulf {{.*}}, {{.*}} : f32
   //     CHECK:    {{.*}} = subf [[rf3]], [[rf4]] : f32
   // CHECK-DAG:    [[ri1:%[0-9]+]] = addi {{.*}}, {{.*}} : i32
   // CHECK-DAG:    [[ri2:%[0-9]+]] = divi_signed [[ri1]], {{.*}} : i32
   // CHECK-DAG:    [[ri3:%[0-9]+]] = remi_signed [[ri2]], {{.*}} : i32
   // CHECK-DAG:    [[ri4:%[0-9]+]] = muli {{.*}}, {{.*}} : i32
   //     CHECK:    {{.*}} = subi [[ri3]], [[ri4]] : i32
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_dynamic_for) {
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_dynamic_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   Value i, a(f.getArgument(0)), b(f.getArgument(1)), c(f.getArgument(2)),
       d(f.getArgument(3));
   using namespace edsc::op;
   affineLoopBuilder(a - b, c + d, 2);
 
   // clang-format off
   // CHECK-LABEL: func @builder_dynamic_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
   // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-NEXT:   affine.for %{{.*}} = affine_map<(d0) -> (d0)>([[r0]]) to affine_map<(d0) -> (d0)>([[r1]]) step 2 {
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_loop_for) {
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_loop_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   Value a(f.getArgument(0)), b(f.getArgument(1)), c(f.getArgument(2)),
       d(f.getArgument(3));
   using namespace edsc::op;
   loopNestBuilder(a - b, c + d, a);
 
   // clang-format off
   // CHECK-LABEL: func @builder_loop_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
   // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-NEXT:   scf.for %{{.*}} = [[r0]] to [[r1]] step {{.*}} {
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_max_min_for) {
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_max_min_for", {},
                         {indexType, indexType, indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   Value lb1(f.getArgument(0)), lb2(f.getArgument(1)), ub1(f.getArgument(2)),
       ub2(f.getArgument(3));
   affineLoopBuilder({lb1, lb2}, {ub1, ub2}, 1);
   std_ret();
 
   // clang-format off
   // CHECK-LABEL: func @builder_max_min_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
   // CHECK:  affine.for %{{.*}} = max affine_map<(d0, d1) -> (d0, d1)>(%{{.*}}, %{{.*}}) to min affine_map<(d0, d1) -> (d0, d1)>(%{{.*}}, %{{.*}}) {
   // CHECK:  return
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_affine_for_iter_args) {
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("builder_affine_for_iter_args", {},
                         {indexType, indexType, indexType});
 
TEST_FUNC(builder_affine_for_iter_args) {
   // CHECK:       (%[[lb_1:.*]]: index, %[[ub_1:.*]]: index, %[[ub_2:.*]]: index) {
   // CHECK-NEXT:    %[[c32:.*]] = constant 32 : i32
   // CHECK-NEXT:    %[[c42:.*]] = constant 42 : i32
   // CHECK-NEXT:    %{{.*}} = affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to min affine_map<(d0, d1) -> (d0, d1)>(%[[ub_1]], %[[ub_2]]) step 2 iter_args(%[[iarg_1:.*]] = %[[c32]], %[[iarg_2:.*]] = %[[c42]]) -> (i32, i32) {
   // CHECK-NEXT:      %[[sum:.*]] = addi %[[iarg_1]], %[[iarg_2]] : i32
   // CHECK-NEXT:      affine.yield %[[iarg_2]], %[[sum]] : i32, i32
   // CHECK-NEXT:    }
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_block_append) {
   using namespace edsc::op;
   auto f = makeFunction("builder_blocks");
 
   OpBuilder builder(f.getBody());
TEST_FUNC(builder_block_append) {
   // CHECK-LABEL: @builder_blocks
   // CHECK-NEXT:   br ^bb1
   // CHECK-NEXT: ^bb1: // pred: ^bb0
   // CHECK-NEXT:   constant 0 : index
   // CHECK-NEXT:   constant 1 : index
   // CHECK-NEXT:   return
   // CHECK-NEXT: }
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_blocks) {
   using namespace edsc::op;
   auto f = makeFunction("builder_blocks");
 
   OpBuilder builder(f.getBody());
TEST_FUNC(builder_blocks) {
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: i32):   // 2 preds: ^bb0, ^bb2
   // CHECK-NEXT:   %{{.*}} = addi %{{.*}}, %{{.*}} : i32
   // CHECK-NEXT:   br ^bb2(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: i32):   // pred: ^bb1
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: }
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_cond_branch) {
   auto f = makeFunction("builder_cond_branch", {},
                         {IntegerType::get(1, &globalContext())});
 
   OpBuilder builder(f.getBody());
TEST_FUNC(builder_cond_branch) {
   // CHECK-NEXT:   %{{.*}} = constant 64 : i64
   // CHECK-NEXT:   %{{.*}} = constant 42 : i32
   // CHECK-NEXT:   cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}}, %{{.*}} : i64, i32)
   // CHECK-NEXT: ^bb1(%{{.*}}: i32):   // pred: ^bb0
   // CHECK-NEXT:   return
   // CHECK-NEXT: ^bb2(%{{.*}}: i64, %{{.*}}: i32):  // pred: ^bb0
   // CHECK-NEXT:   return
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_helpers) {
   using namespace edsc::op;
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize,
TEST_FUNC(builder_helpers) {
   // CHECK-NEXT:       affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%{{.*}}) to affine_map<(d0) -> (d0)>(%{{.*}}) {
   //  CHECK-DAG:         [[a:%.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[b:%.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[c:%.*]] = addf [[b]], [[a]] : f32
   //  CHECK-DAG:         [[d:%.*]] = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-DAG:         [[e:%.*]] = addf [[d]], [[c]] : f32
   // CHECK-NEXT:         affine.store [[e]], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(insertion_in_block) {
   using namespace edsc::op;
   auto indexType = IndexType::get(&globalContext());
   auto f = makeFunction("insertion_in_block", {}, {indexType, indexType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   std_constant_int(0, 32);
   buildInNewBlock({}, [&](ValueRange) { std_constant_int(1, 32); });
   std_constant_int(2, 32);
   // clang-format off
   // CHECK-LABEL: @insertion_in_block
   // CHECK: {{.*}} = constant 0 : i32
   // CHECK: {{.*}} = constant 2 : i32
   // CHECK: ^bb1:   // no predecessors
   // CHECK: {{.*}} = constant 1 : i32
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(zero_and_std_sign_extendi_op_i1_to_i8) {
   using namespace edsc::op;
   auto i1Type = IntegerType::get(1, &globalContext());
   auto i8Type = IntegerType::get(8, &globalContext());
   auto memrefType = MemRefType::get({}, i1Type, {}, 0);
   auto f = makeFunction("zero_and_std_sign_extendi_op", {},
                         {memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   AffineIndexedValue A(f.getArgument(0));
   AffineIndexedValue B(f.getArgument(1));
   // clang-format off
   edsc::intrinsics::std_zero_extendi(A, i8Type);
   edsc::intrinsics::std_sign_extendi(B, i8Type);
   // CHECK-LABEL: @zero_and_std_sign_extendi_op
   //      CHECK:     %[[SRC1:.*]] = affine.load
   //      CHECK:     zexti %[[SRC1]] : i1 to i8
   //      CHECK:     %[[SRC2:.*]] = affine.load
   //      CHECK:     sexti %[[SRC2]] : i1 to i8
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(operator_or) {
   auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
   auto f = makeFunction("operator_or", {}, {i1Type, i1Type});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
 
   using op::operator||;
   Value lhs(f.getArgument(0));
   Value rhs(f.getArgument(1));
   lhs || rhs;
 
   // clang-format off
   // CHECK-LABEL: @operator_or
   //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
   //       CHECK: or [[ARG0]], [[ARG1]]
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(operator_and) {
   auto i1Type = IntegerType::get(/*width=*/1, &globalContext());
   auto f = makeFunction("operator_and", {}, {i1Type, i1Type});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
 
   using op::operator&&;
   using op::negate;
   Value lhs(f.getArgument(0));
   Value rhs(f.getArgument(1));
   negate(lhs && rhs);
 
   // clang-format off
   // CHECK-LABEL: @operator_and
   //       CHECK: [[ARG0:%.*]]: i1, [[ARG1:%.*]]: i1
   //       CHECK: [[AND:%.*]] = and [[ARG0]], [[ARG1]]
   //       CHECK: [[TRUE:%.*]] = constant true
   //       CHECK: subi [[TRUE]], [[AND]] : i1
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(divis_op_i32) {
   using namespace edsc::op;
   auto f = makeFunction("divis_op", {}, {});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   auto i32Type = builder.getI32Type();
   std_divis(std_constant_int(10, i32Type), std_constant_int(2, i32Type));
 
   // clang-format off
   // CHECK-LABEL: @divis_op
   //   CHECK-DAG:     {{.*}} = constant 10
   //   CHECK-DAG:     {{.*}} = constant 2
   //  CHECK-NEXT:     {{.*}} = divi_signed
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(diviu_op_i32) {
   using namespace edsc::op;
   auto f = makeFunction("diviu_op", {}, {});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   auto i32Type = builder.getI32Type();
   std_diviu(std_constant_int(10, i32Type), std_constant_int(2, i32Type));
 
   // clang-format off
   // CHECK-LABEL: @diviu_op
   //   CHECK-DAG:     {{.*}} = constant 10
   //   CHECK-DAG:     {{.*}} = constant 2
   //  CHECK-NEXT:     {{.*}} = divi_unsigned
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(fpext_f32_f64) {
   using namespace edsc::op;
   auto f = makeFunction("fpext", {}, {});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   auto f32Type = builder.getF32Type();
   auto f64Type = builder.getF64Type();
   std_fpext(std_constant_float(llvm::APFloat(10.0f), f32Type), f64Type);
 
   // clang-format off
   // CHECK-LABEL: @fpext
   //       CHECK: {{.*}} = constant 1.0
   //  CHECK-NEXT: {{.*}} = fpext
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(fptrunc_f32_bf16) {
   using namespace edsc::op;
   auto f = makeFunction("fptrunc", {}, {});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   auto f32Type = builder.getF32Type();
   auto bf16Type = builder.getBF16Type();
   std_fptrunc(std_constant_float(llvm::APFloat(10.0f), f32Type), bf16Type);
 
   // clang-format off
   // CHECK-LABEL: @fptrunc
   //       CHECK: {{.*}} = constant 1.0
   //  CHECK-NEXT: {{.*}} = fptrunc
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(select_op_i32) {
   using namespace edsc::op;
   auto i32Type = IntegerType::get(32, &globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, i32Type, {}, 0);
TEST_FUNC(select_op_i32) {
   //  CHECK-DAG:     {{.*}} = affine.load
   //  CHECK-DAG:     {{.*}} = affine.load
   // CHECK-NEXT:     {{.*}} = select
   //  CHECK-DAG:     {{.*}} = cmpi "uge"
   //  CHECK-DAG:     {{.*}} = affine.load
   //  CHECK-DAG:     {{.*}} = affine.load
   // CHECK-NEXT:     {{.*}} = select
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(select_op_f32) {
   auto f32Type = FloatType::getF32(&globalContext());
   auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto f = makeFunction("select_op", {}, {memrefType, memrefType});
TEST_FUNC(select_op_f32) {
   //  CHECK-DAG:     cmpf "ogt"
   //  CHECK-DAG:     affine.load
   //  CHECK-DAG:     affine.load
   //  CHECK-DAG:     affine.load
   //  CHECK-DAG:     affine.load
   //  CHECK-DAG:     affine.apply
   // CHECK-NEXT:     select
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // Inject an EDSC-constructed computation to exercise imperfectly nested 2-d
 // tiling.
 TEST_FUNC(tile_2d) {
   auto memrefType =
       MemRefType::get({ShapedType::kDynamicSize, ShapedType::kDynamicSize,
TEST_FUNC(tile_2d) {
   //  CHECK-NEXT:       affine.for %{{.*}} = affine_map<(d0) -> (d0)>(%[[ZERO]]) to affine_map<(d0) -> (d0)>(%[[P]]) {
   //  CHECK-NEXT:         affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 512)>(%{{.*}})[%[[M]]] {
   //  CHECK-NEXT:           affine.for %{{.*}} = max affine_map<(d0) -> (0, d0)>(%{{.*}}) to min affine_map<(d0)[s0] -> (s0, d0 + 1024)>(%{{.*}})[%[[N]]] {
   //  CHECK-NEXT:             {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-NEXT:             {{.*}} = affine.load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   //  CHECK-NEXT:             {{.*}}= addf {{.*}}, {{.*}} : f32
   //  CHECK-NEXT:             affine.store {{.*}}, {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // Exercise StdIndexedValue for loads and stores.
 TEST_FUNC(indirect_access) {
   using namespace edsc::op;
   auto memrefType = MemRefType::get({ShapedType::kDynamicSize},
                                     FloatType::getF32(&globalContext()), {}, 0);
TEST_FUNC(indirect_access) {
   // clang-format off
   // CHECK-LABEL: func @indirect_access
   // CHECK-SAME: (%[[ARG0:.*]]: memref<?xf32>, %[[ARG1:.*]]: memref<?xf32>, %[[ARG2:.*]]: memref<?xf32>, %[[ARG3:.*]]: memref<?xf32>)
   // CHECK-DAG:  [[B:%.*]] = affine.load %[[ARG1]]
   // CHECK-DAG:  [[D:%.*]] = affine.load %[[ARG3]]
   // CHECK:  load %{{.*}}{{\[}}[[B]]{{\]}}
   // CHECK:  store %{{.*}}, %{{.*}}{{\[}}[[D]]{{\]}}
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // Exercise affine loads and stores build with empty maps.
 TEST_FUNC(empty_map_load_store) {
   using namespace edsc::op;
   auto memrefType =
       MemRefType::get({}, FloatType::getF32(&globalContext()), {}, 0);
TEST_FUNC(empty_map_load_store) {
   });
   // clang-format on
 
   // clang-format off
   // CHECK-LABEL: func @empty_map_load_store(
   // CHECK:  [[A:%.*]] = affine.load %{{.*}}[]
   // CHECK:  affine.store [[A]], %{{.*}}[]
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @affine_if_op
 // CHECK:       affine.if affine_set<([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
 // CHECK-NOT:   else
 // CHECK:       affine.if affine_set<([[d0:.*]], [[d1:.*]]){{\[}}[[s0:.*]], [[s1:.*]]{{\]}}
SmallVector<AffineExpr, 4> affineExprs = {
       builder.getAffineSymbolExpr(1)  // s1 >= 0
   };
   auto intSet = IntegerSet::get(2, 2, affineExprs, isEq);
 
   SmallVector<Value, 4> affineIfArgs = {zero, zero, ten, ten};
   intrinsics::affine_if(intSet, affineIfArgs, /*withElseRegion=*/false);
   intrinsics::affine_if(intSet, affineIfArgs, /*withElseRegion=*/true);
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_generic_pointwise
 //       CHECK:   linalg.generic {
 // CHECK-SAME: indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel"]}
TEST_FUNC(linalg_generic_pointwise_test) {
   Value A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
   AffineExpr i, j;
   bindDims(&globalContext(), i, j);
   StructuredIndexed SA(A), SB(B), SC(C);
   linalg_generic_pointwise_add(SA({i, j}), SB({i, j}), SC({i, j}));
   linalg_generic_pointwise_max(SA({i, j}), SB({i, j}), SC({i, j}));
   linalg_generic_pointwise_tanh(SA({i, j}), SC({i, j}));
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_generic_matmul
 //       CHECK:   linalg.generic {
 // CHECK-SAME: indexing_maps = [affine_map<(d0, d1, d2) -> (d0, d2)>, affine_map<(d0, d1, d2) -> (d2, d1)>, affine_map<(d0, d1, d2) -> (d0, d1)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel", "reduction"]}
auto memrefType = MemRefType::get(
       {ShapedType::kDynamicSize, ShapedType::kDynamicSize}, f32Type, {}, 0);
   auto f = makeFunction("linalg_generic_matmul", {},
                         {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   linalg_generic_matmul(f.getArguments());
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_generic_conv_nhwc
 //       CHECK:   linalg.generic {
 // CHECK-SAME: indexing_maps = [affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d2 * 3 + d4 * 5, d3 * 4 + d5 * 6, d6)>,
 // CHECK-SAME: affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d4, d5, d6, d1)>,
TEST_FUNC(linalg_generic_conv_nhwc) {
   auto f = makeFunction("linalg_generic_conv_nhwc", {},
                         {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   linalg_generic_conv_nhwc(f.getArguments(),
                            /*strides=*/{3, 4}, /*dilations=*/{5, 6});
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_generic_dilated_conv_nhwc
 //       CHECK:   linalg.generic {
 // CHECK-SAME: indexing_maps = [affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d3 * 3 + d5 * 5, d4 * 4 + d6 * 6, d2)>,
 // CHECK-SAME: affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d5, d6, d2, d1)>,
auto f = makeFunction("linalg_generic_dilated_conv_nhwc", {},
                         {memrefType, memrefType, memrefType});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   linalg_generic_dilated_conv_nhwc(f.getArguments(),
                                    /*depth_multiplier=*/7,
                                    /*strides=*/{3, 4}, /*dilations=*/{5, 6});
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_metadata_ops
 //       CHECK: linalg.reshape {{.*}} [affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>] : memref<4x8x16xf32> into memref<32x16xf32>
 //       CHECK: linalg.reshape {{.*}} [affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>] : memref<32x16xf32> into memref<4x8x16xf32>
 // clang-format on
TEST_FUNC(linalg_metadata_ops) {
   AffineExpr i, j, k;
   bindDims(&globalContext(), i, j, k);
   Value v(f.getArgument(0));
   SmallVector<ReassociationExprs, 2> maps = {ReassociationExprs({i, j}),
                                              ReassociationExprs({k})};
   auto reshaped = linalg_reshape(v, maps);
   linalg_reshape(memrefType, reshaped, maps);
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @linalg_tensors
 //       CHECK:   linalg.generic {
 // CHECK-SAME: indexing_maps = [affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>, affine_map<(d0, d1) -> (d0, d1)>],
 // CHECK-SAME: iterator_types = ["parallel", "parallel"]}
Value maxed = linalg_generic_pointwise_max(
                     SA({i, j}), StructuredIndexed(added)({i, j}), SC({i, j}))
                     ->getResult(0);
   Value tanhed = linalg_generic_pointwise_tanh(StructuredIndexed(maxed)({i, j}),
                                                SC({i, j}))
                      ->getResult(0);
   Value o1 = linalg_generic_matmul(A, B, tanhed, tensorType)->getResult(0);
   linalg_generic_matmul(A, B, o1, tensorType);
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(vector_extractelement_op_i32) {
   using namespace edsc::op;
   auto f = makeFunction("vector_extractelement_op", {}, {});
 
   OpBuilder builder(f.getBody());
   ScopedContext scope(builder, f.getLoc());
   auto i32Type = builder.getI32Type();
   auto vectorType = VectorType::get(/*shape=*/{8}, i32Type);
   vector_extract_element(
       i32Type, std_constant(vectorType, builder.getI32VectorAttr({10})),
       std_constant_int(0, i32Type));
 
   // clang-format off
   // CHECK-LABEL: @vector_extractelement_op
   //   CHECK-DAG:     {{.*}} = constant dense<10>
   //   CHECK-DAG:     {{.*}} = constant 0
   //  CHECK-NEXT:     {{.*}} = vector.extractelement
   // clang-format on
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 // clang-format off
 // CHECK-LABEL: func @memref_vector_matmul_test(
 //  CHECK-SAME:   %[[A:.*]]: memref<?x?xvector<4x16xf32>>,
 //  CHECK-SAME:   %[[B:.*]]: memref<?x?xvector<16x8xf32>>,
 //  CHECK-SAME:   %[[C:.*]]: memref<?x?xvector<4x8xf32>>)
TEST_FUNC(memref_vector_matmul_test) {
   ScopedContext scope(builder, f.getLoc());
   Value A(f.getArgument(0)), B(f.getArgument(1)), C(f.getArgument(2));
   auto contractionBuilder = [](ValueRange args) {
     assert(args.size() == 3 && "expected 3 block arguments");
     (linalg_yield(vector_contraction_matmul(args[0], args[1], args[2])));
   };
   linalg_generic_matmul(A, B, C, contractionBuilder);
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 TEST_FUNC(builder_loop_for_yield) {
   auto indexType = IndexType::get(&globalContext());
   auto f32Type = FloatType::getF32(&globalContext());
   auto f = makeFunction("builder_loop_for_yield", {},
                         {indexType, indexType, indexType, indexType});
TEST_FUNC(builder_loop_for_yield) {
   // CHECK-DAG:    [[r0:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 - s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-DAG:    [[r1:%[0-9]+]] = affine.apply affine_map<()[s0, s1] -> (s0 + s1)>()[%{{.*}}, %{{.*}}]
   // CHECK-NEXT: [[res:%[0-9]+]]:2 = scf.for %{{.*}} = [[r0]] to [[r1]] step {{.*}} iter_args([[arg0:%.*]] = [[init0]], [[arg1:%.*]] = [[init1]]) -> (f32, f32) {
   // CHECK:     [[sum:%[0-9]+]] = addf [[arg0]], [[arg1]] : f32
   // CHECK:     scf.yield [[arg1]], [[sum]] : f32, f32
   // CHECK:     addf [[res]]#0, [[res]]#1 : f32
   // clang-format on
 
-  f.print(llvm::outs());
+  f.print(llvm::outs(), OpPrintingFlags().useLocalScope());
   f.erase();
 }
 
 int main() {
   RUN_TESTS();
   return 0;
 }