[mlir][NFC] Update the Builtin dialect to use "Both" accessors

[tpopp]

mlir/include/mlir/IR/BuiltinDialect.td

37

Can you please first use kEmitAccessorPrefix_Both? In this case there is a clear option to allow a transition period and it is unlikely to create much more work for you as there would be few new uses in a 2 week time frame.

[rriddle]

mlir/include/mlir/IR/BuiltinDialect.td

37

Sure, though not sure how long I'll leave it for.

[tpopp]

mlir/include/mlir/IR/BuiltinDialect.td

37

Thank you. (Also, I listed 2 weeks as a random number. At least for us, we will be working on the transition right away as we are aware of it)

[rriddle]

mlir/include/mlir/IR/BuiltinDialect.td

37

Yep, thanks for suggesting the "both" mode. (Almost forgot about it honestly).

flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp

 struct MangleNameOnFuncOp : public mlir::OpRewritePattern<mlir::FuncOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   mlir::LogicalResult
   matchAndRewrite(mlir::FuncOp op,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
-    auto result = fir::NameUniquer::deconstruct(op.sym_name());
-    if (fir::NameUniquer::isExternalFacingUniquedName(result)) {
-      auto newName = mangleExternalName(result);
-      op.sym_nameAttr(rewriter.getStringAttr(newName));
-      SymbolTable::setSymbolName(op, newName);
-    }
+    auto result = fir::NameUniquer::deconstruct(op.getSymName());
+    if (fir::NameUniquer::isExternalFacingUniquedName(result))
+      op.setSymNameAttr(rewriter.getStringAttr(mangleExternalName(result)));
     rewriter.finalizeRootUpdate(op);
     return success();
   }
 };
 
 struct MangleNameForCommonBlock : public mlir::OpRewritePattern<fir::GlobalOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
