[flang][mlir][NFC] Replace uses of raw accessors with prefixed accessors

[shraiysh]

Summary

kEmitAccessorPrefix_Raw is being removed, and so updating the
accessors to kEmitAccessorPrefix_Prefixed.

[clementval]

LGTM

[shraiysh]

Rebase

flang/include/flang/Optimizer/Builder/FIRBuilder.h

public:
   /// Alternatively, getResults() can be used instead of end() to end the ifOp
   /// and get the ifOp results.
   class IfBuilder {
   public:
     IfBuilder(fir::IfOp ifOp, FirOpBuilder &builder)
         : ifOp{ifOp}, builder{builder} {}
     template <typename CC>
     IfBuilder &genThen(CC func) {
-      builder.setInsertionPointToStart(&ifOp.thenRegion().front());
+      builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
       func();
       return *this;
     }
     template <typename CC>
     IfBuilder &genElse(CC func) {
-      assert(!ifOp.elseRegion().empty() && "must have else region");
-      builder.setInsertionPointToStart(&ifOp.elseRegion().front());
+      assert(!ifOp.getElseRegion().empty() && "must have else region");
+      builder.setInsertionPointToStart(&ifOp.getElseRegion().front());
       func();
       return *this;
     }
     void end() { builder.setInsertionPointAfter(ifOp); }
 
     /// End the IfOp and return the results if any.
     mlir::Operation::result_range getResults() {
       end();

flang/include/flang/Optimizer/Dialect/FIRDialect.td

 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";
   let cppNamespace = "::fir";
-  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Prefixed;
   let useDefaultTypePrinterParser = 0;
   let useDefaultAttributePrinterParser = 0;
 }
 
 #endif // FORTRAN_DIALECT_FIR_DIALECT

flang/include/flang/Optimizer/Dialect/FIROps.td

OpBuilder<(ins "mlir::Type":$inType, "bool":$pinned,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$inType,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
 
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
-    bool hasLenParams() { return !typeparams().empty(); }
-    bool hasShapeOperands() { return !shape().empty(); }
-    unsigned numLenParams() { return typeparams().size(); }
-    operand_range getLenParams() { return typeparams(); }
-    unsigned numShapeOperands() { return shape().size(); }
-    operand_range getShapeOperands() { return shape(); }
+    bool hasLenParams() { return !getTypeparams().empty(); }
+    bool hasShapeOperands() { return !getShape().empty(); }
+    unsigned numLenParams() { return getTypeparams().size(); }
+    operand_range getLenParams() { return getTypeparams(); }
+    unsigned numShapeOperands() { return getShape().size(); }
+    operand_range getShapeOperands() { return getShape(); }
     static mlir::Type getRefTy(mlir::Type ty);
   }];
 }
 
 def fir_AllocMemOp : fir_Op<"allocmem",
     [MemoryEffects<[MemAlloc<DefaultResource>]>, AttrSizedOperandSegments]> {
   let summary = "allocate storage on the heap for an object of a given type";
 
OpBuilder<(ins "mlir::Type":$in_type, "llvm::StringRef":$uniq_name,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>,
     OpBuilder<(ins "mlir::Type":$in_type,
       CArg<"mlir::ValueRange", "{}">:$typeparams,
       CArg<"mlir::ValueRange", "{}">:$shape,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>];
 
   let extraClassDeclaration = [{
     mlir::Type getAllocatedType();
-    bool hasLenParams() { return !typeparams().empty(); }
-    bool hasShapeOperands() { return !shape().empty(); }
-    unsigned numLenParams() { return typeparams().size(); }
-    operand_range getLenParams() { return typeparams(); }
-    unsigned numShapeOperands() { return shape().size(); }
-    operand_range getShapeOperands() { return shape(); }
+    bool hasLenParams() { return !getTypeparams().empty(); }
+    bool hasShapeOperands() { return !getShape().empty(); }
+    unsigned numLenParams() { return getTypeparams().size(); }
+    operand_range getLenParams() { return getTypeparams(); }
+    unsigned numShapeOperands() { return getShape().size(); }
+    operand_range getShapeOperands() { return getShape(); }
     static mlir::Type getRefTy(mlir::Type ty);
   }];
 }
 
 def fir_FreeMemOp : fir_Op<"freemem", [MemoryEffects<[MemFree]>]> {
   let summary = "free a heap object";
 
   let description = [{
def fir_EmboxOp : fir_Op<"embox", [NoSideEffect, AttrSizedOperandSegments]> {
   let assemblyFormat = [{
     $memref (`(` $shape^ `)`)? (`[` $slice^ `]`)? (`typeparams` $typeparams^)?
       (`map` $accessMap^)? attr-dict `:` functional-type(operands, results)
   }];
 
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
-    bool hasLenParams() { return !typeparams().empty(); }
-    unsigned numLenParams() { return typeparams().size(); }
+    bool hasLenParams() { return !getTypeparams().empty(); }
+    unsigned numLenParams() { return getTypeparams().size(); }
   }];
 }
 
 def fir_ReboxOp : fir_Op<"rebox", [NoSideEffect, AttrSizedOperandSegments]> {
   let summary =
       "create a box given another box and (optional) dimension information";
 
   let description = [{
def fir_FieldIndexOp : fir_OneResultOp<"field_index", [NoSideEffect]> {
   let hasCustomAssemblyFormat = 1;
 
   let builders = [OpBuilder<(ins "llvm::StringRef":$fieldName,
       "mlir::Type":$recTy, CArg<"mlir::ValueRange","{}">:$operands)>];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
-    llvm::StringRef getFieldName() { return field_id(); }
+    llvm::StringRef getFieldName() { return getFieldId(); }
   }];
 }
 
 def fir_ShapeOp : fir_Op<"shape", [NoSideEffect]> {
 
   let summary = "generate an abstract shape vector of type `!fir.shape`";
 
   let description = [{
def fir_ShapeShiftOp : fir_Op<"shape_shift", [NoSideEffect]> {
   }];
 
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
     // Logically unzip the origins from the extent values.
     std::vector<mlir::Value> getOrigins() {
       std::vector<mlir::Value> result;
-      for (auto i : llvm::enumerate(pairs()))
+      for (auto i : llvm::enumerate(getPairs()))
         if (!(i.index() & 1))
           result.push_back(i.value());
       return result;
     }
 
     // Logically unzip the extents from the origin values.
     std::vector<mlir::Value> getExtents() {
       std::vector<mlir::Value> result;
-      for (auto i : llvm::enumerate(pairs()))
+      for (auto i : llvm::enumerate(getPairs()))
         if (i.index() & 1)
           result.push_back(i.value());
       return result;
     }
   }];
 }
 
 def fir_ShiftOp : fir_Op<"shift", [NoSideEffect]> {
let builders = [
     OpBuilder<(ins "mlir::ValueRange":$triples,
       CArg<"mlir::ValueRange", "llvm::None">:$fields,
       CArg<"mlir::ValueRange", "llvm::None">:$substr)>
   ];
 
   let hasVerifier = 1;
 
   let extraClassDeclaration = [{
-    unsigned getOutRank() { return getOutputRank(triples()); }
+    unsigned getOutRank() { return getOutputRank(getTriples()); }
     static unsigned getOutputRank(mlir::ValueRange triples);
   }];
 }
 
 def fir_InsertValueOp : fir_OneResultOp<"insert_value", [NoSideEffect]> {
   let summary = "insert a new sub-value into a copy of an existing aggregate";
 
   let description = [{
bool hasIterOperands() {
       return (*this)->getNumOperands() > getNumControlOperands();
     }
     /// Get Number of loop-carried values
     unsigned getNumIterOperands() {
       return (*this)->getNumOperands() - getNumControlOperands();
     }
 
     /// Get the body of the loop
-    mlir::Block *getBody() { return &region().front(); }
+    mlir::Block *getBody() { return &getRegion().front(); }
 
     void setUnordered() {
-      unorderedAttr(mlir::UnitAttr::get(getContext()));
+      setUnorderedAttr(mlir::UnitAttr::get(getContext()));
     }
 
     mlir::BlockArgument iterArgToBlockArg(mlir::Value iterArg);
     void resultToSourceOps(llvm::SmallVectorImpl<mlir::Value> &results,
                            unsigned resultNum);
     mlir::Value blockArgToSourceOp(unsigned blockArgNum);
   }];
 }
def fir_IfOp : region_Op<"if", [NoRegionArguments]> {
   let builders = [
     OpBuilder<(ins "mlir::Value":$cond, "bool":$withElseRegion)>,
     OpBuilder<(ins "mlir::TypeRange":$resultTypes, "mlir::Value":$cond,
         "bool":$withElseRegion)>
   ];
 
   let extraClassDeclaration = [{
     mlir::OpBuilder getThenBodyBuilder() {
-      assert(!thenRegion().empty() && "Unexpected empty 'where' region.");
-      mlir::Block &body = thenRegion().front();
+      assert(!getThenRegion().empty() && "Unexpected empty 'where' region.");
+      mlir::Block &body = getThenRegion().front();
       return mlir::OpBuilder(&body, std::prev(body.end()));
     }
     mlir::OpBuilder getElseBodyBuilder() {
-      assert(!elseRegion().empty() && "Unexpected empty 'other' region.");
-      mlir::Block &body = elseRegion().front();
+      assert(!getElseRegion().empty() && "Unexpected empty 'other' region.");
+      mlir::Block &body = getElseRegion().front();
       return mlir::OpBuilder(&body, std::prev(body.end()));
     }
 
     void resultToSourceOps(llvm::SmallVectorImpl<mlir::Value> &results,
                            unsigned resultNum);
   }];
 }
 
OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef getFinalValueAttrNameStr() {
       return "finalValue";
     }
-    mlir::Block *getBody() { return &region().front(); }
+    mlir::Block *getBody() { return &getRegion().front(); }
     mlir::Value getIterateVar() { return getBody()->getArgument(1); }
     mlir::Value getInductionVar() { return getBody()->getArgument(0); }
     mlir::OpBuilder getBodyBuilder() {
       return mlir::OpBuilder(getBody(), std::prev(getBody()->end()));
     }
     mlir::Block::BlockArgListType getRegionIterArgs() {
       return getBody()->getArguments().drop_front();
     }
let extraClassDeclaration = [{
     mlir::Type getType() {
       return typeAttr().getValue();
     }
 
     /// The semantic type of the global
     mlir::Type resultType();
 
     /// Return the initializer attribute if it exists, or a null attribute.
-    Attribute getValueOrNull() { return initVal().getValueOr(Attribute()); }
+    Attribute getValueOrNull() { return getInitVal().getValueOr(Attribute()); }
 
     /// Append the next initializer value to the `GlobalOp` to construct
     /// the variable's initial value.
     void appendInitialValue(mlir::Operation *op);
 
     /// A GlobalOp has one block.
     mlir::Block &getBlock() { return getRegion().front(); }
 

flang/lib/Optimizer/Builder/Character.cpp

if (!resultLen && charTy.getLen() != fir::CharacterType::unknownLen())
       resultLen = builder.createIntegerConstant(loc, lenType, charTy.getLen());
   } else if (auto boxCharType = type.dyn_cast<fir::BoxCharType>()) {
     auto refType = builder.getRefType(boxCharType.getEleTy());
     // If the embox is accessible, use its operand to avoid filling
     // the generated fir with embox/unbox.
     mlir::Value boxCharLen;
     if (auto *definingOp = character.getDefiningOp()) {
       if (auto box = dyn_cast<fir::EmboxCharOp>(definingOp)) {
-        base = box.memref();
-        boxCharLen = box.len();
+        base = box.getMemref();
+        boxCharLen = box.getLen();
       }
     }
     if (!boxCharLen) {
       auto unboxed =
           builder.create<fir::UnboxCharOp>(loc, refType, lenType, character);
       base = builder.createConvert(loc, refType, unboxed.getResult(0));
       boxCharLen = unboxed.getResult(1);
     }

flang/lib/Optimizer/Builder/MutableBox.cpp

 void fir::factory::genFinalization(fir::FirOpBuilder &builder,
                                    mlir::Location loc,
                                    const fir::MutableBoxValue &box) {
   auto addr = MutablePropertyReader(builder, loc, box).readBaseAddress();
   auto isAllocated = builder.genIsNotNull(loc, addr);
   auto ifOp = builder.create<fir::IfOp>(loc, isAllocated,
                                         /*withElseRegion=*/false);
   auto insPt = builder.saveInsertionPoint();
-  builder.setInsertionPointToStart(&ifOp.thenRegion().front());
+  builder.setInsertionPointToStart(&ifOp.getThenRegion().front());
   genFinalizeAndFree(builder, loc, addr);
   builder.restoreInsertionPoint(insPt);
 }
 
 //===----------------------------------------------------------------------===//
 // MutableBoxValue writing interface implementation
 //===----------------------------------------------------------------------===//
 

flang/lib/Optimizer/CodeGen/CodeGen.cpp

 struct AddrOfOpConversion : public FIROpConversion<fir::AddrOfOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::AddrOfOp addr, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto ty = convertType(addr.getType());
     rewriter.replaceOpWithNewOp<mlir::LLVM::AddressOfOp>(
-        addr, ty, addr.symbol().getRootReference().getValue());
+        addr, ty, addr.getSymbol().getRootReference().getValue());
     return success();
   }
 };
 } // namespace
 
 /// Lookup the function to compute the memory size of this parametric derived
 /// type. The size of the object may depend on the LEN type parameters of the
 /// derived type.
struct BoxAddrOpConversion : public FIROpConversion<fir::BoxAddrOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::BoxAddrOp boxaddr, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Value a = adaptor.getOperands()[0];
     auto loc = boxaddr.getLoc();
     mlir::Type ty = convertType(boxaddr.getType());
