Update llvm-project to 830c0b9

- builder.getSymbolRefAttr is gone.
- OpAsmOpInterface's getAsmResultNames method needs explicit override
- a bunch of churn for builtin.func needing to be made explicit (and
  sometimes implicit?)
- operation printers no longer need to print the operation name
  themselves.
- snuck in beneficial trivial addition to TmpDeleteDeadIREEListsPass to
  test a particular upstream change e2e with my local patchset.

external/iree-dialects/include/iree-dialects/Dialect/IREE/IREEBase.td

@@ -43,7 +43,7 @@ class IREE_AliasedSymbolRefAttr : Attr<CPred<"$_self.isa<FlatSymbolRefAttr>()">,
   let storageType = [{ FlatSymbolRefAttr }];
   let returnType = [{ StringRef }];
   let valueType = NoneType;
-  let constBuilderCall = "$_builder.getSymbolRefAttr($0)";
+  let constBuilderCall = "::mlir::SymbolRefAttr::get($_builder.getContext(), $0)";
 }
 
 class IREE_AnyPtrOf<list<Type> types> :

frontends/pytorch/test/node_import/dict.py

@@ -12,7 +12,7 @@
 mb = torch_mlir.ModuleBuilder()
 
 
-# CHECK-LABEL:   builtin.func @__torch__.dict_literal_empty() -> !torch.dict<!torch.str, !torch.tensor> {
+# CHECK-LABEL:   func @__torch__.dict_literal_empty() -> !torch.dict<!torch.str, !torch.tensor> {
 # CHECK:           %[[DICT:.*]] = torch.prim.DictConstruct keys() values() -> !torch.dict<!torch.str, !torch.tensor>
 # CHECK:           return %[[DICT]] : !torch.dict<!torch.str, !torch.tensor>
 @mb.import_function
@@ -21,7 +21,7 @@ def dict_literal_empty() -> Dict[str, torch.Tensor]:
   return {}
 
 
-# CHECK-LABEL:   builtin.func @__torch__.dict_literal(
+# CHECK-LABEL:   func @__torch__.dict_literal(
 # CHECK-SAME:        %[[K0:.*]]: !torch.str, %[[V0:.*]]: !torch.tensor,
 # CHECK-SAME:        %[[K1:.*]]: !torch.str, %[[V1:.*]]: !torch.tensor)
 # CHECK-SAME:        -> !torch.dict<!torch.str, !torch.optional<!torch.tensor>> {

frontends/pytorch/test/node_import/tuple.py

@@ -13,7 +13,7 @@
 NT = NamedTuple('NT', [('f1', Optional[torch.Tensor]),
                        ('f2', Optional[torch.Tensor])])
 
-# CHECK-LABEL:   builtin.func @__torch__.tuple(
+# CHECK-LABEL:   func @__torch__.tuple(
 # CHECK-SAME:            %[[T0:.*]]: !torch.tensor,
 # CHECK-SAME:            %[[T1:.*]]: !torch.tensor) ->
 # CHECK-SAME:            !torch.tuple<!torch.tensor, !torch.tensor> {
@@ -28,7 +28,7 @@ def tuple(t0, t1):
   return t0, t1
 
 
-# CHECK-LABEL:   builtin.func @__torch__.tuple_optional(
+# CHECK-LABEL:   func @__torch__.tuple_optional(
 # CHECK-SAME:            %[[T0:.*]]: !torch.tensor,
 # CHECK-SAME:            %[[T1:.*]]: !torch.tensor) ->
 # CHECK-SAME:            !torch.tuple<!torch.optional<!torch.tensor>, !torch.optional<!torch.tensor>> {