void ExternalNameConversionPass::runOnOperation() {
   target.addDynamicallyLegalOp<fir::CallOp>([](fir::CallOp op) {
     if (op.getCallee().hasValue())
       return !fir::NameUniquer::needExternalNameMangling(
           op.getCallee().getValue().getRootReference().getValue());
     return true;
   });
 
   target.addDynamicallyLegalOp<mlir::FuncOp>([](mlir::FuncOp op) {
-    return !fir::NameUniquer::needExternalNameMangling(op.sym_name());
+    return !fir::NameUniquer::needExternalNameMangling(op.getSymName());
   });
 
   target.addDynamicallyLegalOp<fir::GlobalOp>([](fir::GlobalOp op) {
     return !fir::NameUniquer::needExternalNameMangling(
         op.getSymref().getRootReference().getValue());
   });
 
   target.addDynamicallyLegalOp<fir::AddrOfOp>([](fir::AddrOfOp op) {

mlir/include/mlir/IR/BuiltinDialect.td

private:
     void registerAttributes();
     // Register the builtin Location Attributes.
     void registerLocationAttributes();
     // Register the builtin Types.
     void registerTypes();
 
   public:
   }];
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 #endif // BUILTIN_BASE

mlir/include/mlir/IR/BuiltinOps.td

let description = [{
     func @example_fn_result() -> (f64 {dialectName.attrName = 0 : i64})
 
     // A function with an attribute
     func @example_fn_attr() attributes {dialectName.attrName = false}
     ```
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name,
-                       TypeAttr:$type,
+                       TypeAttrOf<FunctionType>:$type,
                        OptionalAttr<StrAttr>:$sym_visibility);
   let regions = (region AnyRegion:$body);
 
   let builders = [OpBuilder<(ins
     "StringRef":$name, "FunctionType":$type,
     CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs,
     CArg<"ArrayRef<DictionaryAttr>", "{}">:$argAttrs)
   >];
let extraClassDeclaration = [{
     FuncOp clone();
 
     /// Clone the internal blocks and attributes from this function into dest.
     /// Any cloned blocks are appended to the back of dest. This function
     /// asserts that the attributes of the current function and dest are
     /// compatible.
     void cloneInto(FuncOp dest, BlockAndValueMapping &mapper);
 
-    /// Returns the type of this function.
-    /// FIXME: We should drive this via the ODS `type` param.
-    FunctionType getType() { 
-      return getTypeAttr().getValue().cast<FunctionType>();
-    }
-
     //===------------------------------------------------------------------===//
     // CallableOpInterface
     //===------------------------------------------------------------------===//
 
     /// Returns the region on the current operation that is callable. This may
     /// return null in the case of an external callable object, e.g. an external
     /// function.
     ::mlir::Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
let extraClassDeclaration = [{
     /// Returns the result types of this function.
     ArrayRef<Type> getResultTypes() { return getType().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 '" + getTypeAttrName() +
+        return emitOpError("requires '" + FunctionOpInterface::getTypeAttrName() +
                            "' attribute of function type");
       return success();
     }
 
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
let description = [{
     module {
       func @foo()
     }
     ```
   }];
 
   let arguments = (ins OptionalAttr<SymbolNameAttr>:$sym_name,
                        OptionalAttr<StrAttr>:$sym_visibility);
-  let regions = (region SizedRegion<1>:$body);
+  let regions = (region SizedRegion<1>:$bodyRegion);
 
-  let assemblyFormat = "($sym_name^)? attr-dict-with-keyword $body";
+  let assemblyFormat = "($sym_name^)? attr-dict-with-keyword $bodyRegion";
   let builders = [OpBuilder<(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(); }
+    Optional<StringRef> getName() { return getSymName(); }
 
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//
 
     /// A ModuleOp may optionally define a symbol.
     bool isOptionalSymbol() { return true; }
 

mlir/include/mlir/IR/FunctionInterfaces.h

 }
 
 /// This function defines the internal implementation of the `verifyTrait`
 /// method on FunctionOpInterface::Trait.
 template <typename ConcreteOp>
 LogicalResult verifyTrait(ConcreteOp op) {
   if (!op.getTypeAttr())
     return op.emitOpError("requires a type attribute '")
-           << ConcreteOp::getTypeAttrName() << '\'';
+           << function_interface_impl::getTypeAttrName() << '\'';
 
   if (failed(op.verifyType()))
     return failure();
 
   if (ArrayAttr allArgAttrs = op.getAllArgAttrs()) {
     unsigned numArgs = op.getNumArguments();
     if (allArgAttrs.size() != numArgs) {
       return op.emitOpError()

mlir/include/mlir/IR/OpBase.td

class TypeAttrBase<string retType, string summary> :
   let valueType = NoneType;
   let convertFromStorage = "$_self.getValue().cast<" # retType # ">()";
 }
 
 def TypeAttr : TypeAttrBase<"::mlir::Type", "any type attribute"> {
   let constBuilderCall = "::mlir::TypeAttr::get($0)";
 }
 
+class TypeAttrOf<Type ty>
+   : TypeAttrBase<ty.cppClassName, "type attribute of " # ty.description> {
+  let constBuilderCall = "::mlir::TypeAttr::get($0)";
+}
+
 // The mere presence of unit attributes has a meaning.  Therefore, unit
 // attributes are always treated as optional and accessors to them return
 // "true" if the attribute is present and "false" otherwise.
 def UnitAttr : Attr<CPred<"$_self.isa<::mlir::UnitAttr>()">, "unit attribute"> {
   let storageType = [{ ::mlir::UnitAttr }];
   let constBuilderCall = "$_builder.getUnitAttr()";
   let convertFromStorage = "$_self != nullptr";
   let returnType = "bool";

mlir/lib/Conversion/FuncToLLVM/FuncToLLVM.cpp

struct UnrealizedConversionCastOpLowering
     : public ConvertOpToLLVMPattern<UnrealizedConversionCastOp> {
   using ConvertOpToLLVMPattern<
       UnrealizedConversionCastOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(UnrealizedConversionCastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     SmallVector<Type> convertedTypes;
-    if (succeeded(typeConverter->convertTypes(op.outputs().getTypes(),
+    if (succeeded(typeConverter->convertTypes(op.getOutputs().getTypes(),
                                               convertedTypes)) &&
-        convertedTypes == adaptor.inputs().getTypes()) {
-      rewriter.replaceOp(op, adaptor.inputs());
+        convertedTypes == adaptor.getInputs().getTypes()) {
+      rewriter.replaceOp(op, adaptor.getInputs());
       return success();
     }
 
     convertedTypes.clear();
-    if (succeeded(typeConverter->convertTypes(adaptor.inputs().getTypes(),
+    if (succeeded(typeConverter->convertTypes(adaptor.getInputs().getTypes(),
                                               convertedTypes)) &&
-        convertedTypes == op.outputs().getType()) {
-      rewriter.replaceOp(op, adaptor.inputs());
+        convertedTypes == op.getOutputs().getType()) {
+      rewriter.replaceOp(op, adaptor.getInputs());
       return success();
     }
     return failure();
   }
 };
 
 // Special lowering pattern for `ReturnOps`.  Unlike all other operations,
 // `ReturnOp` interacts with the function signature and must have as many

mlir/lib/Conversion/ReconcileUnrealizedCasts/ReconcileUnrealizedCasts.cpp

struct UnrealizedConversionCastPassthrough
 
   LogicalResult matchAndRewrite(UnrealizedConversionCastOp op,
                                 PatternRewriter &rewriter) const override {
     // Match the casts that are _only_ used by other casts, with the overall
     // cast being a trivial noop: A->B->A.
     auto users = op->getUsers();
     if (!llvm::all_of(users, [&](Operation *user) {
           if (auto other = dyn_cast<UnrealizedConversionCastOp>(user))
-            return other.getResultTypes() == op.inputs().getTypes() &&
-                   other.inputs() == op.outputs();
+            return other.getResultTypes() == op.getInputs().getTypes() &&
+                   other.getInputs() == op.getOutputs();
           return false;
         })) {
       return rewriter.notifyMatchFailure(op, "live unrealized conversion cast");
     }
 
     for (Operation *user : users)
-      rewriter.replaceOp(user, op.inputs());
+      rewriter.replaceOp(user, op.getInputs());
 
     rewriter.eraseOp(op);
     return success();
   }
 };
 
 /// Pass to simplify and eliminate unrealized conversion casts.
 struct ReconcileUnrealizedCasts

mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp

 static FuncOp createAsyncDispatchFunction(ParallelComputeFunction &computeFunc,
                                           PatternRewriter &rewriter) {
   OpBuilder::InsertionGuard guard(rewriter);
   Location loc = computeFunc.func.getLoc();
   ImplicitLocOpBuilder b(loc, rewriter);
 
   ModuleOp module = computeFunc.func->getParentOfType<ModuleOp>();
 
-  ArrayRef<Type> computeFuncInputTypes =
-      computeFunc.func.type().cast<FunctionType>().getInputs();
+  ArrayRef<Type> computeFuncInputTypes = computeFunc.func.getType().getInputs();
 
   // Compared to the parallel compute function async dispatch function takes
   // additional !async.group argument. Also instead of a single `blockIndex` it
   // takes `blockStart` and `blockEnd` arguments to define the range of
   // dispatched blocks.
   SmallVector<Type> inputTypes;
   inputTypes.push_back(async::GroupType::get(rewriter.getContext()));
   inputTypes.push_back(rewriter.getIndexType()); // add blockStart argument
// for the seconds half of the original range and go to the next iteration.
     auto executeBodyBuilder = [&](OpBuilder &executeBuilder,
                                   Location executeLoc, ValueRange executeArgs) {
       // Update the original `blockStart` and `blockEnd` with new range.
       SmallVector<Value> operands{block->getArguments().begin(),
                                   block->getArguments().end()};
       operands[1] = midIndex;
       operands[2] = end;
 
-      executeBuilder.create<func::CallOp>(executeLoc, func.sym_name(),
+      executeBuilder.create<func::CallOp>(executeLoc, func.getSymName(),
                                           func.getCallableResults(), operands);
       executeBuilder.create<async::YieldOp>(executeLoc, ValueRange());
     };
 
     // Create async.execute operation to dispatch half of the block range.
     auto execute = b.create<ExecuteOp>(TypeRange(), ValueRange(), ValueRange(),
                                        executeBodyBuilder);
     b.create<AddToGroupOp>(indexTy, execute.token(), group);
     b.create<scf::YieldOp>(ValueRange({start, midIndex}));
   }
 
   // After dispatching async operations to process the tail of the block range
   // call the parallel compute function for the first block of the range.
   b.setInsertionPointAfter(whileOp);
 
   // Drop async dispatch specific arguments: async group, block start and end.
   auto forwardedInputs = block->getArguments().drop_front(3);
   SmallVector<Value> computeFuncOperands = {blockStart};
   computeFuncOperands.append(forwardedInputs.begin(), forwardedInputs.end());
 
-  b.create<func::CallOp>(computeFunc.func.sym_name(),
+  b.create<func::CallOp>(computeFunc.func.getSymName(),
                          computeFunc.func.getCallableResults(),
                          computeFuncOperands);
   b.create<func::ReturnOp>(ValueRange());
 
   return func;
 }
 
 // Launch async dispatch of the parallel compute function.
static void doAsyncDispatch(ImplicitLocOpBuilder &b, PatternRewriter &rewriter,
 
   auto syncDispatch = [&](OpBuilder &nestedBuilder, Location loc) {
     ImplicitLocOpBuilder b(loc, nestedBuilder);
 
     // Call parallel compute function for the single block.
     SmallVector<Value> operands = {c0, blockSize};
     appendBlockComputeOperands(operands);
 
-    b.create<func::CallOp>(parallelComputeFunction.func.sym_name(),
+    b.create<func::CallOp>(parallelComputeFunction.func.getSymName(),
                            parallelComputeFunction.func.getCallableResults(),
                            operands);
     b.create<scf::YieldOp>();
   };
 
   auto asyncDispatch = [&](OpBuilder &nestedBuilder, Location loc) {
     ImplicitLocOpBuilder b(loc, nestedBuilder);
 
     // Create an async.group to wait on all async tokens from the concurrent
     // execution of multiple parallel compute function. First block will be
     // executed synchronously in the caller thread.
     Value groupSize = b.create<arith::SubIOp>(blockCount, c1);
     Value group = b.create<CreateGroupOp>(GroupType::get(ctx), groupSize);
 
     // Launch async dispatch function for [0, blockCount) range.
     SmallVector<Value> operands = {group, c0, blockCount, blockSize};
     appendBlockComputeOperands(operands);
 
-    b.create<func::CallOp>(asyncDispatchFunction.sym_name(),
+    b.create<func::CallOp>(asyncDispatchFunction.getSymName(),
                            asyncDispatchFunction.getCallableResults(),
                            operands);
 
     // Wait for the completion of all parallel compute operations.
     b.create<AwaitAllOp>(group);
 
     b.create<scf::YieldOp>();
   };
doSequentialDispatch(ImplicitLocOpBuilder &b, PatternRewriter &rewriter,
   // Induction variable is the index of the block: [0, blockCount).
   LoopBodyBuilder loopBuilder = [&](OpBuilder &loopBuilder, Location loc,
                                     Value iv, ValueRange args) {
     ImplicitLocOpBuilder b(loc, loopBuilder);
 
     // Call parallel compute function inside the async.execute region.
     auto executeBodyBuilder = [&](OpBuilder &executeBuilder,
                                   Location executeLoc, ValueRange executeArgs) {
-      executeBuilder.create<func::CallOp>(executeLoc, compute.sym_name(),
+      executeBuilder.create<func::CallOp>(executeLoc, compute.getSymName(),
                                           compute.getCallableResults(),
                                           computeFuncOperands(iv));
       executeBuilder.create<async::YieldOp>(executeLoc, ValueRange());
     };
 
     // Create async.execute operation to launch parallel computate function.
     auto execute = b.create<ExecuteOp>(TypeRange(), ValueRange(), ValueRange(),
                                        executeBodyBuilder);
     b.create<AddToGroupOp>(rewriter.getIndexType(), execute.token(), group);
     b.create<scf::YieldOp>();
   };
 
   // Iterate over all compute blocks and launch parallel compute operations.
   b.create<scf::ForOp>(c1, blockCount, c1, ValueRange(), loopBuilder);
 
   // Call parallel compute function for the first block in the caller thread.
-  b.create<func::CallOp>(compute.sym_name(), compute.getCallableResults(),
+  b.create<func::CallOp>(compute.getSymName(), compute.getCallableResults(),
                          computeFuncOperands(c0));
 
   // Wait for the completion of all async compute operations.
   b.create<AwaitAllOp>(group);
 }
 
 LogicalResult
 AsyncParallelForRewrite::matchAndRewrite(scf::ParallelOp op,

mlir/lib/Dialect/Async/Transforms/AsyncToAsyncRuntime.cpp

static CoroMachinery setupCoroMachinery(FuncOp func) {
   // This will be the return value of a coroutine ramp function.
   SmallVector<Value, 4> ret{retToken};
   ret.insert(ret.end(), retValues.begin(), retValues.end());
   builder.create<func::ReturnOp>(ret);
 
   // `async.await` op lowering will create resume blocks for async
   // continuations, and will conditionally branch to cleanup or suspend blocks.
 
-  for (Block &block : func.body().getBlocks()) {
+  for (Block &block : func.getBody().getBlocks()) {
     if (&block == entryBlock || &block == cleanupBlock ||
         &block == suspendBlock)
       continue;
     Operation *terminator = block.getTerminator();
     if (auto yield = dyn_cast<YieldOp>(terminator)) {
       builder.setInsertionPointToEnd(&block);
       builder.create<cf::BranchOp>(cleanupBlock);
     }
auto addToWorklist = [&](FuncOp func) {
     if (isAllowedToBlock(func))
       return;
     // N.B. To refactor this code into a separate pass the lookup in
     // outlinedFunctions is the most obvious obstacle. Looking at an arbitrary
     // func and recognizing if it has a coroutine structure is messy. Passing
     // this dict between the passes is ugly.
     if (isAllowedToBlock(func) ||
         outlinedFunctions.find(func) == outlinedFunctions.end()) {
-      for (Operation &op : func.body().getOps()) {
+      for (Operation &op : func.getBody().getOps()) {
         if (dyn_cast<AwaitOp>(op) || dyn_cast<AwaitAllOp>(op)) {
           funcWorklist.push_back(func);
           break;
         }
       }
     }
   };
 

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ModuleBufferization.cpp

if (it == moduleState.analyzedFuncOps.end())
     return FuncOpAnalysisState::NotAnalyzed;
   return it->second;
 }
 
 /// Return the unique ReturnOp that terminates `funcOp`.
 /// Return nullptr if there is no such unique ReturnOp.
 static func::ReturnOp getAssumedUniqueReturnOp(FuncOp funcOp) {
   func::ReturnOp returnOp;
-  for (Block &b : funcOp.body()) {
+  for (Block &b : funcOp.getBody()) {
     if (auto candidateOp = dyn_cast<func::ReturnOp>(b.getTerminator())) {
       if (returnOp)
         return nullptr;
       returnOp = candidateOp;
     }
   }
   return returnOp;
 }
FunctionType bufferizedFuncType = getBufferizedFunctionType(
       state.getOptions());
   OpBuilder b(returnOp);
   b.create<func::ReturnOp>(returnOp.getLoc(), returnValues);
   returnOp->erase();
 
   // 3. Rewrite the bbArgs.
   // Iterate on the original `numArgs` and replace them in order.
   // This guarantees the argument order still matches after the rewrite.
-  Block &frontBlock = funcOp.body().front();
+  Block &frontBlock = funcOp.getBody().front();
   unsigned numArgs = frontBlock.getNumArguments();
   for (unsigned idx = 0; idx < numArgs; ++idx) {
     auto bbArg = frontBlock.getArgument(0);
     auto tensorType = bbArg.getType().dyn_cast<TensorType>();
     // Non-tensor types are just forwarded.
     if (!tensorType) {
       frontBlock.addArgument(bbArg.getType(), bbArg.getLoc());
       bbArg.replaceAllUsesWith(frontBlock.getArguments().back());
getFuncOpsOrderedByCalls(ModuleOp moduleOp,
                          SmallVectorImpl<FuncOp> &orderedFuncOps,
                          DenseMap<FuncOp, DenseSet<Operation *>> &callerMap) {
   // For each FuncOp, the set of functions called by it (i.e. the union of
   // symbols of all nested CallOpInterfaceOp).
   DenseMap<FuncOp, DenseSet<FuncOp>> calledBy;
   // For each FuncOp, the number of CallOpInterface it contains.
   DenseMap<FuncOp, unsigned> numberCallOpsContainedInFuncOp;
   WalkResult res = moduleOp.walk([&](FuncOp funcOp) -> WalkResult {
-    if (!funcOp.body().empty()) {
+    if (!funcOp.getBody().empty()) {
       func::ReturnOp returnOp = getAssumedUniqueReturnOp(funcOp);
       if (!returnOp)
         return funcOp->emitError()
                << "cannot bufferize a FuncOp with tensors and "
                   "without a unique ReturnOp";
     }
 
     numberCallOpsContainedInFuncOp[funcOp] = 0;
for (const auto &it : llvm::enumerate(funcOp.getType().getInputs())) {
 
       // Compute the buffer type with desired layout and add to input argument
       // types.
       MemRefType desiredMemrefType = MemRefType::get(
           memrefType.getShape(), memrefType.getElementType(), desiredLayoutMap);
       argumentTypes.push_back(desiredMemrefType);
 
       // If funcOp's body is not empty, change the bbArg type and propagate.
-      if (!funcOp.body().empty()) {
+      if (!funcOp.getBody().empty()) {
         BlockArgument bbArg = funcOp.getArgument(argNumber);
         bbArg.setType(desiredMemrefType);
         OpBuilder b(bbArg.getContext());
         b.setInsertionPointToStart(bbArg.getOwner());
         assert(memref::CastOp::areCastCompatible(bbArg.getType(), memrefType) &&
                "layoutPostProcessing: cast incompatible");
         // Cast back to the original memrefType and let it canonicalize.
         Value cast =
for (OpOperand &opOperand : callOp->getOpOperands()) {
                                                            memRefType, buffer);
         buffer = castBuffer;
       }
       newOperands[idx] = buffer;
     }
 
     // 4. Create the new CallOp.
     Operation *newCallOp = rewriter.create<func::CallOp>(
-        callOp.getLoc(), funcOp.sym_name(), resultTypes, newOperands);
+        callOp.getLoc(), funcOp.getSymName(), resultTypes, newOperands);
     newCallOp->setAttrs(callOp->getAttrs());
     // Get replacement values for non-tensor / non-equivalent results.
     for (unsigned i = 0; i < replacementValues.size(); ++i) {
       if (replacementValues[i])
         continue;
       replacementValues[i] = newCallOp->getResult(*retValMapping[i]);
     }
 
LogicalResult mlir::linalg::comprehensive_bufferize::runModuleBufferize(
 
   // Collect bbArg/return value information after the analysis.
   options.addPostAnalysisStep(equivalentFuncOpBBArgsAnalysis);
   options.addPostAnalysisStep(funcOpBbArgReadWriteAnalysis);
 
   // Analyze ops.
   for (FuncOp funcOp : moduleState.orderedFuncOps) {
     // No body => no analysis.
-    if (funcOp.body().empty())
+    if (funcOp.getBody().empty())
       continue;
 
     // Now analyzing function.
     moduleState.analyzedFuncOps[funcOp] = FuncOpAnalysisState::InProgress;
 
     // Analyze funcOp.
     if (failed(analyzeOp(funcOp, state)))
       return failure();
LogicalResult mlir::linalg::comprehensive_bufferize::runModuleBufferize(
   }
 
   if (options.testAnalysisOnly)
     return success();
 
   // Bufferize function bodies.
   for (FuncOp funcOp : moduleState.orderedFuncOps) {
     // No body => no analysis.
-    if (funcOp.body().empty())
+    if (funcOp.getBody().empty())
       continue;
 
     if (failed(bufferizeOp(funcOp, state)))
       return failure();
   }
 
   // Bufferize function boundaries.
   for (FuncOp funcOp : moduleState.orderedFuncOps) {

mlir/lib/Dialect/Tosa/Transforms/TosaInferShapes.cpp

 /// migrating to within the regions of if/while operations.
 struct TosaInferShapes : public TosaInferShapesBase<TosaInferShapes> {
 public:
   void runOnOperation() override {
     FuncOp func = getOperation();
 
     IRRewriter rewriter(func.getContext());
 
-    propagateShapesInRegion(func.body());
+    propagateShapesInRegion(func.getBody());
 
     // Insert UnrealizedConversionCasts to guarantee ReturnOp agress with
     // the FuncOp type.
     func.walk([&](func::ReturnOp op) {
       FuncOp parent = dyn_cast<FuncOp>(op->getParentOp());
       if (!parent)
         return;
 

mlir/lib/IR/BuiltinDialect.cpp

FuncOp FuncOp::create(Location location, StringRef name, FunctionType type,
   return func;
 }
 
 void FuncOp::build(OpBuilder &builder, OperationState &state, StringRef name,
                    FunctionType type, ArrayRef<NamedAttribute> attrs,
                    ArrayRef<DictionaryAttr> argAttrs) {
   state.addAttribute(SymbolTable::getSymbolAttrName(),
                      builder.getStringAttr(name));
-  state.addAttribute(getTypeAttrName(), TypeAttr::get(type));
+  state.addAttribute(function_interface_impl::getTypeAttrName(),
+                     TypeAttr::get(type));
   state.attributes.append(attrs.begin(), attrs.end());
   state.addRegion();
 
   if (argAttrs.empty())
     return;
   assert(type.getNumInputs() == argAttrs.size());
   function_interface_impl::addArgAndResultAttrs(builder, state, argAttrs,
                                                 /*resultAttrs=*/llvm::None);

 
 //===----------------------------------------------------------------------===//
 // UnrealizedConversionCastOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 UnrealizedConversionCastOp::fold(ArrayRef<Attribute> attrOperands,
                                  SmallVectorImpl<OpFoldResult> &foldResults) {
-  OperandRange operands = inputs();
-  ResultRange results = outputs();
+  OperandRange operands = getInputs();
+  ResultRange results = getOutputs();
 
   if (operands.getType() == results.getType()) {
     foldResults.append(operands.begin(), operands.end());
     return success();
   }
 
   if (operands.empty())
     return failure();

mlir/test/lib/IR/TestPrintInvalid.cpp

StringRef getDescription() const final {
     return "Test printing invalid ops.";
   }
   void getDependentDialects(DialectRegistry &registry) const override {
     registry.insert<func::FuncDialect>();
   }
 
   void runOnOperation() override {
     Location loc = getOperation().getLoc();
-    OpBuilder builder(getOperation().body());
+    OpBuilder builder(getOperation().getBodyRegion());
     auto funcOp = builder.create<FuncOp>(
         loc, "test", FunctionType::get(getOperation().getContext(), {}, {}));
     funcOp.addEntryBlock();
     // The created function is invalid because there is no return op.
     llvm::outs() << "Invalid operation:\n" << funcOp << "\n";
     builder.setInsertionPointToEnd(&funcOp.getBody().front());
     builder.create<func::ReturnOp>(loc);
     // Now this function is valid.

mlir/unittests/Interfaces/InferTypeOpInterfaceTest.cpp

void SetUp() override {
     registry.insert<func::FuncDialect, arith::ArithmeticDialect>();
     ctx.appendDialectRegistry(registry);
     module = parseSourceString<ModuleOp>(ir, &ctx);
     mapFn = cast<FuncOp>(module->front());
   }
 
   // Create ValueShapeRange on the arith.addi operation.
   ValueShapeRange addiRange() {
-    auto &fnBody = mapFn.body();
+    auto &fnBody = mapFn.getBody();
     return std::next(fnBody.front().begin())->getOperands();
   }
 
   DialectRegistry registry;
   MLIRContext ctx;
   OwningOpRef<ModuleOp> module;
   FuncOp mapFn;
 };