-    if (auto argty = boxaddr.val().getType().dyn_cast<fir::BoxType>()) {
+    if (auto argty = boxaddr.getVal().getType().dyn_cast<fir::BoxType>()) {
       rewriter.replaceOp(boxaddr, loadBaseAddrFromBox(loc, ty, a, rewriter));
     } else {
       auto c0attr = rewriter.getI32IntegerAttr(0);
       auto c0 = mlir::ArrayAttr::get(boxaddr.getContext(), c0attr);
       rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(boxaddr, ty, a,
                                                               c0);
     }
     return success();

 struct CmpcOpConversion : public FIROpConversion<fir::CmpcOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::CmpcOp cmp, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::ValueRange operands = adaptor.getOperands();
     mlir::MLIRContext *ctxt = cmp.getContext();
-    mlir::Type eleTy = convertType(getComplexEleTy(cmp.lhs().getType()));
+    mlir::Type eleTy = convertType(getComplexEleTy(cmp.getLhs().getType()));
     mlir::Type resTy = convertType(cmp.getType());
     mlir::Location loc = cmp.getLoc();
     auto pos0 = mlir::ArrayAttr::get(ctxt, rewriter.getI32IntegerAttr(0));
     SmallVector<mlir::Value, 2> rp{rewriter.create<mlir::LLVM::ExtractValueOp>(
                                        loc, eleTy, operands[0], pos0),
                                    rewriter.create<mlir::LLVM::ExtractValueOp>(
                                        loc, eleTy, operands[1], pos0)};
     auto rcp =
struct ConvertOpConversion : public FIROpConversion<fir::ConvertOp> {
 
   static bool isFloatingPointTy(mlir::Type ty) {
     return ty.isa<mlir::FloatType>();
   }
 
   mlir::LogicalResult
   matchAndRewrite(fir::ConvertOp convert, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto fromTy = convertType(convert.value().getType());
-    auto toTy = convertType(convert.res().getType());
+    auto fromTy = convertType(convert.getValue().getType());
+    auto toTy = convertType(convert.getRes().getType());
     mlir::Value op0 = adaptor.getOperands()[0];
     if (fromTy == toTy) {
       rewriter.replaceOp(convert, op0);
       return success();
     }
     auto loc = convert.getLoc();
     auto convertFpToFp = [&](mlir::Value val, unsigned fromBits,
                              unsigned toBits, mlir::Type toTy) -> mlir::Value {
       if (fromBits == toBits) {
         // TODO: Converting between two floating-point representations with the
         // same bitwidth is not allowed for now.
         mlir::emitError(loc,
                         "cannot implicitly convert between two floating-point "
                         "representations of the same bitwidth");
         return {};
       }
       if (fromBits > toBits)
         return rewriter.create<mlir::LLVM::FPTruncOp>(loc, toTy, val);
       return rewriter.create<mlir::LLVM::FPExtOp>(loc, toTy, val);
     };
     // Complex to complex conversion.
-    if (fir::isa_complex(convert.value().getType()) &&
-        fir::isa_complex(convert.res().getType())) {
+    if (fir::isa_complex(convert.getValue().getType()) &&
+        fir::isa_complex(convert.getRes().getType())) {
       // Special case: handle the conversion of a complex such that both the
       // real and imaginary parts are converted together.
       auto zero = mlir::ArrayAttr::get(convert.getContext(),
                                        rewriter.getI32IntegerAttr(0));
       auto one = mlir::ArrayAttr::get(convert.getContext(),
                                       rewriter.getI32IntegerAttr(1));
-      auto ty = convertType(getComplexEleTy(convert.value().getType()));
+      auto ty = convertType(getComplexEleTy(convert.getValue().getType()));
       auto rp = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, op0, zero);
       auto ip = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, op0, one);
-      auto nt = convertType(getComplexEleTy(convert.res().getType()));
+      auto nt = convertType(getComplexEleTy(convert.getRes().getType()));
       auto fromBits = mlir::LLVM::getPrimitiveTypeSizeInBits(ty);
       auto toBits = mlir::LLVM::getPrimitiveTypeSizeInBits(nt);
       auto rc = convertFpToFp(rp, fromBits, toBits, nt);
       auto ic = convertFpToFp(ip, fromBits, toBits, nt);
       auto un = rewriter.create<mlir::LLVM::UndefOp>(loc, toTy);
       auto i1 =
           rewriter.create<mlir::LLVM::InsertValueOp>(loc, toTy, un, rc, zero);
       rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(convert, toTy, i1,
struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> {
   mlir::LogicalResult
   matchAndRewrite(fir::GlobalOp global, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     auto tyAttr = convertType(global.getType());
     if (global.getType().isa<fir::BoxType>())
       tyAttr = tyAttr.cast<mlir::LLVM::LLVMPointerType>().getElementType();
     auto loc = global.getLoc();
     mlir::Attribute initAttr{};
-    if (global.initVal())
-      initAttr = global.initVal().getValue();
-    auto linkage = convertLinkage(global.linkName());
-    auto isConst = global.constant().hasValue();
+    if (global.getInitVal())
+      initAttr = global.getInitVal().getValue();
+    auto linkage = convertLinkage(global.getLinkName());
+    auto isConst = global.getConstant().hasValue();
     auto g = rewriter.create<mlir::LLVM::GlobalOp>(
         loc, tyAttr, isConst, linkage, global.getSymName(), initAttr);
     auto &gr = g.getInitializerRegion();
-    rewriter.inlineRegionBefore(global.region(), gr, gr.end());
+    rewriter.inlineRegionBefore(global.getRegion(), gr, gr.end());
     if (!gr.empty()) {
       // Replace insert_on_range with a constant dense attribute if the
       // initialization is on the full range.
       auto insertOnRangeOps = gr.front().getOps<fir::InsertOnRangeOp>();
       for (auto insertOp : insertOnRangeOps) {
-        if (isFullRange(insertOp.coor(), insertOp.getType())) {
+        if (isFullRange(insertOp.getCoor(), insertOp.getType())) {
           auto seqTyAttr = convertType(insertOp.getType());
-          auto *op = insertOp.val().getDefiningOp();
+          auto *op = insertOp.getVal().getDefiningOp();
           auto constant = mlir::dyn_cast<mlir::arith::ConstantOp>(op);
           if (!constant) {
             auto convertOp = mlir::dyn_cast<fir::ConvertOp>(op);
             if (!convertOp)
               continue;
             constant = cast<mlir::arith::ConstantOp>(
-                convertOp.value().getDefiningOp());
+                convertOp.getValue().getDefiningOp());
           }
           mlir::Type vecType = mlir::VectorType::get(
               insertOp.getType().getShape(), constant.getType());
           auto denseAttr = mlir::DenseElementsAttr::get(
               vecType.cast<ShapedType>(), constant.getValue());
           rewriter.setInsertionPointAfter(insertOp);
           rewriter.replaceOpWithNewOp<mlir::arith::ConstantOp>(
               insertOp, seqTyAttr, denseAttr);

 } // namespace
 
 template <typename OP>
 static void selectMatchAndRewrite(fir::LLVMTypeConverter &lowering, OP select,
                                   typename OP::Adaptor adaptor,
                                   mlir::ConversionPatternRewriter &rewriter) {
   unsigned conds = select.getNumConditions();
   auto cases = select.getCases().getValue();
-  mlir::Value selector = adaptor.selector();
+  mlir::Value selector = adaptor.getSelector();
   auto loc = select.getLoc();
   assert(conds > 0 && "select must have cases");
 
   llvm::SmallVector<mlir::Block *> destinations;
   llvm::SmallVector<mlir::ValueRange> destinationsOperands;
   mlir::Block *defaultDestination;
   mlir::ValueRange defaultOperands;
   llvm::SmallVector<int32_t> caseValues;

 
 /// `fir.store` --> `llvm.store`
 struct StoreOpConversion : public FIROpConversion<fir::StoreOp> {
   using FIROpConversion::FIROpConversion;
 
   mlir::LogicalResult
   matchAndRewrite(fir::StoreOp store, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    if (store.value().getType().isa<fir::BoxType>()) {
+    if (store.getValue().getType().isa<fir::BoxType>()) {
       // fir.box value is actually in memory, load it first before storing it.
       mlir::Location loc = store.getLoc();
       mlir::Type boxPtrTy = adaptor.getOperands()[0].getType();
       auto val = rewriter.create<mlir::LLVM::LoadOp>(
           loc, boxPtrTy.cast<mlir::LLVM::LLVMPointerType>().getElementType(),
           adaptor.getOperands()[0]);
       rewriter.replaceOpWithNewOp<mlir::LLVM::StoreOp>(
           store, val, adaptor.getOperands()[1]);

 struct ExtractValueOpConversion
     : public FIROpAndTypeConversion<fir::ExtractValueOp>,
       public ValueOpCommon {
   using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   mlir::LogicalResult
   doRewrite(fir::ExtractValueOp extractVal, mlir::Type ty, OpAdaptor adaptor,
             mlir::ConversionPatternRewriter &rewriter) const override {
-    auto attrs = collectIndices(rewriter, extractVal.coor());
+    auto attrs = collectIndices(rewriter, extractVal.getCoor());
     toRowMajor(attrs, adaptor.getOperands()[0].getType());
     auto position = mlir::ArrayAttr::get(extractVal.getContext(), attrs);
     rewriter.replaceOpWithNewOp<mlir::LLVM::ExtractValueOp>(
         extractVal, ty, adaptor.getOperands()[0], position);
     return success();
   }
 };
 
 /// InsertValue is the generalized instruction for the composition of new
 /// aggregate type values.
 struct InsertValueOpConversion
     : public FIROpAndTypeConversion<fir::InsertValueOp>,
       public ValueOpCommon {
   using FIROpAndTypeConversion::FIROpAndTypeConversion;
 
   mlir::LogicalResult
   doRewrite(fir::InsertValueOp insertVal, mlir::Type ty, OpAdaptor adaptor,
             mlir::ConversionPatternRewriter &rewriter) const override {
-    auto attrs = collectIndices(rewriter, insertVal.coor());
+    auto attrs = collectIndices(rewriter, insertVal.getCoor());
     toRowMajor(attrs, adaptor.getOperands()[0].getType());
     auto position = mlir::ArrayAttr::get(insertVal.getContext(), attrs);
     rewriter.replaceOpWithNewOp<mlir::LLVM::InsertValueOp>(
         insertVal, ty, adaptor.getOperands()[0], adaptor.getOperands()[1],
         position);
     return success();
   }
 };
while (auto t = type.dyn_cast<mlir::LLVM::LLVMArrayType>()) {
       dims.push_back(t.getNumElements());
       type = t.getElementType();
     }
 
     SmallVector<uint64_t> lBounds;
     SmallVector<uint64_t> uBounds;
 
     // Unzip the upper and lower bound and convert to a row major format.
-    mlir::DenseIntElementsAttr coor = range.coor();
+    mlir::DenseIntElementsAttr coor = range.getCoor();
     auto reversedCoor = llvm::reverse(coor.getValues<int64_t>());
     for (auto i = reversedCoor.begin(), e = reversedCoor.end(); i != e; ++i) {
       uBounds.push_back(*i++);
       lBounds.push_back(*i);
     }
 
     auto &subscripts = lBounds;
     auto loc = range.getLoc();
struct IsPresentOpConversion : public FIROpConversion<fir::IsPresentOp> {
 
   mlir::LogicalResult
   matchAndRewrite(fir::IsPresentOp isPresent, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
     mlir::Type idxTy = lowerTy().indexType();
     mlir::Location loc = isPresent.getLoc();
     auto ptr = adaptor.getOperands()[0];
 
-    if (isPresent.val().getType().isa<fir::BoxCharType>()) {
+    if (isPresent.getVal().getType().isa<fir::BoxCharType>()) {
       auto structTy = ptr.getType().cast<mlir::LLVM::LLVMStructType>();
       assert(!structTy.isOpaque() && !structTy.getBody().empty());
 
       mlir::Type ty = structTy.getBody()[0];
       mlir::MLIRContext *ctx = isPresent.getContext();
       auto c0 = mlir::ArrayAttr::get(ctx, rewriter.getI32IntegerAttr(0));
       ptr = rewriter.create<mlir::LLVM::ExtractValueOp>(loc, ty, ptr, c0);
     }

 /// the record is static or dynamic.
 struct FieldIndexOpConversion : public FIROpConversion<fir::FieldIndexOp> {
   using FIROpConversion::FIROpConversion;
 
   // NB: most field references should be resolved by this point
   mlir::LogicalResult
   matchAndRewrite(fir::FieldIndexOp field, OpAdaptor adaptor,
                   mlir::ConversionPatternRewriter &rewriter) const override {
-    auto recTy = field.on_type().cast<fir::RecordType>();
-    unsigned index = recTy.getFieldIndex(field.field_id());
+    auto recTy = field.getOnType().cast<fir::RecordType>();
+    unsigned index = recTy.getFieldIndex(field.getFieldId());
 
     if (!fir::hasDynamicSize(recTy)) {
       // Derived type has compile-time constant layout. Return index of the
       // component type in the parent type (to be used in GEP).
       rewriter.replaceOp(field, mlir::ValueRange{genConstantOffset(
                                     field.getLoc(), rewriter, index)});
       return success();
     }
 
     // Derived type has compile-time constant layout. Call the compiler
     // generated function to determine the byte offset of the field at runtime.
     // This returns a non-constant.
     FlatSymbolRefAttr symAttr = mlir::SymbolRefAttr::get(
-        field.getContext(), getOffsetMethodName(recTy, field.field_id()));
+        field.getContext(), getOffsetMethodName(recTy, field.getFieldId()));
     NamedAttribute callAttr = rewriter.getNamedAttr("callee", symAttr);
     NamedAttribute fieldAttr = rewriter.getNamedAttr(
         "field", mlir::IntegerAttr::get(lowerTy().indexType(), index));
     rewriter.replaceOpWithNewOp<mlir::LLVM::CallOp>(
         field, lowerTy().offsetType(), adaptor.getOperands(),
         llvm::ArrayRef<mlir::NamedAttribute>{callAttr, fieldAttr});
     return success();
   }
doRewriteBox(fir::CoordinateOp coor, mlir::Type ty, mlir::ValueRange operands,
 
     mlir::Value boxBaseAddr = operands[0];
 
     // 1. SPECIAL CASE (uses `fir.len_param_index`):
     //   %box = ... : !fir.box<!fir.type<derived{len1:i32}>>
     //   %lenp = fir.len_param_index len1, !fir.type<derived{len1:i32}>
     //   %addr = coordinate_of %box, %lenp
     if (coor.getNumOperands() == 2) {
-      mlir::Operation *coordinateDef = (*coor.coor().begin()).getDefiningOp();
+      mlir::Operation *coordinateDef =
+          (*coor.getCoor().begin()).getDefiningOp();
       if (isa_and_nonnull<fir::LenParamIndexOp>(coordinateDef)) {
         TODO(loc,
              "fir.coordinate_of - fir.len_param_index is not supported yet");
       }
     }
 
     // 2. GENERAL CASE:
     // 2.1. (`fir.array`)

flang/lib/Optimizer/CodeGen/PreCGRewrite.cpp

 //===----------------------------------------------------------------------===//
 
 using namespace fir;
 
 #define DEBUG_TYPE "flang-codegen-rewrite"
 
 static void populateShape(llvm::SmallVectorImpl<mlir::Value> &vec,
                           ShapeOp shape) {
-  vec.append(shape.extents().begin(), shape.extents().end());
+  vec.append(shape.getExtents().begin(), shape.getExtents().end());
 }
 
 // Operands of fir.shape_shift split into two vectors.
 static void populateShapeAndShift(llvm::SmallVectorImpl<mlir::Value> &shapeVec,
                                   llvm::SmallVectorImpl<mlir::Value> &shiftVec,
                                   ShapeShiftOp shift) {
-  auto endIter = shift.pairs().end();
-  for (auto i = shift.pairs().begin(); i != endIter;) {
+  auto endIter = shift.getPairs().end();
+  for (auto i = shift.getPairs().begin(); i != endIter;) {
     shiftVec.push_back(*i++);
     shapeVec.push_back(*i++);
   }
 }
 
 static void populateShift(llvm::SmallVectorImpl<mlir::Value> &vec,
                           ShiftOp shift) {
-  vec.append(shift.origins().begin(), shift.origins().end());
+  vec.append(shift.getOrigins().begin(), shift.getOrigins().end());
 }
 
 namespace {
 
 /// Convert fir.embox to the extended form where necessary.
 ///
 /// The embox operation can take arguments that specify multidimensional array
 /// properties at runtime. These properties may be shared between distinct
mlir::LogicalResult rewriteStaticShape(EmboxOp embox,
     llvm::SmallVector<mlir::Value> shapeOpers;
     auto idxTy = rewriter.getIndexType();
     for (auto ext : seqTy.getShape()) {
       auto iAttr = rewriter.getIndexAttr(ext);
       auto extVal = rewriter.create<mlir::arith::ConstantOp>(loc, idxTy, iAttr);
       shapeOpers.push_back(extVal);
     }
     auto xbox = rewriter.create<cg::XEmboxOp>(
-        loc, embox.getType(), embox.memref(), shapeOpers, llvm::None,
-        llvm::None, llvm::None, llvm::None, embox.typeparams());
+        loc, embox.getType(), embox.getMemref(), shapeOpers, llvm::None,
+        llvm::None, llvm::None, llvm::None, embox.getTypeparams());
     LLVM_DEBUG(llvm::dbgs() << "rewriting " << embox << " to " << xbox << '\n');
     rewriter.replaceOp(embox, xbox.getOperation()->getResults());
     return mlir::success();
   }
 
   mlir::LogicalResult rewriteDynamicShape(EmboxOp embox,
                                           mlir::PatternRewriter &rewriter,
                                           mlir::Value shapeVal) const {
     auto loc = embox.getLoc();
     auto shapeOp = dyn_cast<ShapeOp>(shapeVal.getDefiningOp());
     llvm::SmallVector<mlir::Value> shapeOpers;
     llvm::SmallVector<mlir::Value> shiftOpers;
     if (shapeOp) {
       populateShape(shapeOpers, shapeOp);
     } else {
       auto shiftOp = dyn_cast<ShapeShiftOp>(shapeVal.getDefiningOp());
       assert(shiftOp && "shape is neither fir.shape nor fir.shape_shift");
       populateShapeAndShift(shapeOpers, shiftOpers, shiftOp);
     }
     llvm::SmallVector<mlir::Value> sliceOpers;
     llvm::SmallVector<mlir::Value> subcompOpers;
     llvm::SmallVector<mlir::Value> substrOpers;
     if (auto s = embox.getSlice())
       if (auto sliceOp = dyn_cast_or_null<SliceOp>(s.getDefiningOp())) {
-        sliceOpers.assign(sliceOp.triples().begin(), sliceOp.triples().end());
-        subcompOpers.assign(sliceOp.fields().begin(), sliceOp.fields().end());
-        substrOpers.assign(sliceOp.substr().begin(), sliceOp.substr().end());
+        sliceOpers.assign(sliceOp.getTriples().begin(),
+                          sliceOp.getTriples().end());
+        subcompOpers.assign(sliceOp.getFields().begin(),
+                            sliceOp.getFields().end());
+        substrOpers.assign(sliceOp.getSubstr().begin(),
+                           sliceOp.getSubstr().end());
       }
     auto xbox = rewriter.create<cg::XEmboxOp>(
-        loc, embox.getType(), embox.memref(), shapeOpers, shiftOpers,
-        sliceOpers, subcompOpers, substrOpers, embox.typeparams());
+        loc, embox.getType(), embox.getMemref(), shapeOpers, shiftOpers,
+        sliceOpers, subcompOpers, substrOpers, embox.getTypeparams());
     LLVM_DEBUG(llvm::dbgs() << "rewriting " << embox << " to " << xbox << '\n');
     rewriter.replaceOp(embox, xbox.getOperation()->getResults());
     return mlir::success();
   }
 };
 
 /// Convert fir.rebox to the extended form where necessary.
 ///
public:
   using OpRewritePattern::OpRewritePattern;
 
   mlir::LogicalResult
   matchAndRewrite(ReboxOp rebox,
                   mlir::PatternRewriter &rewriter) const override {
     auto loc = rebox.getLoc();
     llvm::SmallVector<mlir::Value> shapeOpers;
     llvm::SmallVector<mlir::Value> shiftOpers;
-    if (auto shapeVal = rebox.shape()) {
+    if (auto shapeVal = rebox.getShape()) {
       if (auto shapeOp = dyn_cast<ShapeOp>(shapeVal.getDefiningOp()))
         populateShape(shapeOpers, shapeOp);
       else if (auto shiftOp = dyn_cast<ShapeShiftOp>(shapeVal.getDefiningOp()))
         populateShapeAndShift(shapeOpers, shiftOpers, shiftOp);
       else if (auto shiftOp = dyn_cast<ShiftOp>(shapeVal.getDefiningOp()))
         populateShift(shiftOpers, shiftOp);
       else
         return mlir::failure();
     }
     llvm::SmallVector<mlir::Value> sliceOpers;
     llvm::SmallVector<mlir::Value> subcompOpers;
     llvm::SmallVector<mlir::Value> substrOpers;
-    if (auto s = rebox.slice())
+    if (auto s = rebox.getSlice())
       if (auto sliceOp = dyn_cast_or_null<SliceOp>(s.getDefiningOp())) {
-        sliceOpers.append(sliceOp.triples().begin(), sliceOp.triples().end());
-        subcompOpers.append(sliceOp.fields().begin(), sliceOp.fields().end());
-        substrOpers.append(sliceOp.substr().begin(), sliceOp.substr().end());
+        sliceOpers.append(sliceOp.getTriples().begin(),
+                          sliceOp.getTriples().end());
+        subcompOpers.append(sliceOp.getFields().begin(),
+                            sliceOp.getFields().end());
+        substrOpers.append(sliceOp.getSubstr().begin(),
+                           sliceOp.getSubstr().end());
       }
 
     auto xRebox = rewriter.create<cg::XReboxOp>(
-        loc, rebox.getType(), rebox.box(), shapeOpers, shiftOpers, sliceOpers,
-        subcompOpers, substrOpers);
+        loc, rebox.getType(), rebox.getBox(), shapeOpers, shiftOpers,
+        sliceOpers, subcompOpers, substrOpers);
     LLVM_DEBUG(llvm::dbgs()
                << "rewriting " << rebox << " to " << xRebox << '\n');
     rewriter.replaceOp(rebox, xRebox.getOperation()->getResults());
     return mlir::success();
   }
 };
 
 /// Convert all fir.array_coor to the extended form.
public:
   using OpRewritePattern::OpRewritePattern;
 
   mlir::LogicalResult
   matchAndRewrite(ArrayCoorOp arrCoor,
                   mlir::PatternRewriter &rewriter) const override {
     auto loc = arrCoor.getLoc();
     llvm::SmallVector<mlir::Value> shapeOpers;
     llvm::SmallVector<mlir::Value> shiftOpers;
-    if (auto shapeVal = arrCoor.shape()) {
+    if (auto shapeVal = arrCoor.getShape()) {
       if (auto shapeOp = dyn_cast<ShapeOp>(shapeVal.getDefiningOp()))
         populateShape(shapeOpers, shapeOp);
       else if (auto shiftOp = dyn_cast<ShapeShiftOp>(shapeVal.getDefiningOp()))
         populateShapeAndShift(shapeOpers, shiftOpers, shiftOp);
       else if (auto shiftOp = dyn_cast<ShiftOp>(shapeVal.getDefiningOp()))
         populateShift(shiftOpers, shiftOp);
       else
         return mlir::failure();
     }
     llvm::SmallVector<mlir::Value> sliceOpers;
     llvm::SmallVector<mlir::Value> subcompOpers;
-    if (auto s = arrCoor.slice())
+    if (auto s = arrCoor.getSlice())
       if (auto sliceOp = dyn_cast_or_null<SliceOp>(s.getDefiningOp())) {
-        sliceOpers.append(sliceOp.triples().begin(), sliceOp.triples().end());
-        subcompOpers.append(sliceOp.fields().begin(), sliceOp.fields().end());
-        assert(sliceOp.substr().empty() &&
+        sliceOpers.append(sliceOp.getTriples().begin(),
+                          sliceOp.getTriples().end());
+        subcompOpers.append(sliceOp.getFields().begin(),
+                            sliceOp.getFields().end());
+        assert(sliceOp.getSubstr().empty() &&
                "Don't allow substring operations on array_coor. This "
                "restriction may be lifted in the future.");
       }
     auto xArrCoor = rewriter.create<cg::XArrayCoorOp>(
-        loc, arrCoor.getType(), arrCoor.memref(), shapeOpers, shiftOpers,
-        sliceOpers, subcompOpers, arrCoor.indices(), arrCoor.typeparams());
+        loc, arrCoor.getType(), arrCoor.getMemref(), shapeOpers, shiftOpers,
+        sliceOpers, subcompOpers, arrCoor.getIndices(),
+        arrCoor.getTypeparams());
     LLVM_DEBUG(llvm::dbgs()
                << "rewriting " << arrCoor << " to " << xArrCoor << '\n');
     rewriter.replaceOp(arrCoor, xArrCoor.getOperation()->getResults());
     return mlir::success();
   }
 };
 
 class CodeGenRewrite : public CodeGenRewriteBase<CodeGenRewrite> {

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

void convertCallOp(A callOp) {
     llvm::SmallVector<mlir::Type> newResTys;
     llvm::SmallVector<mlir::Type> newInTys;
     llvm::SmallVector<mlir::Value> newOpers;
 
     // If the call is indirect, the first argument must still be the function
     // to call.
     int dropFront = 0;
     if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
-      if (!callOp.callee().hasValue()) {
+      if (!callOp.getCallee().hasValue()) {
         newInTys.push_back(fnTy.getInput(0));
         newOpers.push_back(callOp.getOperand(0));
         dropFront = 1;
       }
     }
 
     // Determine the rewrite function, `wrap`, for the result value.
     llvm::Optional<std::function<mlir::Value(mlir::Operation *)>> wrap;
for (auto e : llvm::enumerate(
                        callOp.getOperands().drop_front(dropFront)))) {
       mlir::Type ty = std::get<0>(e.value());
       mlir::Value oper = std::get<1>(e.value());
       unsigned index = e.index();
       llvm::TypeSwitch<mlir::Type>(ty)
           .template Case<BoxCharType>([&](BoxCharType boxTy) {
             bool sret;
             if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
-              sret = callOp.callee() &&
+              sret = callOp.getCallee() &&
                      functionArgIsSRet(index,
                                        getModule().lookupSymbol<mlir::FuncOp>(
-                                           *callOp.callee()));
+                                           *callOp.getCallee()));
             } else {
               // TODO: dispatch case; how do we put arguments on a call?
               // We cannot put both an sret and the dispatch object first.
               sret = false;
               TODO(loc, "dispatch + sret not supported yet");
             }
             auto m = specifics->boxcharArgumentType(boxTy.getEleTy(), sret);
             auto unbox =
for (auto e : llvm::enumerate(
           })
           .template Case<mlir::ComplexType>([&](mlir::ComplexType cmplx) {
             rewriteCallComplexInputType(cmplx, oper, newInTys, newOpers);
           })
           .template Case<mlir::TupleType>([&](mlir::TupleType tuple) {
             if (factory::isCharacterProcedureTuple(tuple)) {
               mlir::ModuleOp module = getModule();
               if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
-                if (callOp.callee()) {
+                if (callOp.getCallee()) {
                   llvm::StringRef charProcAttr =
                       fir::getCharacterProcedureDummyAttrName();
                   // The charProcAttr attribute is only used as a safety to
                   // confirm that this is a dummy procedure and should be split.
                   // It cannot be used to match because attributes are not
                   // available in case of indirect calls.
                   auto funcOp =
-                      module.lookupSymbol<mlir::FuncOp>(*callOp.callee());
+                      module.lookupSymbol<mlir::FuncOp>(*callOp.getCallee());
                   if (funcOp &&
                       !funcOp.template getArgAttrOfType<mlir::UnitAttr>(
                           index, charProcAttr))
                     mlir::emitError(loc, "tuple argument will be split even "
                                          "though it does not have the `" +
                                              charProcAttr + "` attribute");
                 }
               }
for (auto e : llvm::enumerate(
             newInTys.push_back(ty);
             newOpers.push_back(oper);
           });
     }
     newInTys.insert(newInTys.end(), trailingInTys.begin(), trailingInTys.end());
     newOpers.insert(newOpers.end(), trailingOpers.begin(), trailingOpers.end());
     if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) {
       fir::CallOp newCall;
-      if (callOp.callee().hasValue()) {
-        newCall = rewriter->create<A>(loc, callOp.callee().getValue(),
+      if (callOp.getCallee().hasValue()) {
+        newCall = rewriter->create<A>(loc, callOp.getCallee().getValue(),
                                       newResTys, newOpers);
       } else {
         // Force new type on the input operand.
         newOpers[0].setType(mlir::FunctionType::get(
             callOp.getContext(),
             mlir::TypeRange{newInTys}.drop_front(dropFront), newResTys));
         newCall = rewriter->create<A>(loc, newResTys, newOpers);
       }
for (mlir::Type ty : addrTy.getInputs()) {
           })
           .Default([&](mlir::Type ty) { newInTys.push_back(ty); });
     }
     // append trailing input types
     newInTys.insert(newInTys.end(), trailingInTys.begin(), trailingInTys.end());
     // replace this op with a new one with the updated signature
     auto newTy = rewriter->getFunctionType(newInTys, newResTys);
     auto newOp =
-        rewriter->create<AddrOfOp>(addrOp.getLoc(), newTy, addrOp.symbol());
+        rewriter->create<AddrOfOp>(addrOp.getLoc(), newTy, addrOp.getSymbol());
     replaceOp(addrOp, newOp.getResult());
   }
 
   /// Convert the type signatures on all the functions present in the module.
   /// As the type signature is being changed, this must also update the
   /// function itself to use any new arguments, etc.
   mlir::LogicalResult convertTypes(mlir::ModuleOp mod) {
     for (auto fn : mod.getOps<mlir::FuncOp>())

flang/lib/Optimizer/Dialect/FIROps.cpp

static mlir::ParseResult parseAllocatableOp(FN wrapResultType,
   if (parser.parseOptionalAttrDict(result.attributes) ||
       parser.addTypeToList(restype, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
 template <typename OP>
 static void printAllocatableOp(mlir::OpAsmPrinter &p, OP &op) {
-  p << ' ' << op.in_type();
-  if (!op.typeparams().empty()) {
-    p << '(' << op.typeparams() << " : " << op.typeparams().getTypes() << ')';
+  p << ' ' << op.getInType();
+  if (!op.getTypeparams().empty()) {
+    p << '(' << op.getTypeparams() << " : " << op.getTypeparams().getTypes()
+      << ')';
   }
   // print the shape of the allocation (if any); all must be index type
-  for (auto sh : op.shape()) {
+  for (auto sh : op.getShape()) {
     p << ", ";
     p.printOperand(sh);
   }
   p.printOptionalAttrDict(op->getAttrs(), {"in_type", "operand_segment_sizes"});
 }
 
 //===----------------------------------------------------------------------===//
 // AllocaOp
mlir::LogicalResult AllocMemOp::verify() {
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayCoorOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ArrayCoorOp::verify() {
-  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
+  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(getMemref().getType());
   auto arrTy = eleTy.dyn_cast<fir::SequenceType>();
   if (!arrTy)
     return emitOpError("must be a reference to an array");
   auto arrDim = arrTy.getDimension();
 
-  if (auto shapeOp = shape()) {
+  if (auto shapeOp = getShape()) {
     auto shapeTy = shapeOp.getType();
     unsigned shapeTyRank = 0;
     if (auto s = shapeTy.dyn_cast<fir::ShapeType>()) {
       shapeTyRank = s.getRank();
     } else if (auto ss = shapeTy.dyn_cast<fir::ShapeShiftType>()) {
       shapeTyRank = ss.getRank();
     } else {
       auto s = shapeTy.cast<fir::ShiftType>();
       shapeTyRank = s.getRank();
-      if (!memref().getType().isa<fir::BoxType>())
+      if (!getMemref().getType().isa<fir::BoxType>())
         return emitOpError("shift can only be provided with fir.box memref");
     }
     if (arrDim && arrDim != shapeTyRank)
       return emitOpError("rank of dimension mismatched");
-    if (shapeTyRank != indices().size())
+    if (shapeTyRank != getIndices().size())
       return emitOpError("number of indices do not match dim rank");
   }
 
-  if (auto sliceOp = slice()) {
+  if (auto sliceOp = getSlice()) {
     if (auto sl = mlir::dyn_cast_or_null<fir::SliceOp>(sliceOp.getDefiningOp()))
-      if (!sl.substr().empty())
+      if (!sl.getSubstr().empty())
         return emitOpError("array_coor cannot take a slice with substring");
     if (auto sliceTy = sliceOp.getType().dyn_cast<fir::SliceType>())
       if (sliceTy.getRank() != arrDim)
         return emitOpError("rank of dimension in slice mismatched");
   }
 
   return mlir::success();
 }
if (fir::isa_derived(eleTy))
       return eleTy;
     if (eleTy.isa<fir::SequenceType>())
       return eleTy;
   }
   return t;
 }
 
 std::vector<mlir::Value> fir::ArrayLoadOp::getExtents() {
-  if (auto sh = shape())
+  if (auto sh = getShape())
     if (auto *op = sh.getDefiningOp()) {
       if (auto shOp = dyn_cast<fir::ShapeOp>(op)) {
         auto extents = shOp.getExtents();
         return {extents.begin(), extents.end()};
       }
       return cast<fir::ShapeShiftOp>(op).getExtents();
     }
   return {};
 }
 
 mlir::LogicalResult ArrayLoadOp::verify() {
-  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
+  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(getMemref().getType());
   auto arrTy = eleTy.dyn_cast<fir::SequenceType>();
   if (!arrTy)
     return emitOpError("must be a reference to an array");
   auto arrDim = arrTy.getDimension();
 
-  if (auto shapeOp = shape()) {
+  if (auto shapeOp = getShape()) {
     auto shapeTy = shapeOp.getType();
     unsigned shapeTyRank = 0;
     if (auto s = shapeTy.dyn_cast<fir::ShapeType>()) {
       shapeTyRank = s.getRank();
     } else if (auto ss = shapeTy.dyn_cast<fir::ShapeShiftType>()) {
       shapeTyRank = ss.getRank();
     } else {
       auto s = shapeTy.cast<fir::ShiftType>();
       shapeTyRank = s.getRank();
-      if (!memref().getType().isa<fir::BoxType>())
+      if (!getMemref().getType().isa<fir::BoxType>())
         return emitOpError("shift can only be provided with fir.box memref");
     }
     if (arrDim && arrDim != shapeTyRank)
       return emitOpError("rank of dimension mismatched");
   }
 
-  if (auto sliceOp = slice()) {
+  if (auto sliceOp = getSlice()) {
     if (auto sl = mlir::dyn_cast_or_null<fir::SliceOp>(sliceOp.getDefiningOp()))
-      if (!sl.substr().empty())
+      if (!sl.getSubstr().empty())
         return emitOpError("array_load cannot take a slice with substring");
     if (auto sliceTy = sliceOp.getType().dyn_cast<fir::SliceType>())
       if (sliceTy.getRank() != arrDim)
         return emitOpError("rank of dimension in slice mismatched");
   }
 
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayMergeStoreOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ArrayMergeStoreOp::verify() {
-  if (!isa<ArrayLoadOp>(original().getDefiningOp()))
+  if (!isa<ArrayLoadOp>(getOriginal().getDefiningOp()))
     return emitOpError("operand #0 must be result of a fir.array_load op");
-  if (auto sl = slice()) {
+  if (auto sl = getSlice()) {
     if (auto sliceOp =
             mlir::dyn_cast_or_null<fir::SliceOp>(sl.getDefiningOp())) {
-      if (!sliceOp.substr().empty())
+      if (!sliceOp.getSubstr().empty())
         return emitOpError(
             "array_merge_store cannot take a slice with substring");
-      if (!sliceOp.fields().empty()) {
+      if (!sliceOp.getFields().empty()) {
         // This is an intra-object merge, where the slice is projecting the
         // subfields that are to be overwritten by the merge operation.
-        auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
+        auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(getMemref().getType());
         if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
           auto projTy =
-              fir::applyPathToType(seqTy.getEleTy(), sliceOp.fields());
-          if (fir::unwrapSequenceType(original().getType()) != projTy)
+              fir::applyPathToType(seqTy.getEleTy(), sliceOp.getFields());
+          if (fir::unwrapSequenceType(getOriginal().getType()) != projTy)
             return emitOpError(
                 "type of origin does not match sliced memref type");
-          if (fir::unwrapSequenceType(sequence().getType()) != projTy)
+          if (fir::unwrapSequenceType(getSequence().getType()) != projTy)
             return emitOpError(
                 "type of sequence does not match sliced memref type");
           return mlir::success();
         }
         return emitOpError("referenced type is not an array");
       }
     }
     return mlir::success();
   }
-  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(memref().getType());
-  if (original().getType() != eleTy)
+  auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(getMemref().getType());
+  if (getOriginal().getType() != eleTy)
     return emitOpError("type of origin does not match memref element type");
-  if (sequence().getType() != eleTy)
+  if (getSequence().getType() != eleTy)
     return emitOpError("type of sequence does not match memref element type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayFetchOp
 //===----------------------------------------------------------------------===//
 
 // Template function used for both array_fetch and array_update verification.
 template <typename A>
 mlir::Type validArraySubobject(A op) {
-  auto ty = op.sequence().getType();
-  return fir::applyPathToType(ty, op.indices());
+  auto ty = op.getSequence().getType();
+  return fir::applyPathToType(ty, op.getIndices());
 }
 
 mlir::LogicalResult ArrayFetchOp::verify() {
-  auto arrTy = sequence().getType().cast<fir::SequenceType>();
-  auto indSize = indices().size();
+  auto arrTy = getSequence().getType().cast<fir::SequenceType>();
+  auto indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
-      ::adjustedElementType(element().getType()) != arrTy.getEleTy())
+      ::adjustedElementType(getElement().getType()) != arrTy.getEleTy())
     return emitOpError("return type does not match array");
   auto ty = validArraySubobject(*this);
   if (!ty || ty != ::adjustedElementType(getType()))
     return emitOpError("return type and/or indices do not type check");
-  if (!isa<fir::ArrayLoadOp>(sequence().getDefiningOp()))
+  if (!isa<fir::ArrayLoadOp>(getSequence().getDefiningOp()))
     return emitOpError("argument #0 must be result of fir.array_load");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayAccessOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ArrayAccessOp::verify() {
-  auto arrTy = sequence().getType().cast<fir::SequenceType>();
-  std::size_t indSize = indices().size();
+  auto arrTy = getSequence().getType().cast<fir::SequenceType>();
+  std::size_t indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
-      element().getType() != fir::ReferenceType::get(arrTy.getEleTy()))
+      getElement().getType() != fir::ReferenceType::get(arrTy.getEleTy()))
     return emitOpError("return type does not match array");
   mlir::Type ty = validArraySubobject(*this);
   if (!ty || fir::ReferenceType::get(ty) != getType())
     return emitOpError("return type and/or indices do not type check");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayUpdateOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ArrayUpdateOp::verify() {
-  if (fir::isa_ref_type(merge().getType()))
+  if (fir::isa_ref_type(getMerge().getType()))
     return emitOpError("does not support reference type for merge");
-  auto arrTy = sequence().getType().cast<fir::SequenceType>();
-  auto indSize = indices().size();
+  auto arrTy = getSequence().getType().cast<fir::SequenceType>();
+  auto indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices != dimension of array");
   if (indSize == arrTy.getDimension() &&
-      ::adjustedElementType(merge().getType()) != arrTy.getEleTy())
+      ::adjustedElementType(getMerge().getType()) != arrTy.getEleTy())
     return emitOpError("merged value does not have element type");
   auto ty = validArraySubobject(*this);
-  if (!ty || ty != ::adjustedElementType(merge().getType()))
+  if (!ty || ty != ::adjustedElementType(getMerge().getType()))
     return emitOpError("merged value and/or indices do not type check");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ArrayModifyOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ArrayModifyOp::verify() {
-  auto arrTy = sequence().getType().cast<fir::SequenceType>();
-  auto indSize = indices().size();
+  auto arrTy = getSequence().getType().cast<fir::SequenceType>();
+  auto indSize = getIndices().size();
   if (indSize < arrTy.getDimension())
     return emitOpError("number of indices must match array dimension");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // BoxAddrOp
 //===----------------------------------------------------------------------===//
 
 mlir::OpFoldResult fir::BoxAddrOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
-  if (auto v = val().getDefiningOp()) {
+  if (auto v = getVal().getDefiningOp()) {
     if (auto box = dyn_cast<fir::EmboxOp>(v))
-      return box.memref();
+      return box.getMemref();
     if (auto box = dyn_cast<fir::EmboxCharOp>(v))
-      return box.memref();
+      return box.getMemref();
   }
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // BoxCharLenOp
 //===----------------------------------------------------------------------===//
 
 mlir::OpFoldResult
 fir::BoxCharLenOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
-  if (auto v = val().getDefiningOp()) {
+  if (auto v = getVal().getDefiningOp()) {
     if (auto box = dyn_cast<fir::EmboxCharOp>(v))
-      return box.len();
+      return box.getLen();
   }
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // BoxDimsOp
 //===----------------------------------------------------------------------===//
 

 //===----------------------------------------------------------------------===//
 
 mlir::FunctionType fir::CallOp::getFunctionType() {
   return mlir::FunctionType::get(getContext(), getOperandTypes(),
                                  getResultTypes());
 }
 
 void fir::CallOp::print(mlir::OpAsmPrinter &p) {
-  bool isDirect = callee().hasValue();
+  bool isDirect = getCallee().hasValue();
   p << ' ';
   if (isDirect)
-    p << callee().getValue();
+    p << getCallee().getValue();
   else
     p << getOperand(0);
   p << '(' << (*this)->getOperands().drop_front(isDirect ? 0 : 1) << ')';
   p.printOptionalAttrDict((*this)->getAttrs(),
                           {fir::CallOp::getCalleeAttrNameStr()});
   auto resultTypes{getResultTypes()};
   llvm::SmallVector<Type> argTypes(
       llvm::drop_begin(getOperandTypes(), isDirect ? 0 : 1));
static void printCmpOp(OpAsmPrinter &p, OPTY op) {
   p << ' ';
   auto predSym = mlir::arith::symbolizeCmpFPredicate(
       op->template getAttrOfType<mlir::IntegerAttr>(
             OPTY::getPredicateAttrName())
           .getInt());
   assert(predSym.hasValue() && "invalid symbol value for predicate");
   p << '"' << mlir::arith::stringifyCmpFPredicate(predSym.getValue()) << '"'
     << ", ";
-  p.printOperand(op.lhs());
+  p.printOperand(op.getLhs());
   p << ", ";
-  p.printOperand(op.rhs());
+  p.printOperand(op.getRhs());
   p.printOptionalAttrDict(op->getAttrs(),
                           /*elidedAttrs=*/{OPTY::getPredicateAttrName()});
-  p << " : " << op.lhs().getType();
+  p << " : " << op.getLhs().getType();
 }
 
 template <typename OPTY>
 static mlir::ParseResult parseCmpOp(mlir::OpAsmParser &parser,
                                     mlir::OperationState &result) {
   llvm::SmallVector<mlir::OpAsmParser::OperandType> ops;
   mlir::NamedAttrList attrs;
   mlir::Attribute predicateNameAttr;

 // CharConvertOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult CharConvertOp::verify() {
   auto unwrap = [&](mlir::Type t) {
     t = fir::unwrapSequenceType(fir::dyn_cast_ptrEleTy(t));
     return t.dyn_cast<fir::CharacterType>();
   };
-  auto inTy = unwrap(from().getType());
-  auto outTy = unwrap(to().getType());
+  auto inTy = unwrap(getFrom().getType());
+  auto outTy = unwrap(getTo().getType());
   if (!(inTy && outTy))
     return emitOpError("not a reference to a character");
   if (inTy.getFKind() == outTy.getFKind())
     return emitOpError("buffers must have different KIND values");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//

 void fir::ConvertOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                  MLIRContext *context) {
   results.insert<ConvertConvertOptPattern, RedundantConvertOptPattern,
                  CombineConvertOptPattern, ForwardConstantConvertPattern>(
       context);
 }
 
 mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
-  if (value().getType() == getType())
-    return value();
-  if (matchPattern(value(), m_Op<fir::ConvertOp>())) {
-    auto inner = cast<fir::ConvertOp>(value().getDefiningOp());
+  if (getValue().getType() == getType())
+    return getValue();
+  if (matchPattern(getValue(), m_Op<fir::ConvertOp>())) {
+    auto inner = cast<fir::ConvertOp>(getValue().getDefiningOp());
     // (convert (convert 'a : logical -> i1) : i1 -> logical) ==> forward 'a
     if (auto toTy = getType().dyn_cast<fir::LogicalType>())
-      if (auto fromTy = inner.value().getType().dyn_cast<fir::LogicalType>())
+      if (auto fromTy = inner.getValue().getType().dyn_cast<fir::LogicalType>())
         if (inner.getType().isa<mlir::IntegerType>() && (toTy == fromTy))
-          return inner.value();
+          return inner.getValue();
     // (convert (convert 'a : i1 -> logical) : logical -> i1) ==> forward 'a
     if (auto toTy = getType().dyn_cast<mlir::IntegerType>())
-      if (auto fromTy = inner.value().getType().dyn_cast<mlir::IntegerType>())
+      if (auto fromTy =
+              inner.getValue().getType().dyn_cast<mlir::IntegerType>())
         if (inner.getType().isa<fir::LogicalType>() && (toTy == fromTy) &&
             (fromTy.getWidth() == 1))
-          return inner.value();
+          return inner.getValue();
   }
   return {};
 }
 
 bool fir::ConvertOp::isIntegerCompatible(mlir::Type ty) {
   return ty.isa<mlir::IntegerType>() || ty.isa<mlir::IndexType>() ||
          ty.isa<fir::IntegerType>() || ty.isa<fir::LogicalType>();
 }
 
 bool fir::ConvertOp::isFloatCompatible(mlir::Type ty) {
   return ty.isa<mlir::FloatType>() || ty.isa<fir::RealType>();
 }
 
 bool fir::ConvertOp::isPointerCompatible(mlir::Type ty) {
   return ty.isa<fir::ReferenceType>() || ty.isa<fir::PointerType>() ||
          ty.isa<fir::HeapType>() || ty.isa<fir::LLVMPointerType>() ||
          ty.isa<mlir::MemRefType>() || ty.isa<mlir::FunctionType>() ||
          ty.isa<fir::TypeDescType>();
 }
 
 mlir::LogicalResult ConvertOp::verify() {
-  auto inType = value().getType();
+  auto inType = getValue().getType();
   auto outType = getType();
   if (inType == outType)
     return mlir::success();
   if ((isPointerCompatible(inType) && isPointerCompatible(outType)) ||
       (isIntegerCompatible(inType) && isIntegerCompatible(outType)) ||
       (isIntegerCompatible(inType) && isFloatCompatible(outType)) ||
       (isFloatCompatible(inType) && isIntegerCompatible(outType)) ||
       (isFloatCompatible(inType) && isFloatCompatible(outType)) ||
       (isIntegerCompatible(inType) && isPointerCompatible(outType)) ||
       (isPointerCompatible(inType) && isIntegerCompatible(outType)) ||
       (inType.isa<fir::BoxType>() && outType.isa<fir::BoxType>()) ||
       (fir::isa_complex(inType) && fir::isa_complex(outType)))
     return mlir::success();
   return emitOpError("invalid type conversion");
 }
 
 //===----------------------------------------------------------------------===//
 // CoordinateOp
 //===----------------------------------------------------------------------===//
 
 void CoordinateOp::print(mlir::OpAsmPrinter &p) {
-  p << ' ' << ref() << ", " << coor();
+  p << ' ' << getRef() << ", " << getCoor();
   p.printOptionalAttrDict((*this)->getAttrs(), /*elideAttrs=*/{"baseType"});
   p << " : ";
   p.printFunctionalType(getOperandTypes(), (*this)->getResultTypes());
 }
 
 mlir::ParseResult CoordinateOp::parse(mlir::OpAsmParser &parser,
                                       mlir::OperationState &result) {
   mlir::OpAsmParser::OperandType memref;
if (parser.parseOptionalAttrDict(result.attributes) ||
                              result.operands))
     return failure();
   parser.addTypesToList(funcTy.getResults(), result.types);
   result.addAttribute("baseType", mlir::TypeAttr::get(funcTy.getInput(0)));
   return mlir::success();
 }
 
 mlir::LogicalResult CoordinateOp::verify() {
-  auto refTy = ref().getType();
+  auto refTy = getRef().getType();
   if (fir::isa_ref_type(refTy)) {
     auto eleTy = fir::dyn_cast_ptrEleTy(refTy);
     if (auto arrTy = eleTy.dyn_cast<fir::SequenceType>()) {
       if (arrTy.hasUnknownShape())
         return emitOpError("cannot find coordinate in unknown shape");
       if (arrTy.getConstantRows() < arrTy.getDimension() - 1)
         return emitOpError("cannot find coordinate with unknown extents");
     }
     if (!(fir::isa_aggregate(eleTy) || fir::isa_complex(eleTy) ||
           fir::isa_char_string(eleTy)))
       return emitOpError("cannot apply coordinate_of to this type");
   }
   // Recovering a LEN type parameter only makes sense from a boxed value. For a
   // bare reference, the LEN type parameters must be passed as additional
   // arguments to `op`.
-  for (auto co : coor())
+  for (auto co : getCoor())
     if (dyn_cast_or_null<fir::LenParamIndexOp>(co.getDefiningOp())) {
       if (getNumOperands() != 2)
         return emitOpError("len_param_index must be last argument");
-      if (!ref().getType().isa<BoxType>())
+      if (!getRef().getType().isa<BoxType>())
         return emitOpError("len_param_index must be used on box type");
     }
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // DispatchOp
 //===----------------------------------------------------------------------===//
if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
       parser.resolveOperands(operands, calleeType.getInputs(), calleeLoc,
                              result.operands))
     return mlir::failure();
   return mlir::success();
 }
 
 void DispatchOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getMethodAttr() << '(';
-  p.printOperand(object());
-  if (!args().empty()) {
+  p.printOperand(getObject());
+  if (!getArgs().empty()) {
     p << ", ";
-    p.printOperands(args());
+    p.printOperands(getArgs());
   }
   p << ") : ";
   p.printFunctionalType(getOperation()->getOperandTypes(),
                         getOperation()->getResultTypes());
 }
 
 //===----------------------------------------------------------------------===//
 // DispatchTableOp
mlir::LogicalResult DispatchTableOp::verify() {
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult EmboxOp::verify() {
-  auto eleTy = fir::dyn_cast_ptrEleTy(memref().getType());
+  auto eleTy = fir::dyn_cast_ptrEleTy(getMemref().getType());
   bool isArray = false;
   if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>()) {
     eleTy = seqTy.getEleTy();
     isArray = true;
   }
   if (hasLenParams()) {
     auto lenPs = numLenParams();
     if (auto rt = eleTy.dyn_cast<fir::RecordType>()) {
       if (lenPs != rt.getNumLenParams())
         return emitOpError("number of LEN params does not correspond"
                            " to the !fir.type type");
     } else if (auto strTy = eleTy.dyn_cast<fir::CharacterType>()) {
       if (strTy.getLen() != fir::CharacterType::unknownLen())
         return emitOpError("CHARACTER already has static LEN");
     } else {
       return emitOpError("LEN parameters require CHARACTER or derived type");
     }
-    for (auto lp : typeparams())
+    for (auto lp : getTypeparams())
       if (!fir::isa_integer(lp.getType()))
         return emitOpError("LEN parameters must be integral type");
   }
   if (getShape() && !isArray)
     return emitOpError("shape must not be provided for a scalar");
   if (getSlice() && !isArray)
     return emitOpError("slice must not be provided for a scalar");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxCharOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult EmboxCharOp::verify() {
-  auto eleTy = fir::dyn_cast_ptrEleTy(memref().getType());
+  auto eleTy = fir::dyn_cast_ptrEleTy(getMemref().getType());
   if (!eleTy.dyn_cast_or_null<CharacterType>())
     return mlir::failure();
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // EmboxProcOp
 //===----------------------------------------------------------------------===//
mlir::ParseResult EmboxProcOp::parse(mlir::OpAsmParser &parser,
   if (parser.parseRParen() || parser.parseArrow() ||
       parser.parseType(boxType) || parser.addTypesToList(boxType, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
 void EmboxProcOp::print(mlir::OpAsmPrinter &p) {
   p << ' ' << getOperation()->getAttr("funcname");
-  auto h = host();
+  auto h = getHost();
   if (h) {
     p << ", ";
     p.printOperand(h);
   }
   p << " : (" << getOperation()->getAttr("functype");
   if (h)
     p << ", " << h.getType();
   p << ") -> " << getType();
 }
 
 mlir::LogicalResult EmboxProcOp::verify() {
   // host bindings (optional) must be a reference to a tuple
-  if (auto h = host()) {
+  if (auto h = getHost()) {
     if (auto r = h.getType().dyn_cast<ReferenceType>()) {
       if (!r.getEleTy().dyn_cast<mlir::TupleType>())
         return mlir::failure();
     } else {
       return mlir::failure();
     }
   }
   return mlir::success();
if (simpleInitializer) {
     if (parseResult.hasValue() && mlir::failed(*parseResult))
       return mlir::failure();
   }
 
   return mlir::success();
 }
 
 void GlobalOp::print(mlir::OpAsmPrinter &p) {
-  if (linkName().hasValue())
-    p << ' ' << linkName().getValue();
+  if (getLinkName().hasValue())
+    p << ' ' << getLinkName().getValue();
   p << ' ';
   p.printAttributeWithoutType(getSymrefAttr());
   if (auto val = getValueOrNull())
     p << '(' << val << ')';
   if (getOperation()->getAttr(fir::GlobalOp::getConstantAttrNameStr()))
     p << " constant";
   p << " : ";
   p.printType(getType());
void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           ArrayRef<NamedAttribute> attrs) {
   result.addRegion();
   result.addAttribute(typeAttrName(result.name), mlir::TypeAttr::get(type));
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(symbolAttrNameStr(),
                       SymbolRefAttr::get(builder.getContext(), name));
   if (isConstant)
-    result.addAttribute(constantAttrName(result.name), builder.getUnitAttr());
+    result.addAttribute(getConstantAttrName(result.name),
+                        builder.getUnitAttr());
   if (initialVal)
-    result.addAttribute(initValAttrName(result.name), initialVal);
+    result.addAttribute(getInitValAttrName(result.name), initialVal);
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, Type type, Attribute initialVal,
                           StringAttr linkage, ArrayRef<NamedAttribute> attrs) {

 void FieldIndexOp::print(mlir::OpAsmPrinter &p) {
   p << ' '
     << getOperation()
            ->getAttrOfType<mlir::StringAttr>(fir::FieldIndexOp::fieldAttrName())
            .getValue()
     << ", " << getOperation()->getAttr(fir::FieldIndexOp::typeAttrName());
   if (getNumOperands()) {
     p << '(';
-    p.printOperands(typeparams());
+    p.printOperands(getTypeparams());
     const auto *sep = ") : ";
-    for (auto op : typeparams()) {
+    for (auto op : getTypeparams()) {
       p << sep;
       if (op)
         p.printType(op.getType());
       else
         p << "()";
       sep = ", ";
     }
   }
llvm::interleaveComma(
           enumerate,
           [](auto indexed_value) { return indexed_value.index() % 2 != 0; }),
       printer, [&](auto indexed_value) { printer << indexed_value.value(); });
   printer << ")";
 }
 
 /// Range bounds must be nonnegative, and the range must not be empty.
 mlir::LogicalResult InsertOnRangeOp::verify() {
-  if (fir::hasDynamicSize(seq().getType()))
+  if (fir::hasDynamicSize(getSeq().getType()))
     return emitOpError("must have constant shape and size");
-  mlir::DenseIntElementsAttr coorAttr = coor();
+  mlir::DenseIntElementsAttr coorAttr = getCoor();
   if (coorAttr.size() < 2 || coorAttr.size() % 2 != 0)
     return emitOpError("has uneven number of values in ranges");
   bool rangeIsKnownToBeNonempty = false;
   for (auto i = coorAttr.getValues<int64_t>().end(),
             b = coorAttr.getValues<int64_t>().begin();
        i != b;) {
     int64_t ub = (*--i);
     int64_t lb = (*--i);
struct UndoComplexPattern : public mlir::RewritePattern {
 
   mlir::LogicalResult
   matchAndRewrite(mlir::Operation *op,
                   mlir::PatternRewriter &rewriter) const override {
     auto insval = dyn_cast_or_null<fir::InsertValueOp>(op);
     if (!insval || !insval.getType().isa<fir::ComplexType>())
       return mlir::failure();
     auto insval2 =
-        dyn_cast_or_null<fir::InsertValueOp>(insval.adt().getDefiningOp());
-    if (!insval2 || !isa<fir::UndefOp>(insval2.adt().getDefiningOp()))
+        dyn_cast_or_null<fir::InsertValueOp>(insval.getAdt().getDefiningOp());
+    if (!insval2 || !isa<fir::UndefOp>(insval2.getAdt().getDefiningOp()))
       return mlir::failure();
-    auto binf = dyn_cast_or_null<FltOp>(insval.val().getDefiningOp());
-    auto binf2 = dyn_cast_or_null<FltOp>(insval2.val().getDefiningOp());
-    if (!binf || !binf2 || insval.coor().size() != 1 ||
-        !isOne(insval.coor()[0]) || insval2.coor().size() != 1 ||
-        !isZero(insval2.coor()[0]))
+    auto binf = dyn_cast_or_null<FltOp>(insval.getVal().getDefiningOp());
+    auto binf2 = dyn_cast_or_null<FltOp>(insval2.getVal().getDefiningOp());
+    if (!binf || !binf2 || insval.getCoor().size() != 1 ||
+        !isOne(insval.getCoor()[0]) || insval2.getCoor().size() != 1 ||
+        !isZero(insval2.getCoor()[0]))
       return mlir::failure();
     auto eai =
         dyn_cast_or_null<fir::ExtractValueOp>(binf.getLhs().getDefiningOp());
     auto ebi =
         dyn_cast_or_null<fir::ExtractValueOp>(binf.getRhs().getDefiningOp());
     auto ear =
         dyn_cast_or_null<fir::ExtractValueOp>(binf2.getLhs().getDefiningOp());
     auto ebr =
         dyn_cast_or_null<fir::ExtractValueOp>(binf2.getRhs().getDefiningOp());
-    if (!eai || !ebi || !ear || !ebr || ear.adt() != eai.adt() ||
-        ebr.adt() != ebi.adt() || eai.coor().size() != 1 ||
-        !isOne(eai.coor()[0]) || ebi.coor().size() != 1 ||
-        !isOne(ebi.coor()[0]) || ear.coor().size() != 1 ||
-        !isZero(ear.coor()[0]) || ebr.coor().size() != 1 ||
-        !isZero(ebr.coor()[0]))
+    if (!eai || !ebi || !ear || !ebr || ear.getAdt() != eai.getAdt() ||
+        ebr.getAdt() != ebi.getAdt() || eai.getCoor().size() != 1 ||
+        !isOne(eai.getCoor()[0]) || ebi.getCoor().size() != 1 ||
+        !isOne(ebi.getCoor()[0]) || ear.getCoor().size() != 1 ||
+        !isZero(ear.getCoor()[0]) || ebr.getCoor().size() != 1 ||
+        !isZero(ebr.getCoor()[0]))
       return mlir::failure();
-    rewriter.replaceOpWithNewOp<CpxOp>(op, ear.adt(), ebr.adt());
+    rewriter.replaceOpWithNewOp<CpxOp>(op, ear.getAdt(), ebr.getAdt());
     return mlir::success();
   }
 };
 
 void fir::InsertValueOp::getCanonicalizationPatterns(
     mlir::RewritePatternSet &results, mlir::MLIRContext *context) {
   results.insert<UndoComplexPattern<mlir::arith::AddFOp, fir::AddcOp>,
                  UndoComplexPattern<mlir::arith::SubFOp, fir::SubcOp>>(context);
return op.emitOpError(
         "expected body second argument to be an index argument for "
         "the induction variable");
   if (!body->getArgument(0).getType().isIndex())
     return op.emitOpError(
         "expected body first argument to be an index argument for "
         "the induction variable");
 
   auto opNumResults = op.getNumResults();
-  if (op.finalValue()) {
+  if (op.getFinalValue()) {
     // Result type must be "(index, i1, ...)".
     if (!op.getResult(0).getType().isa<mlir::IndexType>())
       return op.emitOpError("result #0 expected to be index");
     if (!op.getResult(1).getType().isSignlessInteger(1))
       return op.emitOpError("result #1 expected to be i1");
     opNumResults--;
   } else {
     // iterate_while always returns the early exit induction value.
     // Result type must be "(i1, ...)"
     if (!op.getResult(0).getType().isSignlessInteger(1))
       return op.emitOpError("result #0 expected to be i1");
   }
   if (opNumResults == 0)
     return mlir::failure();
   if (op.getNumIterOperands() != opNumResults)
     return op.emitOpError(
         "mismatch in number of loop-carried values and defined values");
   if (op.getNumRegionIterArgs() != opNumResults)
     return op.emitOpError(
         "mismatch in number of basic block args and defined values");
   auto iterOperands = op.getIterOperands();
   auto iterArgs = op.getRegionIterArgs();
   auto opResults =
-      op.finalValue() ? op.getResults().drop_front() : op.getResults();
+      op.getFinalValue() ? op.getResults().drop_front() : op.getResults();
   unsigned i = 0;
   for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
     if (std::get<0>(e).getType() != std::get<2>(e).getType())
       return op.emitOpError() << "types mismatch between " << i
                               << "th iter operand and defined value";
     if (std::get<1>(e).getType() != std::get<2>(e).getType())
       return op.emitOpError() << "types mismatch between " << i
                               << "th iter region arg and defined value";
 
     i++;
   }
   return mlir::success();
 }
 
 static void print(mlir::OpAsmPrinter &p, fir::IterWhileOp op) {
-  p << " (" << op.getInductionVar() << " = " << op.lowerBound() << " to "
-    << op.upperBound() << " step " << op.step() << ") and (";
+  p << " (" << op.getInductionVar() << " = " << op.getLowerBound() << " to "
+    << op.getUpperBound() << " step " << op.getStep() << ") and (";
   assert(op.hasIterOperands());
   auto regionArgs = op.getRegionIterArgs();
   auto operands = op.getIterOperands();
   p << regionArgs.front() << " = " << *operands.begin() << ")";
   if (regionArgs.size() > 1) {
     p << " iter_args(";
     llvm::interleaveComma(
         llvm::zip(regionArgs.drop_front(), operands.drop_front()), p,
         [&](auto it) { p << std::get<0>(it) << " = " << std::get<1>(it); });
     p << ") -> (";
     llvm::interleaveComma(
-        llvm::drop_begin(op.getResultTypes(), op.finalValue() ? 0 : 1), p);
+        llvm::drop_begin(op.getResultTypes(), op.getFinalValue() ? 0 : 1), p);
     p << ")";
-  } else if (op.finalValue()) {
+  } else if (op.getFinalValue()) {
     p << " -> (" << op.getResultTypes() << ')';
   }
   p.printOptionalAttrDictWithKeyword(op->getAttrs(),
                                      {op.getFinalValueAttrNameStr()});
   p << ' ';
-  p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
+  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/true);
 }
 
-mlir::Region &fir::IterWhileOp::getLoopBody() { return region(); }
+mlir::Region &fir::IterWhileOp::getLoopBody() { return getRegion(); }
 
 bool fir::IterWhileOp::isDefinedOutsideOfLoop(mlir::Value value) {
-  return !region().isAncestor(value.getParentRegion());
+  return !getRegion().isAncestor(value.getParentRegion());
 }
 
 mlir::LogicalResult
 fir::IterWhileOp::moveOutOfLoop(llvm::ArrayRef<mlir::Operation *> ops) {
   for (auto *op : ops)
     op->moveBefore(*this);
   return success();
 }
 
 mlir::BlockArgument fir::IterWhileOp::iterArgToBlockArg(mlir::Value iterArg) {
-  for (auto i : llvm::enumerate(initArgs()))
+  for (auto i : llvm::enumerate(getInitArgs()))
     if (iterArg == i.value())
-      return region().front().getArgument(i.index() + 1);
+      return getRegion().front().getArgument(i.index() + 1);
   return {};
 }
 
 void fir::IterWhileOp::resultToSourceOps(
     llvm::SmallVectorImpl<mlir::Value> &results, unsigned resultNum) {
-  auto oper = finalValue() ? resultNum + 1 : resultNum;
-  auto *term = region().front().getTerminator();
+  auto oper = getFinalValue() ? resultNum + 1 : resultNum;
+  auto *term = getRegion().front().getTerminator();
   if (oper < term->getNumOperands())
     results.push_back(term->getOperand(oper));
 }
 
 mlir::Value fir::IterWhileOp::blockArgToSourceOp(unsigned blockArgNum) {
-  if (blockArgNum > 0 && blockArgNum <= initArgs().size())
-    return initArgs()[blockArgNum - 1];
+  if (blockArgNum > 0 && blockArgNum <= getInitArgs().size())
+    return getInitArgs()[blockArgNum - 1];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // LenParamIndexOp
 //===----------------------------------------------------------------------===//
 
 mlir::ParseResult LenParamIndexOp::parse(mlir::OpAsmParser &parser,
mlir::ParseResult LoadOp::parse(mlir::OpAsmParser &parser,
   if (fir::LoadOp::getElementOf(eleTy, type) ||
       parser.addTypeToList(eleTy, result.types))
     return mlir::failure();
   return mlir::success();
 }
 
 void LoadOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
-  p.printOperand(memref());
+  p.printOperand(getMemref());
   p.printOptionalAttrDict(getOperation()->getAttrs(), {});
-  p << " : " << memref().getType();
+  p << " : " << getMemref().getType();
 }
 
 //===----------------------------------------------------------------------===//
 // DoLoopOp
 //===----------------------------------------------------------------------===//
 
 void fir::DoLoopOp::build(mlir::OpBuilder &builder,
                           mlir::OperationState &result, mlir::Value lb,
                           mlir::Value ub, mlir::Value step, bool unordered,
                           bool finalCountValue, mlir::ValueRange iterArgs,
                           llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   result.addOperands({lb, ub, step});
   result.addOperands(iterArgs);
   if (finalCountValue) {
     result.addTypes(builder.getIndexType());
-    result.addAttribute(finalValueAttrName(result.name), builder.getUnitAttr());
+    result.addAttribute(getFinalValueAttrName(result.name),
+                        builder.getUnitAttr());
   }
   for (auto v : iterArgs)
     result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block{});
   if (iterArgs.empty() && !finalCountValue)
     DoLoopOp::ensureTerminator(*bodyRegion, builder, result.location);
   bodyRegion->front().addArgument(builder.getIndexType(), result.location);
   bodyRegion->front().addArguments(
       iterArgs.getTypes(),
       SmallVector<Location>(iterArgs.size(), result.location));
   if (unordered)
-    result.addAttribute(unorderedAttrName(result.name), builder.getUnitAttr());
+    result.addAttribute(getUnorderedAttrName(result.name),
+                        builder.getUnitAttr());
   result.addAttributes(attributes);
 }
 
 static mlir::ParseResult parseDoLoopOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
   mlir::OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
     prependCount = true;
   }
 
   if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return mlir::failure();
 
   // Induction variable.
   if (prependCount)
-    result.addAttribute(DoLoopOp::finalValueAttrName(result.name),
+    result.addAttribute(DoLoopOp::getFinalValueAttrName(result.name),
                         builder.getUnitAttr());
   else
     argTypes.push_back(indexType);
   // Loop carried variables
   argTypes.append(result.types.begin(), result.types.end());
   // Parse the body region.
   auto *body = result.addRegion();
   if (regionArgs.size() != argTypes.size())
if (!body->getArgument(0).getType().isIndex())
     return op.emitOpError(
         "expected body first argument to be an index argument for "
         "the induction variable");
 
   auto opNumResults = op.getNumResults();
   if (opNumResults == 0)
     return success();
 
-  if (op.finalValue()) {
-    if (op.unordered())
+  if (op.getFinalValue()) {
+    if (op.getUnordered())
       return op.emitOpError("unordered loop has no final value");
     opNumResults--;
   }
   if (op.getNumIterOperands() != opNumResults)
     return op.emitOpError(
         "mismatch in number of loop-carried values and defined values");
   if (op.getNumRegionIterArgs() != opNumResults)
     return op.emitOpError(
         "mismatch in number of basic block args and defined values");
   auto iterOperands = op.getIterOperands();
   auto iterArgs = op.getRegionIterArgs();
   auto opResults =
-      op.finalValue() ? op.getResults().drop_front() : op.getResults();
+      op.getFinalValue() ? op.getResults().drop_front() : op.getResults();
   unsigned i = 0;
   for (auto e : llvm::zip(iterOperands, iterArgs, opResults)) {
     if (std::get<0>(e).getType() != std::get<2>(e).getType())
       return op.emitOpError() << "types mismatch between " << i
                               << "th iter operand and defined value";
     if (std::get<1>(e).getType() != std::get<2>(e).getType())
       return op.emitOpError() << "types mismatch between " << i
                               << "th iter region arg and defined value";
 
     i++;
   }
   return success();
 }
 
 static void print(mlir::OpAsmPrinter &p, fir::DoLoopOp op) {
   bool printBlockTerminators = false;
-  p << ' ' << op.getInductionVar() << " = " << op.lowerBound() << " to "
-    << op.upperBound() << " step " << op.step();
-  if (op.unordered())
+  p << ' ' << op.getInductionVar() << " = " << op.getLowerBound() << " to "
+    << op.getUpperBound() << " step " << op.getStep();
+  if (op.getUnordered())
     p << " unordered";
   if (op.hasIterOperands()) {
     p << " iter_args(";
     auto regionArgs = op.getRegionIterArgs();
     auto operands = op.getIterOperands();
     llvm::interleaveComma(llvm::zip(regionArgs, operands), p, [&](auto it) {
       p << std::get<0>(it) << " = " << std::get<1>(it);
     });
     p << ") -> (" << op.getResultTypes() << ')';
     printBlockTerminators = true;
-  } else if (op.finalValue()) {
+  } else if (op.getFinalValue()) {
     p << " -> " << op.getResultTypes();
     printBlockTerminators = true;
   }
   p.printOptionalAttrDictWithKeyword(op->getAttrs(),
                                      {"unordered", "finalValue"});
   p << ' ';
-  p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
+  p.printRegion(op.getRegion(), /*printEntryBlockArgs=*/false,
                 printBlockTerminators);
 }
 
-mlir::Region &fir::DoLoopOp::getLoopBody() { return region(); }
+mlir::Region &fir::DoLoopOp::getLoopBody() { return getRegion(); }
 
 bool fir::DoLoopOp::isDefinedOutsideOfLoop(mlir::Value value) {
-  return !region().isAncestor(value.getParentRegion());
+  return !getRegion().isAncestor(value.getParentRegion());
 }
 
 mlir::LogicalResult
 fir::DoLoopOp::moveOutOfLoop(llvm::ArrayRef<mlir::Operation *> ops) {
   for (auto op : ops)
     op->moveBefore(*this);
   return success();
 }
 
 /// Translate a value passed as an iter_arg to the corresponding block
 /// argument in the body of the loop.
 mlir::BlockArgument fir::DoLoopOp::iterArgToBlockArg(mlir::Value iterArg) {
-  for (auto i : llvm::enumerate(initArgs()))
+  for (auto i : llvm::enumerate(getInitArgs()))
     if (iterArg == i.value())
-      return region().front().getArgument(i.index() + 1);
+      return getRegion().front().getArgument(i.index() + 1);
   return {};
 }
 
 /// Translate the result vector (by index number) to the corresponding value
 /// to the `fir.result` Op.
 void fir::DoLoopOp::resultToSourceOps(
     llvm::SmallVectorImpl<mlir::Value> &results, unsigned resultNum) {
-  auto oper = finalValue() ? resultNum + 1 : resultNum;
-  auto *term = region().front().getTerminator();
+  auto oper = getFinalValue() ? resultNum + 1 : resultNum;
+  auto *term = getRegion().front().getTerminator();
   if (oper < term->getNumOperands())
     results.push_back(term->getOperand(oper));
 }
 
 /// Translate the block argument (by index number) to the corresponding value
 /// passed as an iter_arg to the parent DoLoopOp.
 mlir::Value fir::DoLoopOp::blockArgToSourceOp(unsigned blockArgNum) {
-  if (blockArgNum > 0 && blockArgNum <= initArgs().size())
-    return initArgs()[blockArgNum - 1];
+  if (blockArgNum > 0 && blockArgNum <= getInitArgs().size())
+    return getInitArgs()[blockArgNum - 1];
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // DTEntryOp
 //===----------------------------------------------------------------------===//
 
 mlir::ParseResult DTEntryOp::parse(mlir::OpAsmParser &parser,

 static unsigned getBoxRank(mlir::Type boxTy) {
   auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(boxTy);
   if (auto seqTy = eleTy.dyn_cast<fir::SequenceType>())
     return seqTy.getDimension();
   return 0;
 }
 
 mlir::LogicalResult ReboxOp::verify() {
-  auto inputBoxTy = box().getType();
+  auto inputBoxTy = getBox().getType();
   if (fir::isa_unknown_size_box(inputBoxTy))
     return emitOpError("box operand must not have unknown rank or type");
   auto outBoxTy = getType();
   if (fir::isa_unknown_size_box(outBoxTy))
     return emitOpError("result type must not have unknown rank or type");
   auto inputRank = getBoxRank(inputBoxTy);
   auto inputEleTy = getBoxScalarEleTy(inputBoxTy);
   auto outRank = getBoxRank(outBoxTy);
   auto outEleTy = getBoxScalarEleTy(outBoxTy);
 
-  if (auto sliceVal = slice()) {
+  if (auto sliceVal = getSlice()) {
     // Slicing case
     if (sliceVal.getType().cast<fir::SliceType>().getRank() != inputRank)
       return emitOpError("slice operand rank must match box operand rank");
-    if (auto shapeVal = shape()) {
+    if (auto shapeVal = getShape()) {
       if (auto shiftTy = shapeVal.getType().dyn_cast<fir::ShiftType>()) {
         if (shiftTy.getRank() != inputRank)
           return emitOpError("shape operand and input box ranks must match "
                              "when there is a slice");
       } else {
         return emitOpError("shape operand must absent or be a fir.shift "
                            "when there is a slice");
       }
     }
     if (auto sliceOp = sliceVal.getDefiningOp()) {
       auto slicedRank = mlir::cast<fir::SliceOp>(sliceOp).getOutRank();
       if (slicedRank != outRank)
         return emitOpError("result type rank and rank after applying slice "
                            "operand must match");
     }
   } else {
     // Reshaping case
     unsigned shapeRank = inputRank;
-    if (auto shapeVal = shape()) {
+    if (auto shapeVal = getShape()) {
       auto ty = shapeVal.getType();
       if (auto shapeTy = ty.dyn_cast<fir::ShapeType>()) {
         shapeRank = shapeTy.getRank();
       } else if (auto shapeShiftTy = ty.dyn_cast<fir::ShapeShiftType>()) {
         shapeRank = shapeShiftTy.getRank();
       } else {
         auto shiftTy = ty.cast<fir::ShiftType>();
         shapeRank = shiftTy.getRank();
mlir::LogicalResult ResultOp::verify() {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SaveResultOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult SaveResultOp::verify() {
-  auto resultType = value().getType();
-  if (resultType != fir::dyn_cast_ptrEleTy(memref().getType()))
+  auto resultType = getValue().getType();
+  if (resultType != fir::dyn_cast_ptrEleTy(getMemref().getType()))
     return emitOpError("value type must match memory reference type");
   if (fir::isa_unknown_size_box(resultType))
     return emitOpError("cannot save !fir.box of unknown rank or type");
 
   if (resultType.isa<fir::BoxType>()) {
-    if (shape() || !typeparams().empty())
+    if (getShape() || !getTypeparams().empty())
       return emitOpError(
           "must not have shape or length operands if the value is a fir.box");
     return mlir::success();
   }
 
   // fir.record or fir.array case.
   unsigned shapeTyRank = 0;
-  if (auto shapeVal = shape()) {
+  if (auto shapeVal = getShape()) {
     auto shapeTy = shapeVal.getType();
     if (auto s = shapeTy.dyn_cast<fir::ShapeType>())
       shapeTyRank = s.getRank();
     else
       shapeTyRank = shapeTy.cast<fir::ShapeShiftType>().getRank();
   }
 
   auto eleTy = resultType;
   if (auto seqTy = resultType.dyn_cast<fir::SequenceType>()) {
     if (seqTy.getDimension() != shapeTyRank)
       emitOpError("shape operand must be provided and have the value rank "
                   "when the value is a fir.array");
     eleTy = seqTy.getEleTy();
   } else {
     if (shapeTyRank != 0)
       emitOpError(
           "shape operand should only be provided if the value is a fir.array");
   }
 
   if (auto recTy = eleTy.dyn_cast<fir::RecordType>()) {
-    if (recTy.getNumLenParams() != typeparams().size())
+    if (recTy.getNumLenParams() != getTypeparams().size())
       emitOpError("length parameters number must match with the value type "
                   "length parameters");
   } else if (auto charTy = eleTy.dyn_cast<fir::CharacterType>()) {
-    if (typeparams().size() > 1)
+    if (getTypeparams().size() > 1)
       emitOpError("no more than one length parameter must be provided for "
                   "character value");
   } else {
-    if (!typeparams().empty())
+    if (!getTypeparams().empty())
       emitOpError("length parameters must not be provided for this value type");
   }
 
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // SelectOp

 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
   return {};
 }
 
 llvm::Optional<mlir::MutableOperandRange>
 fir::SelectOp::getMutableSuccessorOperands(unsigned oper) {
-  return ::getMutableSuccessorOperands(oper, targetArgsMutable(),
+  return ::getMutableSuccessorOperands(oper, getTargetArgsMutable(),
                                        getTargetOffsetAttr());
 }
 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
                                     unsigned oper) {
   auto a =
       (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());

 //===----------------------------------------------------------------------===//
 // SelectCaseOp
 //===----------------------------------------------------------------------===//
 
 llvm::Optional<mlir::OperandRange>
 fir::SelectCaseOp::getCompareOperands(unsigned cond) {
   auto a = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getCompareOffsetAttr());
-  return {getSubOperands(cond, compareArgs(), a)};
+  return {getSubOperands(cond, getCompareArgs(), a)};
 }
 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectCaseOp::getCompareOperands(llvm::ArrayRef<mlir::Value> operands,
                                       unsigned cond) {
   auto a = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getCompareOffsetAttr());
   auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getOperandSegmentSizeAttr());
   return {getSubOperands(cond, getSubOperands(1, operands, segments), a)};
 }
 
 llvm::Optional<mlir::ValueRange>
 fir::SelectCaseOp::getCompareOperands(mlir::ValueRange operands,
                                       unsigned cond) {
   auto a = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getCompareOffsetAttr());
   auto segments = (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(
       getOperandSegmentSizeAttr());
   return {getSubOperands(cond, getSubOperands(1, operands, segments), a)};
 }
 
 llvm::Optional<mlir::MutableOperandRange>
 fir::SelectCaseOp::getMutableSuccessorOperands(unsigned oper) {
-  return ::getMutableSuccessorOperands(oper, targetArgsMutable(),
+  return ::getMutableSuccessorOperands(oper, getTargetArgsMutable(),
                                        getTargetOffsetAttr());
 }
 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectCaseOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
                                         unsigned oper) {
   auto a =
       (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());

 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectRankOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
   return {};
 }
 
 llvm::Optional<mlir::MutableOperandRange>
 fir::SelectRankOp::getMutableSuccessorOperands(unsigned oper) {
-  return ::getMutableSuccessorOperands(oper, targetArgsMutable(),
+  return ::getMutableSuccessorOperands(oper, getTargetArgsMutable(),
                                        getTargetOffsetAttr());
 }
 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectRankOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
                                         unsigned oper) {
   auto a =
       (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());

 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectTypeOp::getCompareOperands(llvm::ArrayRef<mlir::Value>, unsigned) {
   return {};
 }
 
 llvm::Optional<mlir::MutableOperandRange>
 fir::SelectTypeOp::getMutableSuccessorOperands(unsigned oper) {
-  return ::getMutableSuccessorOperands(oper, targetArgsMutable(),
+  return ::getMutableSuccessorOperands(oper, getTargetArgsMutable(),
                                        getTargetOffsetAttr());
 }
 
 llvm::Optional<llvm::ArrayRef<mlir::Value>>
 fir::SelectTypeOp::getSuccessorOperands(llvm::ArrayRef<mlir::Value> operands,
                                         unsigned oper) {
   auto a =
       (*this)->getAttrOfType<mlir::DenseIntElementsAttr>(getTargetOffsetAttr());
void fir::SelectTypeOp::build(mlir::OpBuilder &builder,
   result.addAttributes(attributes);
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ShapeOp::verify() {
-  auto size = extents().size();
+  auto size = getExtents().size();
   auto shapeTy = getType().dyn_cast<fir::ShapeType>();
   assert(shapeTy && "must be a shape type");
   if (shapeTy.getRank() != size)
     return emitOpError("shape type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShapeShiftOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ShapeShiftOp::verify() {
-  auto size = pairs().size();
+  auto size = getPairs().size();
   if (size < 2 || size > 16 * 2)
     return emitOpError("incorrect number of args");
   if (size % 2 != 0)
     return emitOpError("requires a multiple of 2 args");
   auto shapeTy = getType().dyn_cast<fir::ShapeShiftType>();
   assert(shapeTy && "must be a shape shift type");
   if (shapeTy.getRank() * 2 != size)
     return emitOpError("shape type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ShiftOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult ShiftOp::verify() {
-  auto size = origins().size();
+  auto size = getOrigins().size();
   auto shiftTy = getType().dyn_cast<fir::ShiftType>();
   assert(shiftTy && "must be a shift type");
   if (shiftTy.getRank() != size)
     return emitOpError("shift type rank mismatch");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
for (unsigned i = 1, end = triples.size(); i < end; i += 3) {
         ++rank;
     }
     assert(rank > 0);
   }
   return rank;
 }
 
 mlir::LogicalResult SliceOp::verify() {
-  auto size = triples().size();
+  auto size = getTriples().size();
   if (size < 3 || size > 16 * 3)
     return emitOpError("incorrect number of args for triple");
   if (size % 3 != 0)
     return emitOpError("requires a multiple of 3 args");
   auto sliceTy = getType().dyn_cast<fir::SliceType>();
   assert(sliceTy && "must be a slice type");
   if (sliceTy.getRank() * 3 != size)
     return emitOpError("slice type rank mismatch");
if (parser.parseOperand(oper) || parser.parseKeyword("to") ||
                             result.operands) ||
       parser.resolveOperand(store, type, result.operands))
     return mlir::failure();
   return mlir::success();
 }
 
 void StoreOp::print(mlir::OpAsmPrinter &p) {
   p << ' ';
-  p.printOperand(value());
+  p.printOperand(getValue());
   p << " to ";
-  p.printOperand(memref());
+  p.printOperand(getMemref());
   p.printOptionalAttrDict(getOperation()->getAttrs(), {});
-  p << " : " << memref().getType();
+  p << " : " << getMemref().getType();
 }
 
 mlir::LogicalResult StoreOp::verify() {
-  if (value().getType() != fir::dyn_cast_ptrEleTy(memref().getType()))
+  if (getValue().getType() != fir::dyn_cast_ptrEleTy(getMemref().getType()))
     return emitOpError("store value type must match memory reference type");
-  if (fir::isa_unknown_size_box(value().getType()))
+  if (fir::isa_unknown_size_box(getValue().getType()))
     return emitOpError("cannot store !fir.box of unknown rank or type");
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // StringLitOp
 //===----------------------------------------------------------------------===//
 
mlir::LogicalResult StringLitOp::verify() {
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // UnboxProcOp
 //===----------------------------------------------------------------------===//
 
 mlir::LogicalResult UnboxProcOp::verify() {
-  if (auto eleTy = fir::dyn_cast_ptrEleTy(refTuple().getType()))
+  if (auto eleTy = fir::dyn_cast_ptrEleTy(getRefTuple().getType()))
     if (eleTy.isa<mlir::TupleType>())
       return mlir::success();
   return emitOpError("second output argument has bad type");
 }
 
 //===----------------------------------------------------------------------===//
 // IfOp
 //===----------------------------------------------------------------------===//
static mlir::ParseResult parseIfOp(OpAsmParser &parser,
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return mlir::failure();
   return mlir::success();
 }
 
 static LogicalResult verify(fir::IfOp op) {
-  if (op.getNumResults() != 0 && op.elseRegion().empty())
+  if (op.getNumResults() != 0 && op.getElseRegion().empty())
     return op.emitOpError("must have an else block if defining values");
 
   return mlir::success();
 }
 
 static void print(mlir::OpAsmPrinter &p, fir::IfOp op) {
   bool printBlockTerminators = false;
-  p << ' ' << op.condition();
-  if (!op.results().empty()) {
+  p << ' ' << op.getCondition();
+  if (!op.getResults().empty()) {
     p << " -> (" << op.getResultTypes() << ')';
     printBlockTerminators = true;
   }
   p << ' ';
-  p.printRegion(op.thenRegion(), /*printEntryBlockArgs=*/false,
+  p.printRegion(op.getThenRegion(), /*printEntryBlockArgs=*/false,
                 printBlockTerminators);
 
   // Print the 'else' regions if it exists and has a block.
-  auto &otherReg = op.elseRegion();
+  auto &otherReg = op.getElseRegion();
   if (!otherReg.empty()) {
     p << " else ";
     p.printRegion(otherReg, /*printEntryBlockArgs=*/false,
                   printBlockTerminators);
   }
   p.printOptionalAttrDict(op->getAttrs());
 }
 
 void fir::IfOp::resultToSourceOps(llvm::SmallVectorImpl<mlir::Value> &results,
                                   unsigned resultNum) {
-  auto *term = thenRegion().front().getTerminator();
+  auto *term = getThenRegion().front().getTerminator();
   if (resultNum < term->getNumOperands())
     results.push_back(term->getOperand(resultNum));
-  term = elseRegion().front().getTerminator();
+  term = getElseRegion().front().getTerminator();
   if (resultNum < term->getNumOperands())
     results.push_back(term->getOperand(resultNum));
 }
 
 //===----------------------------------------------------------------------===//
 
 mlir::ParseResult fir::isValidCaseAttr(mlir::Attribute attr) {
   if (attr.dyn_cast_or_null<mlir::UnitAttr>() ||

 
 bool fir::valueHasFirAttribute(mlir::Value value,
                                llvm::StringRef attributeName) {
   // If this is a fir.box that was loaded, the fir attributes will be on the
   // related fir.ref<fir.box> creation.
   if (value.getType().isa<fir::BoxType>())
     if (auto definingOp = value.getDefiningOp())
       if (auto loadOp = mlir::dyn_cast<fir::LoadOp>(definingOp))
-        value = loadOp.memref();
+        value = loadOp.getMemref();
   // If this is a function argument, look in the argument attributes.
   if (auto blockArg = value.dyn_cast<mlir::BlockArgument>()) {
     if (blockArg.getOwner() && blockArg.getOwner()->isEntryBlock())
       if (auto funcOp =
               mlir::dyn_cast<mlir::FuncOp>(blockArg.getOwner()->getParentOp()))
         if (funcOp.getArgAttr(blockArg.getArgNumber(), attributeName))
           return true;
     return false;
   }
 
   if (auto definingOp = value.getDefiningOp()) {
     // If this is an allocated value, look at the allocation attributes.
     if (mlir::isa<fir::AllocMemOp>(definingOp) ||
         mlir::isa<AllocaOp>(definingOp))
       return definingOp->hasAttr(attributeName);
     // If this is an imported global, look at AddrOfOp and GlobalOp attributes.
     // Both operations are looked at because use/host associated variable (the
     // AddrOfOp) can have ASYNCHRONOUS/VOLATILE attributes even if the ultimate
     // entity (the globalOp) does not have them.
     if (auto addressOfOp = mlir::dyn_cast<fir::AddrOfOp>(definingOp)) {
       if (addressOfOp->hasAttr(attributeName))
         return true;
       if (auto module = definingOp->getParentOfType<mlir::ModuleOp>())
         if (auto globalOp =
-                module.lookupSymbol<fir::GlobalOp>(addressOfOp.symbol()))
+                module.lookupSymbol<fir::GlobalOp>(addressOfOp.getSymbol()))
           return globalOp->hasAttr(attributeName);
     }
   }
   // TODO: Construct associated entities attributes. Decide where the fir
   // attributes must be placed/looked for in this case.
   return false;
 }
 

flang/lib/Optimizer/Transforms/AbstractResult.cpp

matchAndRewrite(fir::CallOp callOp,
     auto saveResult =
         mlir::dyn_cast<fir::SaveResultOp>(result.use_begin().getUser());
     if (!saveResult) {
       mlir::emitError(
           loc, "calls with abstract result must be used in fir.save_result");
       return mlir::failure();
     }
     auto argType = getResultArgumentType(result.getType(), options);
-    auto buffer = saveResult.memref();
+    auto buffer = saveResult.getMemref();
     mlir::Value arg = buffer;
     if (mustEmboxResult(result.getType(), options))
       arg = rewriter.create<fir::EmboxOp>(
-          loc, argType, buffer, saveResult.shape(), /*slice*/ mlir::Value{},
-          saveResult.typeparams());
+          loc, argType, buffer, saveResult.getShape(), /*slice*/ mlir::Value{},
+          saveResult.getTypeparams());
 
     llvm::SmallVector<mlir::Type> newResultTypes;
-    if (callOp.callee()) {
+    if (callOp.getCallee()) {
       llvm::SmallVector<mlir::Value> newOperands = {arg};
       newOperands.append(callOp.getOperands().begin(),
                          callOp.getOperands().end());
-      rewriter.create<fir::CallOp>(loc, callOp.callee().getValue(),
+      rewriter.create<fir::CallOp>(loc, callOp.getCallee().getValue(),
                                    newResultTypes, newOperands);
     } else {
       // Indirect calls.
       llvm::SmallVector<mlir::Type> newInputTypes = {argType};
       for (auto operand : callOp.getOperands().drop_front())
         newInputTypes.push_back(operand.getType());
       auto funTy = mlir::FunctionType::get(callOp.getContext(), newInputTypes,
                                            newResultTypes);
public:
   mlir::LogicalResult
   matchAndRewrite(mlir::ReturnOp ret,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.setInsertionPoint(ret);
     auto returnedValue = ret.getOperand(0);
     bool replacedStorage = false;
     if (auto *op = returnedValue.getDefiningOp())
       if (auto load = mlir::dyn_cast<fir::LoadOp>(op)) {
-        auto resultStorage = load.memref();
-        load.memref().replaceAllUsesWith(options.newArg);
+        auto resultStorage = load.getMemref();
+        load.getMemref().replaceAllUsesWith(options.newArg);
         replacedStorage = true;
         if (auto *alloc = resultStorage.getDefiningOp())
           if (alloc->use_empty())
             rewriter.eraseOp(alloc);
       }
     // The result storage may have been optimized out by a memory to
     // register pass, this is possible for fir.box results, or fir.record
     // with no length parameters. Simply store the result in the result storage.
AddrOfOpConversion(mlir::MLIRContext *context,
                      const AbstractResultOptions &opt)
       : OpRewritePattern(context), options{opt} {}
   mlir::LogicalResult
   matchAndRewrite(fir::AddrOfOp addrOf,
                   mlir::PatternRewriter &rewriter) const override {
     auto oldFuncTy = addrOf.getType().cast<mlir::FunctionType>();
     auto newFuncTy = getNewFunctionType(oldFuncTy, options);
     auto newAddrOf = rewriter.create<fir::AddrOfOp>(addrOf.getLoc(), newFuncTy,
-                                                    addrOf.symbol());
+                                                    addrOf.getSymbol());
     // Rather than converting all op a function pointer might transit through
     // (e.g calls, stores, loads, converts...), cast new type to the abstract
     // type. A conversion will be added when calling indirect calls of abstract
     // types.
     rewriter.replaceOpWithNewOp<fir::ConvertOp>(addrOf, oldFuncTy, newAddrOf);
     return mlir::success();
   }
 

flang/lib/Optimizer/Transforms/AffineDemotion.cpp

 };
 
 class ConvertConversion : public mlir::OpRewritePattern<fir::ConvertOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
   mlir::LogicalResult
   matchAndRewrite(fir::ConvertOp op,
                   mlir::PatternRewriter &rewriter) const override {
-    if (op.res().getType().isa<mlir::MemRefType>()) {
+    if (op.getRes().getType().isa<mlir::MemRefType>()) {
       // due to index calculation moving to affine maps we still need to
       // add converts for sequence types this has a side effect of losing
       // some information about arrays with known dimensions by creating:
       // fir.convert %arg0 : (!fir.ref<!fir.array<5xi32>>) ->
       // !fir.ref<!fir.array<?xi32>>
-      if (auto refTy = op.value().getType().dyn_cast<fir::ReferenceType>())
+      if (auto refTy = op.getValue().getType().dyn_cast<fir::ReferenceType>())
         if (auto arrTy = refTy.getEleTy().dyn_cast<fir::SequenceType>()) {
           fir::SequenceType::Shape flatShape = {
               fir::SequenceType::getUnknownExtent()};
           auto flatArrTy = fir::SequenceType::get(flatShape, arrTy.getEleTy());
           auto flatTy = fir::ReferenceType::get(flatArrTy);
-          rewriter.replaceOpWithNewOp<fir::ConvertOp>(op, flatTy, op.value());
+          rewriter.replaceOpWithNewOp<fir::ConvertOp>(op, flatTy,
+                                                      op.getValue());
           return success();
         }
       rewriter.startRootUpdate(op->getParentOp());
-      op.getResult().replaceAllUsesWith(op.value());
+      op.getResult().replaceAllUsesWith(op.getValue());
       rewriter.finalizeRootUpdate(op->getParentOp());
       rewriter.eraseOp(op);
     }
     return success();
   }
 };
 
 mlir::Type convertMemRef(mlir::MemRefType type) {
void runOnOperation() override {
     mlir::RewritePatternSet patterns(context);
     patterns.insert<ConvertConversion>(context);
     patterns.insert<AffineLoadConversion>(context);
     patterns.insert<AffineStoreConversion>(context);
     patterns.insert<StdAllocConversion>(context);
     mlir::ConversionTarget target(*context);
     target.addIllegalOp<memref::AllocOp>();
     target.addDynamicallyLegalOp<fir::ConvertOp>([](fir::ConvertOp op) {
-      if (op.res().getType().isa<mlir::MemRefType>())
+      if (op.getRes().getType().isa<mlir::MemRefType>())
         return false;
       return true;
     });
     target.addLegalDialect<FIROpsDialect, mlir::scf::SCFDialect,
                            mlir::arith::ArithmeticDialect,
                            mlir::StandardOpsDialect>();
 
     if (mlir::failed(mlir::applyPartialConversion(function, target,

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

bool analyzeLoop(fir::DoLoopOp loopOperation,
                    AffineFunctionAnalysis &functionAnalysis) {
     LLVM_DEBUG(llvm::dbgs() << "AffineLoopAnalysis: \n"; loopOperation.dump(););
     return analyzeMemoryAccess(loopOperation) &&
            analyzeBody(loopOperation, functionAnalysis);
   }
 
   bool analyzeReference(mlir::Value memref, mlir::Operation *op) {
     if (auto acoOp = memref.getDefiningOp<ArrayCoorOp>()) {
-      if (acoOp.memref().getType().isa<fir::BoxType>()) {
+      if (acoOp.getMemref().getType().isa<fir::BoxType>()) {
         // TODO: Look if and how fir.box can be promoted to affine.
         LLVM_DEBUG(llvm::dbgs() << "AffineLoopAnalysis: cannot promote loop, "
                                    "array memory operation uses fir.box\n";
                    op->dump(); acoOp.dump(););
         return false;
       }
       bool canPromote = true;
-      for (auto coordinate : acoOp.indices())
+      for (auto coordinate : acoOp.getIndices())
         canPromote = canPromote && analyzeCoordinate(coordinate, op);
       return canPromote;
     }
     if (auto coOp = memref.getDefiningOp<CoordinateOp>()) {
       LLVM_DEBUG(llvm::dbgs()
                      << "AffineLoopAnalysis: cannot promote loop, "
                         "array memory operation uses non ArrayCoorOp\n";
                  op->dump(); coOp.dump(););
 
       return false;
     }
     LLVM_DEBUG(llvm::dbgs() << "AffineLoopAnalysis: unknown type of memory "
                                "reference for array load\n";
                op->dump(););
     return false;
   }
 
   bool analyzeMemoryAccess(fir::DoLoopOp loopOperation) {
     for (auto loadOp : loopOperation.getOps<fir::LoadOp>())
-      if (!analyzeReference(loadOp.memref(), loadOp))
+      if (!analyzeReference(loadOp.getMemref(), loadOp))
         return false;
     for (auto storeOp : loopOperation.getOps<fir::StoreOp>())
-      if (!analyzeReference(storeOp.memref(), storeOp))
+      if (!analyzeReference(storeOp.getMemref(), storeOp))
         return false;
     return true;
   }
 
   bool legality{};
 };
 } // namespace
 

 static Optional<int64_t> constantIntegerLike(const mlir::Value value) {
   if (auto definition = value.getDefiningOp<mlir::arith::ConstantOp>())
     if (auto stepAttr = definition.getValue().dyn_cast<IntegerAttr>())
       return stepAttr.getInt();
   return {};
 }
 
 static mlir::Type coordinateArrayElement(fir::ArrayCoorOp op) {
-  if (auto refType = op.memref().getType().dyn_cast_or_null<ReferenceType>()) {
+  if (auto refType =
+          op.getMemref().getType().dyn_cast_or_null<ReferenceType>()) {
     if (auto seqType = refType.getEleTy().dyn_cast_or_null<SequenceType>()) {
       return seqType.getEleTy();
     }
   }
   op.emitError(
       "AffineLoopConversion: array type in coordinate operation not valid\n");
   return mlir::Type();
 }
 
 static void populateIndexArgs(fir::ArrayCoorOp acoOp, fir::ShapeOp shape,
                               SmallVectorImpl<mlir::Value> &indexArgs,
                               mlir::PatternRewriter &rewriter) {
   auto one = rewriter.create<mlir::arith::ConstantOp>(
       acoOp.getLoc(), rewriter.getIndexType(), rewriter.getIndexAttr(1));
-  auto extents = shape.extents();
+  auto extents = shape.getExtents();
   for (auto i = extents.begin(); i < extents.end(); i++) {
     indexArgs.push_back(one);
     indexArgs.push_back(*i);
     indexArgs.push_back(one);
   }
 }
 
 static void populateIndexArgs(fir::ArrayCoorOp acoOp, fir::ShapeShiftOp shape,
                               SmallVectorImpl<mlir::Value> &indexArgs,
                               mlir::PatternRewriter &rewriter) {
   auto one = rewriter.create<mlir::arith::ConstantOp>(
       acoOp.getLoc(), rewriter.getIndexType(), rewriter.getIndexAttr(1));
-  auto extents = shape.pairs();
+  auto extents = shape.getPairs();
   for (auto i = extents.begin(); i < extents.end();) {
     indexArgs.push_back(*i++);
     indexArgs.push_back(*i++);
     indexArgs.push_back(one);
   }
 }
 
 static void populateIndexArgs(fir::ArrayCoorOp acoOp, fir::SliceOp slice,
                               SmallVectorImpl<mlir::Value> &indexArgs,
                               mlir::PatternRewriter &rewriter) {
-  auto extents = slice.triples();
+  auto extents = slice.getTriples();
   for (auto i = extents.begin(); i < extents.end();) {
     indexArgs.push_back(*i++);
     indexArgs.push_back(*i++);
     indexArgs.push_back(*i++);
   }
 }
 
 static void populateIndexArgs(fir::ArrayCoorOp acoOp,
                               SmallVectorImpl<mlir::Value> &indexArgs,
                               mlir::PatternRewriter &rewriter) {
-  if (auto shape = acoOp.shape().getDefiningOp<ShapeOp>())
+  if (auto shape = acoOp.getShape().getDefiningOp<ShapeOp>())
     return populateIndexArgs(acoOp, shape, indexArgs, rewriter);
-  if (auto shapeShift = acoOp.shape().getDefiningOp<ShapeShiftOp>())
+  if (auto shapeShift = acoOp.getShape().getDefiningOp<ShapeShiftOp>())
     return populateIndexArgs(acoOp, shapeShift, indexArgs, rewriter);
-  if (auto slice = acoOp.shape().getDefiningOp<SliceOp>())
+  if (auto slice = acoOp.getShape().getDefiningOp<SliceOp>())
     return populateIndexArgs(acoOp, slice, indexArgs, rewriter);
   return;
 }
 
 /// Returns affine.apply and fir.convert from array_coor and gendims
 static std::pair<mlir::AffineApplyOp, fir::ConvertOp>
 createAffineOps(mlir::Value arrayRef, mlir::PatternRewriter &rewriter) {
   auto acoOp = arrayRef.getDefiningOp<ArrayCoorOp>();
   auto affineMap =
-      createArrayIndexAffineMap(acoOp.indices().size(), acoOp.getContext());
+      createArrayIndexAffineMap(acoOp.getIndices().size(), acoOp.getContext());
   SmallVector<mlir::Value> indexArgs;
-  indexArgs.append(acoOp.indices().begin(), acoOp.indices().end());
+  indexArgs.append(acoOp.getIndices().begin(), acoOp.getIndices().end());
 
   populateIndexArgs(acoOp, indexArgs, rewriter);
 
   auto affineApply = rewriter.create<mlir::AffineApplyOp>(acoOp.getLoc(),
                                                           affineMap, indexArgs);
   auto arrayElementType = coordinateArrayElement(acoOp);
   auto newType = mlir::MemRefType::get({-1}, arrayElementType);
-  auto arrayConvert =
-      rewriter.create<fir::ConvertOp>(acoOp.getLoc(), newType, acoOp.memref());
+  auto arrayConvert = rewriter.create<fir::ConvertOp>(acoOp.getLoc(), newType,
+                                                      acoOp.getMemref());
   return std::make_pair(affineApply, arrayConvert);
 }
 
 static void rewriteLoad(fir::LoadOp loadOp, mlir::PatternRewriter &rewriter) {
   rewriter.setInsertionPoint(loadOp);
-  auto affineOps = createAffineOps(loadOp.memref(), rewriter);
+  auto affineOps = createAffineOps(loadOp.getMemref(), rewriter);
   rewriter.replaceOpWithNewOp<mlir::AffineLoadOp>(
       loadOp, affineOps.second.getResult(), affineOps.first.getResult());
 }
 
 static void rewriteStore(fir::StoreOp storeOp,
                          mlir::PatternRewriter &rewriter) {
   rewriter.setInsertionPoint(storeOp);
-  auto affineOps = createAffineOps(storeOp.memref(), rewriter);
-  rewriter.replaceOpWithNewOp<mlir::AffineStoreOp>(storeOp, storeOp.value(),
+  auto affineOps = createAffineOps(storeOp.getMemref(), rewriter);
+  rewriter.replaceOpWithNewOp<mlir::AffineStoreOp>(storeOp, storeOp.getValue(),
                                                    affineOps.second.getResult(),
                                                    affineOps.first.getResult());
 }
 
 static void rewriteMemoryOps(Block *block, mlir::PatternRewriter &rewriter) {
   for (auto &bodyOp : block->getOperations()) {
     if (isa<fir::LoadOp>(bodyOp))
       rewriteLoad(cast<fir::LoadOp>(bodyOp), rewriter);
LLVM_DEBUG(llvm::dbgs() << "AffineLoopConversion: loop rewriten to:\n";
                affineFor.dump(););
     rewriter.replaceOp(loop, affineFor.getOperation()->getResults());
     return success();
   }
 
 private:
   std::pair<mlir::AffineForOp, mlir::Value>
   createAffineFor(fir::DoLoopOp op, mlir::PatternRewriter &rewriter) const {
-    if (auto constantStep = constantIntegerLike(op.step()))
+    if (auto constantStep = constantIntegerLike(op.getStep()))
       if (constantStep.getValue() > 0)
         return positiveConstantStep(op, constantStep.getValue(), rewriter);
     return genericBounds(op, rewriter);
   }
 
   // when step for the loop is positive compile time constant
   std::pair<mlir::AffineForOp, mlir::Value>
   positiveConstantStep(fir::DoLoopOp op, int64_t step,
                        mlir::PatternRewriter &rewriter) const {
     auto affineFor = rewriter.create<mlir::AffineForOp>(
-        op.getLoc(), ValueRange(op.lowerBound()),
+        op.getLoc(), ValueRange(op.getLowerBound()),
         mlir::AffineMap::get(0, 1,
                              mlir::getAffineSymbolExpr(0, op.getContext())),
-        ValueRange(op.upperBound()),
+        ValueRange(op.getUpperBound()),
         mlir::AffineMap::get(0, 1,
                              1 + mlir::getAffineSymbolExpr(0, op.getContext())),
         step);
     return std::make_pair(affineFor, affineFor.getInductionVar());
   }
 
   std::pair<mlir::AffineForOp, mlir::Value>
   genericBounds(fir::DoLoopOp op, mlir::PatternRewriter &rewriter) const {
     auto lowerBound = mlir::getAffineSymbolExpr(0, op.getContext());
     auto upperBound = mlir::getAffineSymbolExpr(1, op.getContext());
     auto step = mlir::getAffineSymbolExpr(2, op.getContext());
     mlir::AffineMap upperBoundMap = mlir::AffineMap::get(
         0, 3, (upperBound - lowerBound + step).floorDiv(step));
     auto genericUpperBound = rewriter.create<mlir::AffineApplyOp>(
         op.getLoc(), upperBoundMap,
-        ValueRange({op.lowerBound(), op.upperBound(), op.step()}));
+        ValueRange({op.getLowerBound(), op.getUpperBound(), op.getStep()}));
     auto actualIndexMap = mlir::AffineMap::get(
         1, 2,
         (lowerBound + mlir::getAffineDimExpr(0, op.getContext())) *
             mlir::getAffineSymbolExpr(1, op.getContext()));
 
     auto affineFor = rewriter.create<mlir::AffineForOp>(
         op.getLoc(), ValueRange(),
         AffineMap::getConstantMap(0, op.getContext()),
         genericUpperBound.getResult(),
         mlir::AffineMap::get(0, 1,
                              1 + mlir::getAffineSymbolExpr(0, op.getContext())),
         1);
     rewriter.setInsertionPointToStart(affineFor.getBody());
     auto actualIndex = rewriter.create<mlir::AffineApplyOp>(
         op.getLoc(), actualIndexMap,
-        ValueRange({affineFor.getInductionVar(), op.lowerBound(), op.step()}));
+        ValueRange(
+            {affineFor.getInductionVar(), op.getLowerBound(), op.getStep()}));
     return std::make_pair(affineFor, actualIndex.getResult());
   }
 
   AffineFunctionAnalysis &functionAnalysis;
 };
 
 /// Convert `fir.if` to `affine.if`.
 class AffineIfConversion : public mlir::OpRewritePattern<fir::IfOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
   AffineIfConversion(mlir::MLIRContext *context, AffineFunctionAnalysis &afa)
       : OpRewritePattern(context) {}
   mlir::LogicalResult
   matchAndRewrite(fir::IfOp op,
                   mlir::PatternRewriter &rewriter) const override {
     LLVM_DEBUG(llvm::dbgs() << "AffineIfConversion: rewriting if:\n";
                op.dump(););
-    auto &ifOps = op.thenRegion().front().getOperations();
-    auto affineCondition = AffineIfCondition(op.condition());
+    auto &ifOps = op.getThenRegion().front().getOperations();
+    auto affineCondition = AffineIfCondition(op.getCondition());
     if (!affineCondition.hasIntegerSet()) {
       LLVM_DEBUG(
           llvm::dbgs()
               << "AffineIfConversion: couldn't calculate affine condition\n";);
       return failure();
     }
     auto affineIf = rewriter.create<mlir::AffineIfOp>(
         op.getLoc(), affineCondition.getIntegerSet(),
-        affineCondition.getAffineArgs(), !op.elseRegion().empty());
+        affineCondition.getAffineArgs(), !op.getElseRegion().empty());
     rewriter.startRootUpdate(affineIf);
     affineIf.getThenBlock()->getOperations().splice(
         std::prev(affineIf.getThenBlock()->end()), ifOps, ifOps.begin(),
         std::prev(ifOps.end()));
-    if (!op.elseRegion().empty()) {
-      auto &otherOps = op.elseRegion().front().getOperations();
+    if (!op.getElseRegion().empty()) {
+      auto &otherOps = op.getElseRegion().front().getOperations();
       affineIf.getElseBlock()->getOperations().splice(
           std::prev(affineIf.getElseBlock()->end()), otherOps, otherOps.begin(),
           std::prev(otherOps.end()));
     }
     rewriter.finalizeRootUpdate(affineIf);
     rewriteMemoryOps(affineIf.getBody(), rewriter);
 
     LLVM_DEBUG(llvm::dbgs() << "AffineIfConversion: if converted to:\n";

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

if (auto rop = mlir::dyn_cast<fir::DoLoopOp>(op)) {
       return;
     }
     if (auto rop = mlir::dyn_cast<fir::IfOp>(op)) {
       popFn(rop);
       return;
     }
     if (auto mergeStore = mlir::dyn_cast<ArrayMergeStoreOp>(op)) {
       if (opIsInsideLoops(mergeStore))
-        collectArrayAccessFrom(mergeStore.sequence());
+        collectArrayAccessFrom(mergeStore.getSequence());
       return;
     }
 
     if (mlir::isa<AllocaOp, AllocMemOp>(op)) {
       // Look for any stores inside the loops, and collect an array operation
       // that produced the value being stored to it.
       for (mlir::Operation *user : op->getUsers())
         if (auto store = mlir::dyn_cast<fir::StoreOp>(user))
           if (opIsInsideLoops(store))
-            collectArrayAccessFrom(store.value());
+            collectArrayAccessFrom(store.getValue());
       return;
     }
 
     // Otherwise, Op does not contain a region so just chase its operands.
     if (mlir::isa<ArrayLoadOp, ArrayUpdateOp, ArrayModifyOp, ArrayFetchOp>(
             op)) {
       LLVM_DEBUG(llvm::dbgs() << "add " << *op << " to reachable set\n");
       reach.emplace_back(op);
ArrayCopyAnalysis::arrayAccesses(ArrayLoadOp load) {
   // Process the worklist until done.
   while (!queue.empty()) {
     mlir::OpOperand *operand = queue.pop_back_val();
     mlir::Operation *owner = operand->getOwner();
 
     auto structuredLoop = [&](auto ro) {
       if (auto blockArg = ro.iterArgToBlockArg(operand->get())) {
         int64_t arg = blockArg.getArgNumber();
-        mlir::Value output = ro.getResult(ro.finalValue() ? arg : arg - 1);
+        mlir::Value output = ro.getResult(ro.getFinalValue() ? arg : arg - 1);
         appendToQueue(output);
         appendToQueue(blockArg);
       }
     };
     // TODO: this need to be updated to use the control-flow interface.
     auto branchOp = [&](mlir::Block *dest, OperandRange operands) {
       if (operands.empty())
         return;

 }
 
 /// Is there a conflict between the array value that was updated and to be
 /// stored to `st` and the set of arrays loaded (`reach`) and used to compute
 /// the updated value?
 static bool conflictOnLoad(llvm::ArrayRef<mlir::Operation *> reach,
                            ArrayMergeStoreOp st) {
   mlir::Value load;
-  mlir::Value addr = st.memref();
+  mlir::Value addr = st.getMemref();
   auto stEleTy = fir::dyn_cast_ptrOrBoxEleTy(addr.getType());
   for (auto *op : reach) {
     auto ld = mlir::dyn_cast<ArrayLoadOp>(op);
     if (!ld)
       continue;
-    mlir::Type ldTy = ld.memref().getType();
+    mlir::Type ldTy = ld.getMemref().getType();
     if (auto boxTy = ldTy.dyn_cast<fir::BoxType>())
       ldTy = boxTy.getEleTy();
     if (ldTy.isa<fir::PointerType>() && stEleTy == dyn_cast_ptrEleTy(ldTy))
       return true;
-    if (ld.memref() == addr) {
-      if (ld.getResult() != st.original())
+    if (ld.getMemref() == addr) {
+      if (ld.getResult() != st.getOriginal())
         return true;
       if (load)
         return true;
       load = ld;
     }
   }
   return false;
 }
static bool conflictOnMerge(llvm::ArrayRef<mlir::Operation *> accesses) {
   LLVM_DEBUG(llvm::dbgs() << "check merge conflict on with " << accesses.size()
                           << " accesses on the list\n");
   for (auto *op : accesses) {
     assert((mlir::isa<ArrayFetchOp, ArrayUpdateOp, ArrayModifyOp>(op)) &&
            "unexpected operation in analysis");
     llvm::SmallVector<mlir::Value> compareVector;
     if (auto u = mlir::dyn_cast<ArrayUpdateOp>(op)) {
       if (indices.empty()) {
-        indices = u.indices();
+        indices = u.getIndices();
         continue;
       }
-      compareVector = u.indices();
+      compareVector = u.getIndices();
     } else if (auto f = mlir::dyn_cast<ArrayModifyOp>(op)) {
       if (indices.empty()) {
-        indices = f.indices();
+        indices = f.getIndices();
         continue;
       }
-      compareVector = f.indices();
+      compareVector = f.getIndices();
     } else if (auto f = mlir::dyn_cast<ArrayFetchOp>(op)) {
       if (indices.empty()) {
-        indices = f.indices();
+        indices = f.getIndices();
         continue;
       }
-      compareVector = f.indices();
+      compareVector = f.getIndices();
     }
     if (compareVector != indices)
       return true;
     LLVM_DEBUG(llvm::dbgs() << "vectors compare equal\n");
   }
   return false;
 }
 
 // Are either of types of conflicts present?
 inline bool conflictDetected(llvm::ArrayRef<mlir::Operation *> reach,
                              llvm::ArrayRef<mlir::Operation *> accesses,
                              ArrayMergeStoreOp st) {
   return conflictOnLoad(reach, st) || conflictOnMerge(accesses);
 }
 
 /// Constructor of the array copy analysis.
 /// This performs the analysis and saves the intermediate results.
 void ArrayCopyAnalysis::construct(mlir::Operation *topLevelOp) {
   topLevelOp->walk([&](Operation *op) {
     if (auto st = mlir::dyn_cast<fir::ArrayMergeStoreOp>(op)) {
       llvm::SmallVector<Operation *> values;
-      ReachCollector::reachingValues(values, st.sequence());
-      const llvm::SmallVector<Operation *> &accesses =
-          arrayAccesses(mlir::cast<ArrayLoadOp>(st.original().getDefiningOp()));
+      ReachCollector::reachingValues(values, st.getSequence());
+      const llvm::SmallVector<Operation *> &accesses = arrayAccesses(
+          mlir::cast<ArrayLoadOp>(st.getOriginal().getDefiningOp()));
       if (conflictDetected(values, accesses, st)) {
         LLVM_DEBUG(llvm::dbgs()
                    << "CONFLICT: copies required for " << st << '\n'
                    << "   adding conflicts on: " << op << " and "
-                   << st.original() << '\n');
+                   << st.getOriginal() << '\n');
         conflicts.insert(op);
-        conflicts.insert(st.original().getDefiningOp());
+        conflicts.insert(st.getOriginal().getDefiningOp());
       }
-      auto *ld = st.original().getDefiningOp();
+      auto *ld = st.getOriginal().getDefiningOp();
       LLVM_DEBUG(llvm::dbgs()
                  << "map: adding {" << *ld << " -> " << st << "}\n");
       useMap.insert({ld, op});
     } else if (auto load = mlir::dyn_cast<ArrayLoadOp>(op)) {
       const llvm::SmallVector<mlir::Operation *> &accesses =
           arrayAccesses(load);
       LLVM_DEBUG(llvm::dbgs() << "process load: " << load
                               << ", accesses: " << accesses.size() << '\n');

 // extents.
 // Otherwise, the extents will be extracted from the ShapeOp/ShapeShiftOp
 // argument of the ArrayLoadOp that is returned.
 static mlir::Value
 getOrReadExtentsAndShapeOp(mlir::Location loc, mlir::PatternRewriter &rewriter,
                            fir::ArrayLoadOp loadOp,
                            llvm::SmallVectorImpl<mlir::Value> &result) {
   assert(result.empty());
-  if (auto boxTy = loadOp.memref().getType().dyn_cast<fir::BoxType>()) {
+  if (auto boxTy = loadOp.getMemref().getType().dyn_cast<fir::BoxType>()) {
     auto rank = fir::dyn_cast_ptrOrBoxEleTy(boxTy)
                     .cast<fir::SequenceType>()
                     .getDimension();
     auto idxTy = rewriter.getIndexType();
     for (decltype(rank) dim = 0; dim < rank; ++dim) {
       auto dimVal = rewriter.create<arith::ConstantIndexOp>(loc, dim);
-      auto dimInfo = rewriter.create<fir::BoxDimsOp>(loc, idxTy, idxTy, idxTy,
-                                                     loadOp.memref(), dimVal);
+      auto dimInfo = rewriter.create<fir::BoxDimsOp>(
+          loc, idxTy, idxTy, idxTy, loadOp.getMemref(), dimVal);
       result.emplace_back(dimInfo.getResult(1));
     }
     auto shapeType = fir::ShapeType::get(rewriter.getContext(), rank);
     return rewriter.create<fir::ShapeOp>(loc, shapeType, result);
   }
-  getExtents(result, loadOp.shape());
-  return loadOp.shape();
+  getExtents(result, loadOp.getShape());
+  return loadOp.getShape();
 }
 
 static mlir::Type toRefType(mlir::Type ty) {
   if (fir::isa_ref_type(ty))
     return ty;
   return fir::ReferenceType::get(ty);
 }
 
if (analysis.hasPotentialConflict(loadOp)) {
       // the lhs array. This yields Fortran's copy-in copy-out array semantics.
       LLVM_DEBUG(llvm::outs() << "Yes, conflict was found\n");
       rewriter.setInsertionPoint(loadOp);
       // Copy in.
       llvm::SmallVector<mlir::Value> extents;
       mlir::Value shapeOp =
           getOrReadExtentsAndShapeOp(loc, rewriter, load, extents);
       auto allocmem = rewriter.create<AllocMemOp>(
-          loc, dyn_cast_ptrOrBoxEleTy(load.memref().getType()),
-          load.typeparams(), extents);
-      genArrayCopy(load.getLoc(), rewriter, allocmem, load.memref(), shapeOp,
+          loc, dyn_cast_ptrOrBoxEleTy(load.getMemref().getType()),
+          load.getTypeparams(), extents);
+      genArrayCopy(load.getLoc(), rewriter, allocmem, load.getMemref(), shapeOp,
                    load.getType());
       rewriter.setInsertionPoint(op);
       mlir::Value coor = genCoorOp(
           rewriter, loc, getEleTy(load.getType()), lhsEltRefType, allocmem,
-          shapeOp, load.slice(), update.indices(), load.typeparams(),
+          shapeOp, load.getSlice(), update.getIndices(), load.getTypeparams(),
           update->hasAttr(fir::factory::attrFortranArrayOffsets()));
       assignElement(coor);
       mlir::Operation *storeOp = useMap.lookup(loadOp);
       auto store = mlir::cast<ArrayMergeStoreOp>(storeOp);
       rewriter.setInsertionPoint(storeOp);
       // Copy out.
-      genArrayCopy(store.getLoc(), rewriter, store.memref(), allocmem, shapeOp,
-                   load.getType());
+      genArrayCopy(store.getLoc(), rewriter, store.getMemref(), allocmem,
+                   shapeOp, load.getType());
       rewriter.create<FreeMemOp>(loc, allocmem);
       return {coor, load.getResult()};
     }
     // Otherwise, when there is no conflict (a possible loop-carried
     // dependence), the lhs array can be updated in place.
     LLVM_DEBUG(llvm::outs() << "No, conflict wasn't found\n");
     rewriter.setInsertionPoint(op);
     auto coorTy = getEleTy(load.getType());
     mlir::Value coor = genCoorOp(
-        rewriter, loc, coorTy, lhsEltRefType, load.memref(), load.shape(),
-        load.slice(), update.indices(), load.typeparams(),
+        rewriter, loc, coorTy, lhsEltRefType, load.getMemref(), load.getShape(),
+        load.getSlice(), update.getIndices(), load.getTypeparams(),
         update->hasAttr(fir::factory::attrFortranArrayOffsets()));
     assignElement(coor);
     return {coor, load.getResult()};
   }
 
 private:
   const ArrayCopyAnalysis &analysis;
   const OperationUseMapT &useMap;
 };
 
 class ArrayUpdateConversion : public ArrayUpdateConversionBase<ArrayUpdateOp> {
 public:
   explicit ArrayUpdateConversion(mlir::MLIRContext *ctx,
                                  const ArrayCopyAnalysis &a,
                                  const OperationUseMapT &m)
       : ArrayUpdateConversionBase{ctx, a, m} {}
 
   mlir::LogicalResult
   matchAndRewrite(ArrayUpdateOp update,
                   mlir::PatternRewriter &rewriter) const override {
     auto loc = update.getLoc();
     auto assignElement = [&](mlir::Value coor) {
-      rewriter.create<fir::StoreOp>(loc, update.merge(), coor);
+      rewriter.create<fir::StoreOp>(loc, update.getMerge(), coor);
     };
-    auto lhsEltRefType = toRefType(update.merge().getType());
+    auto lhsEltRefType = toRefType(update.getMerge().getType());
     auto [_, lhsLoadResult] = materializeAssignment(
         loc, rewriter, update, assignElement, lhsEltRefType);
     update.replaceAllUsesWith(lhsLoadResult);
     rewriter.replaceOp(update, lhsLoadResult);
     return mlir::success();
   }
 };
 
public:
   matchAndRewrite(ArrayFetchOp fetch,
                   mlir::PatternRewriter &rewriter) const override {
     auto *op = fetch.getOperation();
     rewriter.setInsertionPoint(op);
     auto load = mlir::cast<ArrayLoadOp>(useMap.lookup(op));
     auto loc = fetch.getLoc();
     mlir::Value coor =
         genCoorOp(rewriter, loc, getEleTy(load.getType()),
-                  toRefType(fetch.getType()), load.memref(), load.shape(),
-                  load.slice(), fetch.indices(), load.typeparams(),
+                  toRefType(fetch.getType()), load.getMemref(), load.getShape(),
+                  load.getSlice(), fetch.getIndices(), load.getTypeparams(),
                   fetch->hasAttr(fir::factory::attrFortranArrayOffsets()));
     rewriter.replaceOpWithNewOp<fir::LoadOp>(fetch, coor);
     return mlir::success();
   }
 
 private:
   const OperationUseMapT &useMap;
 };

flang/lib/Optimizer/Transforms/CharacterConversion.cpp

matchAndRewrite(fir::CharConvertOp conv,
 
     LLVM_DEBUG(llvm::dbgs()
                << "running character conversion on " << conv << '\n');
 
     // Establish a loop that executes count iterations.
     auto zero = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0);
     auto one = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 1);
     auto idxTy = rewriter.getIndexType();
-    auto castCnt = rewriter.create<fir::ConvertOp>(loc, idxTy, conv.count());
+    auto castCnt = rewriter.create<fir::ConvertOp>(loc, idxTy, conv.getCount());
     auto countm1 = rewriter.create<mlir::arith::SubIOp>(loc, castCnt, one);
     auto loop = rewriter.create<fir::DoLoopOp>(loc, zero, countm1, one);
     auto insPt = rewriter.saveInsertionPoint();
     rewriter.setInsertionPointToStart(loop.getBody());
 
     // For each code point in the `from` string, convert naively to the `to`
     // string code point. Conversion is done blindly on size only, not value.
     auto getCharBits = [&](mlir::Type t) {
       auto chrTy = fir::unwrapSequenceType(fir::dyn_cast_ptrEleTy(t))
                        .cast<fir::CharacterType>();
       return kindMap.getCharacterBitsize(chrTy.getFKind());
     };
-    auto fromBits = getCharBits(conv.from().getType());
-    auto toBits = getCharBits(conv.to().getType());
+    auto fromBits = getCharBits(conv.getFrom().getType());
+    auto toBits = getCharBits(conv.getTo().getType());
     auto pointerType = [&](unsigned bits) {
       return fir::ReferenceType::get(fir::SequenceType::get(
           fir::SequenceType::ShapeRef{fir::SequenceType::getUnknownExtent()},
           rewriter.getIntegerType(bits)));
     };
     auto fromPtrTy = pointerType(fromBits);
     auto toTy = rewriter.getIntegerType(toBits);
     auto toPtrTy = pointerType(toBits);
-    auto fromPtr = rewriter.create<fir::ConvertOp>(loc, fromPtrTy, conv.from());
-    auto toPtr = rewriter.create<fir::ConvertOp>(loc, toPtrTy, conv.to());
+    auto fromPtr =
+        rewriter.create<fir::ConvertOp>(loc, fromPtrTy, conv.getFrom());
+    auto toPtr = rewriter.create<fir::ConvertOp>(loc, toPtrTy, conv.getTo());
     auto getEleTy = [&](unsigned bits) {
       return fir::ReferenceType::get(rewriter.getIntegerType(bits));
     };
     auto fromi = rewriter.create<fir::CoordinateOp>(
         loc, getEleTy(fromBits), fromPtr,
         mlir::ValueRange{loop.getInductionVar()});
     auto toi = rewriter.create<fir::CoordinateOp>(
         loc, getEleTy(toBits), toPtr, mlir::ValueRange{loop.getInductionVar()});

flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp

 class MangleNameOnCallOp : public mlir::OpRewritePattern<fir::CallOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   mlir::LogicalResult
   matchAndRewrite(fir::CallOp op,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
-    auto callee = op.callee();
+    auto callee = op.getCallee();
     if (callee.hasValue()) {
       auto result = fir::NameUniquer::deconstruct(
           callee.getValue().getRootReference().getValue());
       if (fir::NameUniquer::isExternalFacingUniquedName(result))
-        op.calleeAttr(
+        op.setCalleeAttr(
             SymbolRefAttr::get(op.getContext(), mangleExternalName(result)));
     }
     rewriter.finalizeRootUpdate(op);
     return success();
   }
 };
 
 struct MangleNameOnFuncOp : public mlir::OpRewritePattern<mlir::FuncOp> {

 public:
   using OpRewritePattern::OpRewritePattern;
 
   mlir::LogicalResult
   matchAndRewrite(fir::GlobalOp op,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
     auto result = fir::NameUniquer::deconstruct(
-        op.symref().getRootReference().getValue());
+        op.getSymref().getRootReference().getValue());
     if (fir::NameUniquer::isExternalFacingUniquedName(result)) {
       auto newName = mangleExternalName(result);
-      op.symrefAttr(mlir::SymbolRefAttr::get(op.getContext(), newName));
+      op.setSymrefAttr(mlir::SymbolRefAttr::get(op.getContext(), newName));
       SymbolTable::setSymbolName(op, newName);
     }
     rewriter.finalizeRootUpdate(op);
     return success();
   }
 };
 
 struct MangleNameOnAddrOfOp : public mlir::OpRewritePattern<fir::AddrOfOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   mlir::LogicalResult
   matchAndRewrite(fir::AddrOfOp op,
                   mlir::PatternRewriter &rewriter) const override {
     auto result = fir::NameUniquer::deconstruct(
-        op.symbol().getRootReference().getValue());
+        op.getSymbol().getRootReference().getValue());
     if (fir::NameUniquer::isExternalFacingUniquedName(result)) {
       auto newName =
           SymbolRefAttr::get(op.getContext(), mangleExternalName(result));
-      rewriter.replaceOpWithNewOp<fir::AddrOfOp>(op, op.resTy().getType(),
+      rewriter.replaceOpWithNewOp<fir::AddrOfOp>(op, op.getResTy().getType(),
                                                  newName);
     }
     return success();
   }
 };
 
 struct MangleNameOnEmboxProcOp
     : public mlir::OpRewritePattern<fir::EmboxProcOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   mlir::LogicalResult
   matchAndRewrite(fir::EmboxProcOp op,
                   mlir::PatternRewriter &rewriter) const override {
     rewriter.startRootUpdate(op);
     auto result = fir::NameUniquer::deconstruct(
-        op.funcname().getRootReference().getValue());
+        op.getFuncname().getRootReference().getValue());
     if (fir::NameUniquer::isExternalFacingUniquedName(result))
-      op.funcnameAttr(
+      op.setFuncnameAttr(
           SymbolRefAttr::get(op.getContext(), mangleExternalName(result)));
     rewriter.finalizeRootUpdate(op);
     return success();
   }
 };
 
 class ExternalNameConversionPass
     : public fir::ExternalNameConversionBase<ExternalNameConversionPass> {
patterns.insert<MangleNameOnCallOp, MangleNameOnCallOp, MangleNameOnFuncOp,
                   MangleNameForCommonBlock, MangleNameOnAddrOfOp,
                   MangleNameOnEmboxProcOp>(context);
 
   ConversionTarget target(*context);
   target.addLegalDialect<fir::FIROpsDialect, LLVM::LLVMDialect,
                          acc::OpenACCDialect, omp::OpenMPDialect>();
 
   target.addDynamicallyLegalOp<fir::CallOp>([](fir::CallOp op) {
-    if (op.callee().hasValue())
+    if (op.getCallee().hasValue())
       return !fir::NameUniquer::needExternalNameMangling(
-          op.callee().getValue().getRootReference().getValue());
+          op.getCallee().getValue().getRootReference().getValue());
     return true;
   });
 
   target.addDynamicallyLegalOp<mlir::FuncOp>([](mlir::FuncOp op) {
     return !fir::NameUniquer::needExternalNameMangling(op.sym_name());
   });
 
   target.addDynamicallyLegalOp<fir::GlobalOp>([](fir::GlobalOp op) {
     return !fir::NameUniquer::needExternalNameMangling(
-        op.symref().getRootReference().getValue());
+        op.getSymref().getRootReference().getValue());
   });
 
   target.addDynamicallyLegalOp<fir::AddrOfOp>([](fir::AddrOfOp op) {
     return !fir::NameUniquer::needExternalNameMangling(
-        op.symbol().getRootReference().getValue());
+        op.getSymbol().getRootReference().getValue());
   });
 
   target.addDynamicallyLegalOp<fir::EmboxProcOp>([](fir::EmboxProcOp op) {
     return !fir::NameUniquer::needExternalNameMangling(
-        op.funcname().getRootReference().getValue());
+        op.getFuncname().getRootReference().getValue());
   });
 
   if (failed(applyPartialConversion(op, target, std::move(patterns))))
     signalPassFailure();
 }
 
 std::unique_ptr<mlir::Pass> fir::createExternalNameConversionPass() {
   return std::make_unique<ExternalNameConversionPass>();
 }

flang/lib/Optimizer/Transforms/MemRefDataFlowOpt.cpp

 public:
   void runOnOperation() override {
     mlir::FuncOp f = getOperation();
 
     auto *domInfo = &getAnalysis<mlir::DominanceInfo>();
     LoadStoreForwarding<fir::LoadOp, fir::StoreOp> lsf(domInfo);
     f.walk([&](fir::LoadOp loadOp) {
       auto maybeStore = lsf.findStoreToForward(
-          loadOp, getSpecificUsers<fir::StoreOp>(loadOp.memref()));
+          loadOp, getSpecificUsers<fir::StoreOp>(loadOp.getMemref()));
       if (maybeStore) {
         auto storeOp = maybeStore.getValue();
         LLVM_DEBUG(llvm::dbgs() << "FlangMemDataFlowOpt: In " << f.getName()
                                 << " erasing load " << loadOp
                                 << " with value from " << storeOp << '\n');
-        loadOp.getResult().replaceAllUsesWith(storeOp.value());
+        loadOp.getResult().replaceAllUsesWith(storeOp.getValue());
         loadOp.erase();
       }
     });
     f.walk([&](fir::AllocaOp alloca) {
       for (auto &storeOp : getSpecificUsers<fir::StoreOp>(alloca.getResult())) {
         if (!lsf.findReadForWrite(
-                storeOp, getSpecificUsers<fir::LoadOp>(storeOp.memref()))) {
+                storeOp, getSpecificUsers<fir::LoadOp>(storeOp.getMemref()))) {
           LLVM_DEBUG(llvm::dbgs() << "FlangMemDataFlowOpt: In " << f.getName()
                                   << " erasing store " << storeOp << '\n');
           storeOp.erase();
         }
       }
     });
   }
 };
 } // namespace
 
 std::unique_ptr<mlir::Pass> fir::createMemDataFlowOptPass() {
   return std::make_unique<MemDataFlowOpt>();
 }

flang/lib/Optimizer/Transforms/MemoryAllocation.cpp

matchAndRewrite(fir::AllocaOp alloca,
     auto loc = alloca.getLoc();
     mlir::Type varTy = alloca.getInType();
     auto unpackName =
         [](llvm::Optional<llvm::StringRef> opt) -> llvm::StringRef {
       if (opt)
         return *opt;
       return {};
     };
-    auto uniqName = unpackName(alloca.uniq_name());
-    auto bindcName = unpackName(alloca.bindc_name());
+    auto uniqName = unpackName(alloca.getUniqName());
+    auto bindcName = unpackName(alloca.getBindcName());
     auto heap = rewriter.create<fir::AllocMemOp>(
-        loc, varTy, uniqName, bindcName, alloca.typeparams(), alloca.shape());
+        loc, varTy, uniqName, bindcName, alloca.getTypeparams(),
+        alloca.getShape());
     auto insPt = rewriter.saveInsertionPoint();
     for (mlir::Operation *retOp : returnOps) {
       rewriter.setInsertionPoint(retOp);
       [[maybe_unused]] auto free = rewriter.create<fir::FreeMemOp>(loc, heap);
       LLVM_DEBUG(llvm::dbgs() << "memory allocation opt: add free " << free
                               << " for " << heap << '\n');
     }
     rewriter.restoreInsertionPoint(insPt);

flang/lib/Optimizer/Transforms/RewriteLoop.cpp

matchAndRewrite(DoLoopOp loop,
     // initalizer and an end point
     auto *initBlock = rewriter.getInsertionBlock();
     auto initPos = rewriter.getInsertionPoint();
     auto *endBlock = rewriter.splitBlock(initBlock, initPos);
 
     // Split the first DoLoopOp block in two parts. The part before will be the
     // conditional block since it already has the induction variable and
     // loop-carried values as arguments.
-    auto *conditionalBlock = &loop.region().front();
+    auto *conditionalBlock = &loop.getRegion().front();
     conditionalBlock->addArgument(rewriter.getIndexType(), loc);
     auto *firstBlock =
         rewriter.splitBlock(conditionalBlock, conditionalBlock->begin());
-    auto *lastBlock = &loop.region().back();
+    auto *lastBlock = &loop.getRegion().back();
 
     // Move the blocks from the DoLoopOp between initBlock and endBlock
-    rewriter.inlineRegionBefore(loop.region(), endBlock);
+    rewriter.inlineRegionBefore(loop.getRegion(), endBlock);
 
     // Get loop values from the DoLoopOp
-    auto low = loop.lowerBound();
-    auto high = loop.upperBound();
+    auto low = loop.getLowerBound();
+    auto high = loop.getUpperBound();
     assert(low && high && "must be a Value");
-    auto step = loop.step();
+    auto step = loop.getStep();
 
     // Initalization block
     rewriter.setInsertionPointToEnd(initBlock);
     auto diff = rewriter.create<mlir::arith::SubIOp>(loc, high, low);
     auto distance = rewriter.create<mlir::arith::AddIOp>(loc, diff, step);
     mlir::Value iters =
         rewriter.create<mlir::arith::DivSIOp>(loc, distance, step);
 
matchAndRewrite(DoLoopOp loop,
     auto lastArg = conditionalBlock->getNumArguments() - 1;
     auto itersLeft = conditionalBlock->getArgument(lastArg);
     auto one = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 1);
     mlir::Value itersMinusOne =
         rewriter.create<mlir::arith::SubIOp>(loc, itersLeft, one);
 
     llvm::SmallVector<mlir::Value> loopCarried;
     loopCarried.push_back(steppedIndex);
-    auto begin = loop.finalValue() ? std::next(terminator->operand_begin())
+    auto begin = loop.getFinalValue() ? std::next(terminator->operand_begin())
                                       : terminator->operand_begin();
     loopCarried.append(begin, terminator->operand_end());
     loopCarried.push_back(itersMinusOne);
     rewriter.create<mlir::cf::BranchOp>(loc, conditionalBlock, loopCarried);
     rewriter.eraseOp(terminator);
 
     // Conditional block
     rewriter.setInsertionPointToEnd(conditionalBlock);
     auto zero = rewriter.create<mlir::arith::ConstantIndexOp>(loc, 0);
     auto comparison = rewriter.create<mlir::arith::CmpIOp>(
         loc, arith::CmpIPredicate::sgt, itersLeft, zero);
 
     rewriter.create<mlir::cf::CondBranchOp>(
         loc, comparison, firstBlock, llvm::ArrayRef<mlir::Value>(), endBlock,
         llvm::ArrayRef<mlir::Value>());
 
     // The result of the loop operation is the values of the condition block
     // arguments except the induction variable on the last iteration.
-    auto args = loop.finalValue()
+    auto args = loop.getFinalValue()
                     ? conditionalBlock->getArguments()
                     : conditionalBlock->getArguments().drop_front();
     rewriter.replaceOp(loop, args.drop_back());
     return success();
   }
 
 private:
   bool forceLoopToExecuteOnce;
matchAndRewrite(IfOp ifOp, mlir::PatternRewriter &rewriter) const override {
     } else {
       continueBlock =
           rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes());
       rewriter.create<mlir::cf::BranchOp>(loc, remainingOpsBlock);
     }
 
     // Move blocks from the "then" region to the region containing 'fir.if',
     // place it before the continuation block, and branch to it.
-    auto &ifOpRegion = ifOp.thenRegion();
+    auto &ifOpRegion = ifOp.getThenRegion();
     auto *ifOpBlock = &ifOpRegion.front();
     auto *ifOpTerminator = ifOpRegion.back().getTerminator();
     auto ifOpTerminatorOperands = ifOpTerminator->getOperands();
     rewriter.setInsertionPointToEnd(&ifOpRegion.back());
     rewriter.create<mlir::cf::BranchOp>(loc, continueBlock,
                                         ifOpTerminatorOperands);
     rewriter.eraseOp(ifOpTerminator);
     rewriter.inlineRegionBefore(ifOpRegion, continueBlock);
 
     // Move blocks from the "else" region (if present) to the region containing
     // 'fir.if', place it before the continuation block and branch to it.  It
     // will be placed after the "then" regions.
     auto *otherwiseBlock = continueBlock;
-    auto &otherwiseRegion = ifOp.elseRegion();
+    auto &otherwiseRegion = ifOp.getElseRegion();
     if (!otherwiseRegion.empty()) {
       otherwiseBlock = &otherwiseRegion.front();
       auto *otherwiseTerm = otherwiseRegion.back().getTerminator();
       auto otherwiseTermOperands = otherwiseTerm->getOperands();
       rewriter.setInsertionPointToEnd(&otherwiseRegion.back());
       rewriter.create<mlir::cf::BranchOp>(loc, continueBlock,
                                           otherwiseTermOperands);
       rewriter.eraseOp(otherwiseTerm);
       rewriter.inlineRegionBefore(otherwiseRegion, continueBlock);
     }
 
     rewriter.setInsertionPointToEnd(condBlock);
     rewriter.create<mlir::cf::CondBranchOp>(
-        loc, ifOp.condition(), ifOpBlock, llvm::ArrayRef<mlir::Value>(),
+        loc, ifOp.getCondition(), ifOpBlock, llvm::ArrayRef<mlir::Value>(),
         otherwiseBlock, llvm::ArrayRef<mlir::Value>());
     rewriter.replaceOp(ifOp, continueBlock->getArguments());
     return success();
   }
 };
 
 /// Convert `fir.iter_while` to control-flow.
 class CfgIterWhileConv : public mlir::OpRewritePattern<fir::IterWhileOp> {
matchAndRewrite(fir::IterWhileOp whileOp,
     auto initPosition = rewriter.getInsertionPoint();
     auto *endBlock = rewriter.splitBlock(initBlock, initPosition);
 
     // Use the first block of the loop body as the condition block since it is
     // the block that has the induction variable and loop-carried values as
     // arguments. Split out all operations from the first block into a new
     // block. Move all body blocks from the loop body region to the region
     // containing the loop.
-    auto *conditionBlock = &whileOp.region().front();
+    auto *conditionBlock = &whileOp.getRegion().front();
     auto *firstBodyBlock =
         rewriter.splitBlock(conditionBlock, conditionBlock->begin());
-    auto *lastBodyBlock = &whileOp.region().back();
-    rewriter.inlineRegionBefore(whileOp.region(), endBlock);
+    auto *lastBodyBlock = &whileOp.getRegion().back();
+    rewriter.inlineRegionBefore(whileOp.getRegion(), endBlock);
     auto iv = conditionBlock->getArgument(0);
     auto iterateVar = conditionBlock->getArgument(1);
 
     // Append the induction variable stepping logic to the last body block and
     // branch back to the condition block. Loop-carried values are taken from
     // operands of the loop terminator.
     auto *terminator = lastBodyBlock->getTerminator();
     rewriter.setInsertionPointToEnd(lastBodyBlock);
-    auto step = whileOp.step();
+    auto step = whileOp.getStep();
     mlir::Value stepped = rewriter.create<mlir::arith::AddIOp>(loc, iv, step);
     assert(stepped && "must be a Value");
 
     llvm::SmallVector<mlir::Value> loopCarried;
     loopCarried.push_back(stepped);
-    auto begin = whileOp.finalValue() ? std::next(terminator->operand_begin())
-                                      : terminator->operand_begin();
+    auto begin = whileOp.getFinalValue()
+                     ? std::next(terminator->operand_begin())
     loopCarried.append(begin, terminator->operand_end());
     rewriter.create<mlir::cf::BranchOp>(loc, conditionBlock, loopCarried);
     rewriter.eraseOp(terminator);
 
     // Compute loop bounds before branching to the condition.
     rewriter.setInsertionPointToEnd(initBlock);
-    auto lowerBound = whileOp.lowerBound();
-    auto upperBound = whileOp.upperBound();
+    auto lowerBound = whileOp.getLowerBound();
+    auto upperBound = whileOp.getUpperBound();
     assert(lowerBound && upperBound && "must be a Value");
 
     // The initial values of loop-carried values is obtained from the operands
     // of the loop operation.
     llvm::SmallVector<mlir::Value> destOperands;
     destOperands.push_back(lowerBound);
     auto iterOperands = whileOp.getIterOperands();
     destOperands.append(iterOperands.begin(), iterOperands.end());
matchAndRewrite(fir::IterWhileOp whileOp,
     // Remember to AND in the early-exit bool.
     auto comparison =
         rewriter.create<mlir::arith::AndIOp>(loc, iterateVar, cmp2);
     rewriter.create<mlir::cf::CondBranchOp>(
         loc, comparison, firstBodyBlock, llvm::ArrayRef<mlir::Value>(),
         endBlock, llvm::ArrayRef<mlir::Value>());
     // The result of the loop operation is the values of the condition block
     // arguments except the induction variable on the last iteration.
-    auto args = whileOp.finalValue()
+    auto args = whileOp.getFinalValue()
                     ? conditionBlock->getArguments()
                     : conditionBlock->getArguments().drop_front();
     rewriter.replaceOp(whileOp, args);
     return success();
   }
 };
 
 /// Convert FIR structured control flow ops to CFG ops.

flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp

 TEST_F(DoLoopHelperTest, createLoopWithCountTest) {
   auto firBuilder = getBuilder();
   fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
 
   auto c10 = firBuilder.createIntegerConstant(
       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 10);
   auto loop =
       helper.createLoop(c10, [&](fir::FirOpBuilder &, mlir::Value index) {});
-  checkConstantValue(loop.lowerBound(), 0);
-  EXPECT_TRUE(mlir::isa<arith::SubIOp>(loop.upperBound().getDefiningOp()));
-  auto subOp = dyn_cast<arith::SubIOp>(loop.upperBound().getDefiningOp());
+  checkConstantValue(loop.getLowerBound(), 0);
+  EXPECT_TRUE(mlir::isa<arith::SubIOp>(loop.getUpperBound().getDefiningOp()));
+  auto subOp = dyn_cast<arith::SubIOp>(loop.getUpperBound().getDefiningOp());
   EXPECT_EQ(c10, subOp.getLhs());
   checkConstantValue(subOp.getRhs(), 1);
   checkConstantValue(loop.getStep(), 1);
 }
 
 TEST_F(DoLoopHelperTest, createLoopWithLowerAndUpperBound) {
   auto firBuilder = getBuilder();
   fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());

flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp

 
 TEST_F(FIRBuilderTest, createGlobal1) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto i64Type = IntegerType::get(builder.getContext(), 64);
   auto global = builder.createGlobal(
       loc, i64Type, "global1", builder.createInternalLinkage(), {}, true);
   EXPECT_TRUE(mlir::isa<fir::GlobalOp>(global));
-  EXPECT_EQ("global1", global.sym_name());
-  EXPECT_TRUE(global.constant().hasValue());
+  EXPECT_EQ("global1", global.getSymName());
+  EXPECT_TRUE(global.getConstant().hasValue());
   EXPECT_EQ(i64Type, global.type());
-  EXPECT_TRUE(global.linkName().hasValue());
-  EXPECT_EQ(
-      builder.createInternalLinkage().getValue(), global.linkName().getValue());
-  EXPECT_FALSE(global.initVal().hasValue());
+  EXPECT_TRUE(global.getLinkName().hasValue());
+  EXPECT_EQ(builder.createInternalLinkage().getValue(),
+      global.getLinkName().getValue());
+  EXPECT_FALSE(global.getInitVal().hasValue());
 
   auto g1 = builder.getNamedGlobal("global1");
   EXPECT_EQ(global, g1);
   auto g2 = builder.getNamedGlobal("global7");
   EXPECT_EQ(nullptr, g2);
   auto g3 = builder.getNamedGlobal("");
   EXPECT_EQ(nullptr, g3);
 }
 
 TEST_F(FIRBuilderTest, createGlobal2) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto i32Type = IntegerType::get(builder.getContext(), 32);
   auto attr = builder.getIntegerAttr(i32Type, 16);
   auto global = builder.createGlobal(
       loc, i32Type, "global2", builder.createLinkOnceLinkage(), attr, false);
   EXPECT_TRUE(mlir::isa<fir::GlobalOp>(global));
-  EXPECT_EQ("global2", global.sym_name());
-  EXPECT_FALSE(global.constant().hasValue());
+  EXPECT_EQ("global2", global.getSymName());
+  EXPECT_FALSE(global.getConstant().hasValue());
   EXPECT_EQ(i32Type, global.type());
-  EXPECT_TRUE(global.initVal().hasValue());
-  EXPECT_TRUE(global.initVal().getValue().isa<mlir::IntegerAttr>());
-  EXPECT_EQ(
-      16, global.initVal().getValue().cast<mlir::IntegerAttr>().getValue());
-  EXPECT_TRUE(global.linkName().hasValue());
+  EXPECT_TRUE(global.getInitVal().hasValue());
+  EXPECT_TRUE(global.getInitVal().getValue().isa<mlir::IntegerAttr>());
   EXPECT_EQ(
-      builder.createLinkOnceLinkage().getValue(), global.linkName().getValue());
+      16, global.getInitVal().getValue().cast<mlir::IntegerAttr>().getValue());
+  EXPECT_TRUE(global.getLinkName().hasValue());
+  EXPECT_EQ(builder.createLinkOnceLinkage().getValue(),
+      global.getLinkName().getValue());
 }
 
 TEST_F(FIRBuilderTest, uniqueCFIdent) {
   auto str1 = fir::factory::uniqueCGIdent("", "func1");
   EXPECT_EQ("_QQ.66756E6331", str1);
   str1 = fir::factory::uniqueCGIdent("", "");
   EXPECT_EQ("_QQ.", str1);
   str1 = fir::factory::uniqueCGIdent("pr", "func1");

 }
 
 TEST_F(FIRBuilderTest, locationToFilename) {
   auto builder = getBuilder();
   auto loc =
       mlir::FileLineColLoc::get(builder.getStringAttr("file1.f90"), 10, 5);
   mlir::Value locToFile = fir::factory::locationToFilename(builder, loc);
   auto addrOp = dyn_cast<fir::AddrOfOp>(locToFile.getDefiningOp());
-  auto symbol = addrOp.symbol().getRootReference().getValue();
+  auto symbol = addrOp.getSymbol().getRootReference().getValue();
   auto global = builder.getNamedGlobal(symbol);
   auto stringLitOps = global.getRegion().front().getOps<fir::StringLitOp>();
   EXPECT_TRUE(llvm::hasSingleElement(stringLitOps));
   for (auto stringLit : stringLitOps) {
     EXPECT_EQ(10, stringLit.getSize().cast<mlir::IntegerAttr>().getValue());
     EXPECT_TRUE(stringLit.getValue().isa<StringAttr>());
     EXPECT_EQ(0,
         strcmp("file1.f90\0",
TEST_F(FIRBuilderTest, createStringLiteral) {
   auto *charBox = strLit.getCharBox();
   EXPECT_FALSE(fir::isArray(*charBox));
   checkIntegerConstant(charBox->getLen(), builder.getCharacterLengthType(), 16);
   auto generalGetLen = fir::getLen(strLit);
   checkIntegerConstant(generalGetLen, builder.getCharacterLengthType(), 16);
   auto addr = charBox->getBuffer();
   EXPECT_TRUE(mlir::isa<fir::AddrOfOp>(addr.getDefiningOp()));
   auto addrOp = dyn_cast<fir::AddrOfOp>(addr.getDefiningOp());
-  auto symbol = addrOp.symbol().getRootReference().getValue();
+  auto symbol = addrOp.getSymbol().getRootReference().getValue();
   auto global = builder.getNamedGlobal(symbol);
-  EXPECT_EQ(
-      builder.createLinkOnceLinkage().getValue(), global.linkName().getValue());
+  EXPECT_EQ(builder.createLinkOnceLinkage().getValue(),
+      global.getLinkName().getValue());
   EXPECT_EQ(fir::CharacterType::get(builder.getContext(), 1, strValue.size()),
       global.type());
 
   auto stringLitOps = global.getRegion().front().getOps<fir::StringLitOp>();
   EXPECT_TRUE(llvm::hasSingleElement(stringLitOps));
   for (auto stringLit : stringLitOps) {
     EXPECT_EQ(16, stringLit.getSize().cast<mlir::IntegerAttr>().getValue());
     EXPECT_TRUE(stringLit.getValue().isa<StringAttr>());
     EXPECT_EQ(strValue, stringLit.getValue().dyn_cast<StringAttr>().getValue());
   }
 }
 
 TEST_F(FIRBuilderTest, allocateLocal) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   llvm::StringRef varName = "var1";
   auto var = builder.allocateLocal(
       loc, builder.getI64Type(), "", varName, {}, {}, false);
   EXPECT_TRUE(mlir::isa<fir::AllocaOp>(var.getDefiningOp()));
   auto allocaOp = dyn_cast<fir::AllocaOp>(var.getDefiningOp());
-  EXPECT_EQ(builder.getI64Type(), allocaOp.in_type());
-  EXPECT_TRUE(allocaOp.bindc_name().hasValue());
-  EXPECT_EQ(varName, allocaOp.bindc_name().getValue());
-  EXPECT_FALSE(allocaOp.uniq_name().hasValue());
-  EXPECT_FALSE(allocaOp.pinned());
-  EXPECT_EQ(0u, allocaOp.typeparams().size());
-  EXPECT_EQ(0u, allocaOp.shape().size());
+  EXPECT_EQ(builder.getI64Type(), allocaOp.getInType());
+  EXPECT_TRUE(allocaOp.getBindcName().hasValue());
+  EXPECT_EQ(varName, allocaOp.getBindcName().getValue());
+  EXPECT_FALSE(allocaOp.getUniqName().hasValue());
+  EXPECT_FALSE(allocaOp.getPinned());
+  EXPECT_EQ(0u, allocaOp.getTypeparams().size());
+  EXPECT_EQ(0u, allocaOp.getShape().size());
 }
 
 static void checkShapeOp(mlir::Value shape, mlir::Value c10, mlir::Value c100) {
   EXPECT_TRUE(mlir::isa<fir::ShapeOp>(shape.getDefiningOp()));
   fir::ShapeOp op = dyn_cast<fir::ShapeOp>(shape.getDefiningOp());
   auto shapeTy = op.getType().dyn_cast<fir::ShapeType>();
   EXPECT_EQ(2u, shapeTy.getRank());
   EXPECT_EQ(2u, op.getExtents().size());

flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h

 /// Check that the \p op is a `fir::CallOp` operation and its name matches
 /// \p fctName and the number of arguments is equal to \p nbArgs.
 /// Most runtime calls have two additional location arguments added. These are
 /// added in this check when \p addLocArgs is true.
 static inline void checkCallOp(mlir::Operation *op, llvm::StringRef fctName,
     unsigned nbArgs, bool addLocArgs = true) {
   EXPECT_TRUE(mlir::isa<fir::CallOp>(*op));
   auto callOp = mlir::dyn_cast<fir::CallOp>(*op);
-  EXPECT_TRUE(callOp.callee().hasValue());
-  mlir::SymbolRefAttr callee = *callOp.callee();
+  EXPECT_TRUE(callOp.getCallee().hasValue());
+  mlir::SymbolRefAttr callee = *callOp.getCallee();
   EXPECT_EQ(fctName, callee.getRootReference().getValue());
   // sourceFile and sourceLine are added arguments.
   if (addLocArgs)
     nbArgs += 2;
-  EXPECT_EQ(nbArgs, callOp.args().size());
+  EXPECT_EQ(nbArgs, callOp.getArgs().size());
 }
 
 /// Check the call operation from the \p result value. In some cases the
 /// value is directly used in the call and sometimes there is an indirection
 /// through a `fir.convert` operation. Once the `fir.call` operation is
 /// retrieved the check is made by `checkCallOp`.
 ///
 /// Directly used in `fir.call`.

 /// if the operation exists, and not the order in when the operation is called.
 /// This results in exiting the test as soon as the first correct instance of
 /// `fir::CallOp` is found).
 static inline void checkBlockForCallOp(
     mlir::Block *block, llvm::StringRef fctName, unsigned nbArgs) {
   assert(block && "mlir::Block given is a nullptr");
   for (auto &op : block->getOperations()) {
     if (auto callOp = mlir::dyn_cast<fir::CallOp>(op)) {
-      if (fctName == callOp.callee()->getRootReference().getValue()) {
-        EXPECT_EQ(nbArgs, callOp.args().size());
+      if (fctName == callOp.getCallee()->getRootReference().getValue()) {
+        EXPECT_EQ(nbArgs, callOp.getArgs().size());
         return;
       }
     }
   }
   FAIL() << "No calls to " << fctName << " were found!";
 }
 
 #endif // FORTRAN_OPTIMIZER_BUILDER_RUNTIME_RUNTIMECALLTESTBASE_H