@@ -47,7 +47,7 @@ def tuple_optional(
   return t0, t1
 
 
-# CHECK-LABEL:   builtin.func @__torch__.namedtuple_optional(
+# CHECK-LABEL:   func @__torch__.namedtuple_optional(
 # CHECK-SAME:            %[[T0:.*]]: !torch.tensor,
 # CHECK-SAME:            %[[T1:.*]]: !torch.tensor) ->
 # CHECK-SAME:            !torch.tuple<!torch.optional<!torch.tensor>, !torch.optional<!torch.tensor>> {

include/npcomp/Dialect/Basicpy/IR/BasicpyOps.td

@@ -95,7 +95,8 @@ def CompareOperationAttr : StrEnumAttr<
 //===----------------------------------------------------------------------===//
 
 def Basicpy_NumericConstantOp : Basicpy_Op<"numeric_constant", [
-    ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "A constant from the Python3 numeric type hierarchy";
   let description = [{
     Basicpy re-uses core MLIR types to represent the Python3 numeric type
@@ -141,7 +142,8 @@ def Basicpy_NumericConstantOp : Basicpy_Op<"numeric_constant", [
 }
 
 def Basicpy_BoolConstantOp : Basicpy_Op<"bool_constant", [
-    ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "A boolean constant";
   let description = [{
     A constant of type !basicpy.BoolType that can take either an i1 value
@@ -220,7 +222,8 @@ def Basicpy_BuildTupleOp : Basicpy_Op<"build_tuple", [NoSideEffect]> {
 }
 
 def Basicpy_BytesConstantOp : Basicpy_Op<"bytes_constant", [
-    ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "Constant bytes value";
   let description = [{
     A bytes value of BytesType. The value is represented by a StringAttr.
@@ -251,7 +254,8 @@ def Basicpy_SingletonOp : Basicpy_Op<"singleton", [
 }
 
 def Basicpy_StrConstantOp : Basicpy_Op<"str_constant", [
-    ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "Constant string value";
   let description = [{
     A string value of StrType. The value is represented by a StringAttr

include/npcomp/Dialect/Torch/IR/TorchOps.td

@@ -534,7 +534,8 @@ def Torch_PrimIfYieldOp : Torch_Op<"prim.If.yield", [
 //===----------------------------------------------------------------------===//
 
 def Torch_ConstantNoneOp : Torch_Op<"constant.none",
-    [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    [ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "Get the singleton None value.";
   let description = [{
     Not to be confused with the `mlir::NoneType`. Be careful to use
@@ -547,7 +548,8 @@ def Torch_ConstantNoneOp : Torch_Op<"constant.none",
 }
 
 def Torch_ConstantStrOp : Torch_Op<"constant.str",
-    [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    [ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "Materialize a constant str value.";
   let description = [{
     Note: Strings in Python (and TorchScript) are immutable.
@@ -563,7 +565,8 @@ def Torch_ConstantStrOp : Torch_Op<"constant.str",
 }
 
 def Torch_ConstantIntOp : Torch_Op<"constant.int",
-    [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    [ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "Materialize a constant `int` value.";
   let description = [{
     Note: TorchScript represents integers as 64-bit signed values, unlike
@@ -581,7 +584,8 @@ def Torch_ConstantIntOp : Torch_Op<"constant.int",
 }
 
 def Torch_ConstantFloatOp : Torch_Op<"constant.float",
-    [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    [ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "Materialize a constant `float` value.";
   let description = [{
     Note: TorchScript represents `float` as 64-bit floating point values.
@@ -599,7 +603,8 @@ def Torch_ConstantFloatOp : Torch_Op<"constant.float",
 }
 
 def Torch_ConstantBoolOp : Torch_Op<"constant.bool",
-    [ConstantLike, NoSideEffect, DeclareOpInterfaceMethods<OpAsmOpInterface>]> {
+    [ConstantLike, NoSideEffect,
+    DeclareOpInterfaceMethods<OpAsmOpInterface, ["getAsmResultNames"]>]> {
   let summary = "Materialize a constant `bool` value.";
   let description = [{
   }];

include/npcomp/Dialect/Torch/IR/TorchTypes.td

@@ -62,7 +62,7 @@ def Torch_NnModuleType : Torch_Type<"NnModule", "nn.Module"> {
   let parser = [{
     if (parser.parseLess())
       return Type();
-    StringRef className;
+    std::string className;
     if ($_parser.parseOptionalString(&className))
       return Type();
     if ($_parser.parseGreater())

lib/Dialect/Basicpy/IR/BasicpyOps.cpp

@@ -80,7 +80,7 @@ static ParseResult parseNumericConstantOp(OpAsmParser &parser,
 }
 
 static void print(OpAsmPrinter &p, NumericConstantOp op) {
-  p << "basicpy.numeric_constant ";
+  p << " ";
   p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"value"});
 
   if (op->getAttrs().size() > 1)
@@ -176,7 +176,6 @@ static ParseResult parseExecOp(OpAsmParser &parser, OperationState *result) {
 }
 
 static void print(OpAsmPrinter &p, ExecOp op) {
-  p << op.getOperationName();
   p.printOptionalAttrDictWithKeyword(op->getAttrs());
   p.printRegion(op.body());
 }
@@ -230,7 +229,7 @@ static ParseResult parseFuncTemplateOp(OpAsmParser &parser,
 }
 
 static void print(OpAsmPrinter &p, FuncTemplateOp op) {
-  p << op.getOperationName() << " ";
+  p << " ";
   p.printSymbolName(op.getName());
   p.printOptionalAttrDictWithKeyword(op->getAttrs(),
                                      {SymbolTable::getSymbolAttrName()});
@@ -294,7 +293,7 @@ static void print(OpAsmPrinter &p, SlotObjectMakeOp op) {
     return;
   }
 
-  p << op.getOperationName() << "(";
+  p << "(";
   p.printOperands(op.slots());
   p << ")";
   p.printOptionalAttrDict(op->getAttrs(), {"className"});
@@ -358,7 +357,7 @@ static void print(OpAsmPrinter &p, SlotObjectGetOp op) {
     return;
   }
 
-  p << op.getOperationName() << " ";
+  p << " ";
   p.printOperand(op.object());
   p << "[" << op.index() << "]";
   p.printOptionalAttrDict(op->getAttrs(), {"index"});

lib/Dialect/Refbackrt/IR/RefbackrtOps.cpp

@@ -21,7 +21,6 @@ using namespace mlir::NPCOMP::refbackrt;
 //===----------------------------------------------------------------------===//
 
 static void printModuleMetadataOp(OpAsmPrinter &p, ModuleMetadataOp &op) {
-  p << "refbackrt.module_metadata";
   p.printOptionalAttrDictWithKeyword(op->getAttrs());
   p.printRegion(op.metadatas(), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/false);

lib/Dialect/Torch/IR/TorchOps.cpp

@@ -54,7 +54,8 @@ static IntegerAttr getI64IntegerAttr(MLIRContext *context, int64_t value) {
 //===----------------------------------------------------------------------===//
 
 LogicalResult MethodOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
-  auto func = symbolTable.lookupNearestSymbolFrom<FuncOp>(*this, function());
+  auto func =
+      symbolTable.lookupNearestSymbolFrom<FuncOp>(*this, functionAttr());
   if (!func)
     return emitError() << "'@" << function()
                        << "' does not reference a valid function";
@@ -132,8 +133,8 @@ bool isValidSubtype(Type subtype, Type type) {
 }
 
 LogicalResult NnModuleOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
-  auto classType =
-      symbolTable.lookupNearestSymbolFrom<ClassTypeOp>(*this, getClassName());
+  auto classType = symbolTable.lookupNearestSymbolFrom<ClassTypeOp>(
+      *this, SymbolRefAttr::get(getContext(), getClassName()));
   if (!classType)
     return emitError() << "'" << getClassName()
                        << "' does not reference a valid class type";
@@ -297,7 +298,7 @@ static ParseResult parsePrimIfOp(OpAsmParser &parser, OperationState &result) {
 }
 
 static void print(OpAsmPrinter &p, PrimIfOp op) {
-  p << PrimIfOp::getOperationName() << " " << op.condition();
+  p << " " << op.condition();
   p << " -> (" << op.getResultTypes() << ")";
   p.printRegion(op.thenRegion(), /*printEntryBlockArgs=*/false);
   p << " else";
@@ -748,7 +749,7 @@ static ParseResult parseConstantIntOp(OpAsmParser &parser,
 }
 
 static void print(OpAsmPrinter &p, Torch::ConstantIntOp op) {
-  p << Torch::ConstantIntOp::getOperationName() << " ";
+  p << " ";
   p << op.value().getSExtValue();
   p.printOptionalAttrDict(op->getAttrs(), {"value"});
 }

lib/Dialect/TorchConversion/Transforms/TmpDeleteDeadIREELists.cpp

@@ -33,7 +33,7 @@ class TmpDeleteDeadIREEListsPass
       SmallVector<Operation *> deadOps;
       deadOps.push_back(op);
       for (auto &use : op.getResult().getUses()) {
-        if (isa<iree::ListSetOp>(use.getOwner())) {
+        if (isa<iree::ListSetOp, iree::ListResizeOp>(use.getOwner())) {
           deadOps.push_back(use.getOwner());
         } else {
           // We can't analyze the list op if it is used by something else.

lib/RefBackend/LowerToLLVM.cpp

@@ -735,7 +735,8 @@ class LowerToLLVM : public LowerToLLVMBase<LowerToLLVM> {
       auto wrapper = createWrapperFunc(originalFunc);
       op.getResult().setType(LLVMPointerType::get(wrapper.getType()));
       Builder builder(op.getContext());
-      op->setAttr("global_name", builder.getSymbolRefAttr(wrapper.getName()));
+      op->setAttr("global_name",
+                  SymbolRefAttr::get(builder.getContext(), wrapper.getName()));
     });
   }
 };

lib/RefBackend/LowerToRefbackrtABI.cpp

@@ -231,9 +231,9 @@ static LogicalResult createModuleMetadata(ModuleOp module) {
 
     // Add attributes that are valid for every func (funcName, numInputs,
     // numOutputs)
-    namedAttrs.push_back(
-        std::make_pair(Identifier::get("funcName", module.getContext()),
-                       builder.getSymbolRefAttr(func.getName())));
+    namedAttrs.push_back(std::make_pair(
+        Identifier::get("funcName", module.getContext()),
+        SymbolRefAttr::get(builder.getContext(), func.getName())));
     namedAttrs.push_back(
         std::make_pair(Identifier::get("numInputs", module.getContext()),
                        builder.getI32IntegerAttr(func.getNumArguments())));

test/Conversion/TorchToIREE/basic.mlir

@@ -1,7 +1,7 @@
 
 // RUN: npcomp-opt <%s -convert-torch-to-iree -split-input-file -verify-diagnostics | FileCheck %s
 
-// CHECK-LABEL:   builtin.func @forward(
+// CHECK-LABEL: func @forward(
 // CHECK-SAME:                          %[[ARG_TORCH:.*]]: !torch.float) -> !torch.list<!torch.float> {
 // CHECK:           %[[ARG:.*]] = torch_c.to_f64 %[[ARG_TORCH]]
 // CHECK:           %[[ALSO_ARG:.*]] = torch_c.to_f64 %[[ARG_TORCH]]

test/Conversion/TorchToLinalg/flatten.mlir

@@ -36,7 +36,7 @@ func @torch.aten.flatten.using_ints$basic_negative(%arg0: !torch.vtensor<[3,3,2,
 
 // -----
 
-// CHECK-LABEL:   builtin.func @torch.aten.flatten.using_ints$flatten_front(
+// CHECK-LABEL:   func @torch.aten.flatten.using_ints$flatten_front(
 // CHECK-SAME:                                                              %[[TENSOR:.*]]: !torch.vtensor<[3,3,2,2],f32>) -> !torch.vtensor<[?,?],f32> {
 // CHECK:           %[[BUILTIN_TENSOR:.*]] = torch_c.to_builtin_tensor %[[TENSOR]] : !torch.vtensor<[3,3,2,2],f32> -> tensor<3x3x2x2xf32>
 // CHECK:           %[[COLLAPSED:.*]] = linalg.tensor_collapse_shape %[[BUILTIN_TENSOR]] {{\[\[}}0, 1, 2], [3]] : tensor<3x3x2x2xf32> into tensor<18x2xf32>
@@ -53,7 +53,7 @@ func @torch.aten.flatten.using_ints$flatten_front(%arg0: !torch.vtensor<[3,3,2,2
 
 // -----
 
-// CHECK-LABEL:   builtin.func @torch.aten.flatten.using_ints$flatten_back(
+// CHECK-LABEL:   func @torch.aten.flatten.using_ints$flatten_back(
 // CHECK-SAME:                                                              %[[TENSOR:.*]]: !torch.vtensor<[3,3,2,2],f32>) -> !torch.vtensor<[?,12],f32> {
 // CHECK:           %[[BUILTIN_TENSOR:.*]] = torch_c.to_builtin_tensor %[[TENSOR]] : !torch.vtensor<[3,3,2,2],f32> -> tensor<3x3x2x2xf32>
 // CHECK:           %[[COLLAPSED:.*]] = linalg.tensor_collapse_shape %[[BUILTIN_TENSOR]] {{\[\[}}0], [1, 2, 3]] : tensor<3x3x2x2xf32> into tensor<3x12xf32>

test/Conversion/TorchToLinalg/pooling.mlir

@@ -1,6 +1,6 @@
 // RUN: npcomp-opt <%s -convert-torch-to-linalg -split-input-file -verify-diagnostics | FileCheck %s
 
-// CHECK-LABEL: builtin.func @forward
+// CHECK-LABEL: func @forward
 builtin.func @forward(%arg0: !torch.vtensor<[?,?,?,?],f32>) -> !torch.vtensor<[?,?,?,?],f32> {
   %int1 = torch.constant.int 1
   %int2 = torch.constant.int 2

test/Dialect/Basicpy/functions.mlir

@@ -5,52 +5,52 @@
 //===----------------------------------------------------------------------===//
 
 // CHECK-LABEL: func @positional
-func @positional(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
+builtin.func @positional(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
   // CHECK: basicpy.func_template_call @foobar(%arg0, %arg1) kw []
   %0 = basicpy.func_template_call @foobar(%arg0, %arg1) kw [] : (!basicpy.UnknownType, !basicpy.UnknownType) -> !basicpy.UnknownType
   return %0 : !basicpy.UnknownType
 }
 
 // -----
 // CHECK-LABEL: func @kwValid
-func @kwValid(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
+builtin.func @kwValid(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
   // CHECK: basicpy.func_template_call @foobar(%arg0, %arg1) kw ["second"]
   %0 = basicpy.func_template_call @foobar(%arg0, %arg1) kw ["second"] : (!basicpy.UnknownType, !basicpy.UnknownType) -> !basicpy.UnknownType
   return %0 : !basicpy.UnknownType
 }
 
 // -----
 // CHECK-LABEL: func @posArgPack
-func @posArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
+builtin.func @posArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
   // CHECK: basicpy.func_template_call @foobar(%arg0, %arg1) kw ["*"]
   %0 = basicpy.func_template_call @foobar(%arg0, %arg1) kw ["*"] : (!basicpy.UnknownType, !basicpy.UnknownType) -> !basicpy.UnknownType
   return %0 : !basicpy.UnknownType
 }
 
 // -----
 // CHECK-LABEL: func @kwArgPack
-func @kwArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
+builtin.func @kwArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
   // CHECK: basicpy.func_template_call @foobar(%arg0, %arg1) kw ["**"]
   %0 = basicpy.func_template_call @foobar(%arg0, %arg1) kw ["**"] : (!basicpy.UnknownType, !basicpy.UnknownType) -> !basicpy.UnknownType
   return %0 : !basicpy.UnknownType
 }
 
 // -----
-func @kwOverflow(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
+builtin.func @kwOverflow(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
   // expected-error @+1 {{expected <= kw arg names vs args}}
   %0 = basicpy.func_template_call @foobar(%arg0, %arg1) kw ["second", "third", "fourth"] : (!basicpy.UnknownType, !basicpy.UnknownType) -> !basicpy.UnknownType
   return %0 : !basicpy.UnknownType
 }
 
 // -----
-func @badPosArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
+builtin.func @badPosArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
   // expected-error @+1 {{positional arg pack must be the first kw arg}}
   %0 = basicpy.func_template_call @foobar(%arg0, %arg1) kw ["*", "*"] : (!basicpy.UnknownType, !basicpy.UnknownType) -> !basicpy.UnknownType
   return %0 : !basicpy.UnknownType
 }
 
 // -----
-func @badKwArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
+builtin.func @badKwArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -> !basicpy.UnknownType {
   // expected-error @+1 {{kw arg pack must be the last kw arg}}
   %0 = basicpy.func_template_call @foobar(%arg0, %arg1) kw ["**", "next"] : (!basicpy.UnknownType, !basicpy.UnknownType) -> !basicpy.UnknownType
   return %0 : !basicpy.UnknownType
@@ -62,20 +62,20 @@ func @badKwArgPack(%arg0 : !basicpy.UnknownType, %arg1 : !basicpy.UnknownType) -
 
 // -----
 // CHECK-LABEL: module @valid_template
-module @valid_template {
+builtin.module @valid_template {
   // CHECK: basicpy.func_template @__global$pkg.foobar attributes {py_bind = ["#abs"]} {
   basicpy.func_template @__global$pkg.foobar attributes {py_bind = ["#abs"]} {
     // CHECK: func @forInts(%arg0: i32) -> i32
-    func @forInts(%arg0 : i32) -> i32 {
+    builtin.func @forInts(%arg0 : i32) -> i32 {
       return %arg0 : i32
     }
   }
 }
 
 // -----
-module @invalid_template {
+builtin.module @invalid_template {
   basicpy.func_template @__global$pkg.foobar {
     // expected-error @+1 {{illegal operation in func_template}}
-    module {}
+    builtin.module {}
   }
 }