[flang] Updated FIR dialect to _Both

[jpienaar]

Summary

Change dialect (and remove now redundant accessors) to generate both
form of accessors of being generated. Tried to keep this change
reasonably minimal (this also includes keeping note about not generating
getType accessor to avoid shadowing).

[clementval]

LGTM. Thanks for looking at this. Please give some time to @schweitz to have a look at it.

[schweitz]

LGTM. We'll have to sync the rest with the next rebase @clementval .

flang/include/flang/Lower/Support/Utils.h

 /// Convert an F18 CharBlock to an LLVM StringRef.
 inline llvm::StringRef toStringRef(const Fortran::parser::CharBlock &cb) {
   return {cb.begin(), cb.size()};
 }
 
 namespace fir {
 /// Return the integer value of a arith::ConstantOp.
 inline std::int64_t toInt(mlir::arith::ConstantOp cop) {
-  return cop.value().cast<mlir::IntegerAttr>().getValue().getSExtValue();
+  return cop.getValue().cast<mlir::IntegerAttr>().getValue().getSExtValue();
 }
 } // namespace fir
 
 /// Template helper to remove Fortran::common::Indirection wrappers.
 template <typename A>
 const A &removeIndirection(const A &a) {
   return a;
 }
 template <typename A>
 const A &removeIndirection(const Fortran::common::Indirection<A> &a) {
   return a.value();
 }
 
 #endif // FORTRAN_LOWER_SUPPORT_UTILS_H

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;
 }
 
 #endif // FORTRAN_DIALECT_FIR_DIALECT

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

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(); }
     static mlir::Type getRefTy(mlir::Type ty);
-    mlir::Type getInType() { return in_type(); }
   }];
 }
 
 def fir_AllocMemOp : fir_Op<"allocmem",
     [MemoryEffects<[MemAlloc<DefaultResource>]>, AttrSizedOperandSegments]> {
   let summary = "allocate storage on the heap for an object of a given type";
 
   let description = [{
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(); }
     static mlir::Type getRefTy(mlir::Type ty);
-    mlir::Type getInType() { return in_type(); }
   }];
 }
 
 def fir_FreeMemOp : fir_Op<"freemem", [MemoryEffects<[MemFree]>]> {
   let summary = "free a heap object";
 
   let description = [{
     Deallocates a heap memory reference that was allocated by an `allocmem`.
string extraSwitchClassDeclaration = [{
     static constexpr llvm::StringRef getCasesAttr() { return "case_tags"; }
 
     // The number of destination conditions that may be tested
     unsigned getNumConditions() {
       return getCases().size();
     }
 
     // The selector is the value being tested to determine the destination
-    mlir::Value getSelector() { return selector(); }
     mlir::Value getSelector(llvm::ArrayRef<mlir::Value> operands) {
       return operands[0];
     }
     mlir::Value getSelector(mlir::ValueRange operands) {
       return operands.front();
     }
 
     // The number of blocks that may be branched to
def fir_EmboxOp : fir_Op<"embox", [NoSideEffect, AttrSizedOperandSegments]> {
   let assemblyFormat = [{
     $memref (`(` $shape^ `)`)? (`[` $slice^ `]`)? (`typeparams` $typeparams^)?
       (`map` $accessMap^)? attr-dict `:` functional-type(operands, results)
   }];
 
   let verifier = "return ::verify(*this);";
 
   let extraClassDeclaration = [{
-    mlir::Value getShape() { return shape(); }
-    mlir::Value getSlice() { return slice(); }
     bool hasLenParams() { return !typeparams().empty(); }
     unsigned numLenParams() { return typeparams().size(); }
   }];
 }
 
 def fir_ReboxOp : fir_Op<"rebox", [NoSideEffect, AttrSizedOperandSegments]> {
   let summary =
       "create a box given another box and (optional) dimension information";
def fir_CoordinateOp : fir_Op<"coordinate_of", [NoSideEffect]> {
   let verifier = "return ::verify(*this);";
 
   let builders = [
     OpBuilder<(ins "mlir::Type":$resultType,
       "mlir::Value":$ref, "mlir::ValueRange":$coor),
     [{ return build($_builder, $_state, resultType, ref, coor,
            mlir::TypeAttr::get(ref.getType())); }]>,
   ];
-
-  let extraClassDeclaration = [{
-    /// Get the type of the base object.
-    mlir::Type getBaseType() { return baseType(); }
-  }];
 }
 
 def fir_ExtractValueOp : fir_OneResultOp<"extract_value", [NoSideEffect]> {
   let summary = "Extract a value from an aggregate SSA-value";
 
   let description = [{
     Extract a value from an entity with a type composed of tuples, arrays,
     and/or derived types. Returns the value from entity with the type of the
def fir_ShapeOp : fir_Op<"shape", [NoSideEffect]> {
 
   let results = (outs fir_ShapeType);
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 
   let verifier = "return ::verify(*this);";
-
-  let extraClassDeclaration = [{
-    std::vector<mlir::Value> getExtents() {
-      return {extents().begin(), extents().end()};
-    }
-  }];
 }
 
 def fir_ShapeShiftOp : fir_Op<"shape_shift", [NoSideEffect]> {
 
   let summary = [{
     generate an abstract shape and shift vector of type `!fir.shapeshift`
   }];
 
def fir_ShiftOp : fir_Op<"shift", [NoSideEffect]> {
 
   let results = (outs fir_ShiftType);
 
   let assemblyFormat = [{
     operands attr-dict `:` functional-type(operands, results)
   }];
 
   let verifier = "return ::verify(*this);";
-
-  let extraClassDeclaration = [{
-    std::vector<mlir::Value> getOrigins() {
-      return {origins().begin(), origins().end()};
-    }
-  }];
 }
 
 def fir_SliceOp : fir_Op<"slice", [NoSideEffect, AttrSizedOperandSegments]> {
 
   let summary = "generate an abstract slice vector of type `!fir.slice`";
 
   let description = [{
     The array slicing arguments are an ordered list of integral type values
[{
       $_state.addAttribute(fieldAttrName(), $_builder.getStringAttr(fieldName));
       $_state.addAttribute(typeAttrName(), TypeAttr::get(recTy));
     }]
   >];
 
   let extraClassDeclaration = [{
     static constexpr llvm::StringRef fieldAttrName() { return "field_id"; }
     static constexpr llvm::StringRef typeAttrName() { return "on_type"; }
-    mlir::Type getOnType() {
-      return (*this)->getAttrOfType<TypeAttr>(typeAttrName()).getValue();
-    }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Fortran loops
 //===----------------------------------------------------------------------===//
 
 def fir_ResultOp : fir_Op<"result",
let builders = [
     OpBuilder<(ins "mlir::Value":$lowerBound, "mlir::Value":$upperBound,
       "mlir::Value":$step, "mlir::Value":$iterate,
       CArg<"bool", "false">:$finalCountValue,
       CArg<"mlir::ValueRange", "llvm::None">:$iterArgs,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attributes)>
   ];
 
   let extraClassDeclaration = [{
-    static constexpr llvm::StringRef getFinalValueAttrName() {
+    static constexpr llvm::StringRef getFinalValueAttrNameStr() {
       return "finalValue";
     }
     mlir::Block *getBody() { return &region().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()));
     }
OpBuilder<(ins "llvm::StringRef":$callee,
         CArg<"mlir::ValueRange", "{}">:$operands),
     [{
       build($_builder, $_state,
           SymbolRefAttr::get($_builder.getContext(), callee), results,
           operands);
     }]>];
 
   let extraClassDeclaration = [{
-    static constexpr StringRef getCalleeAttrName() { return "callee"; }
+    static constexpr StringRef getCalleeAttrNameStr() { return "callee"; }
 
     mlir::FunctionType getFunctionType();
 
     /// Get the argument operands to the called function.
     operand_range getArgOperands() {
       if ((*this)->getAttrOfType<SymbolRefAttr>(getCalleeAttrName()))
         return {arg_operand_begin(), arg_operand_end()};
       return {arg_operand_begin() + 1, arg_operand_end()};
operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
     // operand[0] is the object (of box type)
     operand_iterator arg_operand_begin() { return operand_begin() + 1; }
     operand_iterator arg_operand_end() { return operand_end(); }
     static constexpr llvm::StringRef passArgAttrName() {
       return "pass_arg_pos";
     }
-    static constexpr llvm::StringRef getMethodAttrName() { return "method"; }
+    static constexpr llvm::StringRef getMethodAttrNameStr() { return "method"; }
     unsigned passArgPos();
   }];
 }
 
 // Constant operations that support Fortran
 
 def fir_StringLitOp : fir_Op<"string_lit", [NoSideEffect]> {
   let summary = "create a string literal constant";
def fir_GenTypeDescOp : fir_OneResultOp<"gentypedesc", [NoSideEffect]> {
 
   let parser = "return parseGenTypeDescOp(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let builders = [OpBuilder<(ins "mlir::TypeAttr":$inty)>];
 
   let verifier = "return ::verify(*this);";
-
-  let extraClassDeclaration = [{
-    mlir::Type getInType() {
-      // get the type that the type descriptor describes
-      return (*this)->getAttrOfType<mlir::TypeAttr>("in_type").getValue();
-    }
-  }];
 }
 
 def fir_NoReassocOp : fir_OneResultOp<"no_reassoc",
     [NoSideEffect, SameOperandsAndResultType]> {
   let summary = "synthetic op to prevent reassociation";
   let description = [{
     Primitive operation meant to intrusively prevent operator reassociation.
     The operation is otherwise a nop and the value returned is the same as the
OpBuilder<(ins "llvm::StringRef":$name, "mlir::Type":$type,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
     OpBuilder<(ins "llvm::StringRef":$name, "bool":$isConstant,
       "mlir::Type":$type, "mlir::Attribute":$initVal,
       CArg<"mlir::StringAttr", "{}">:$linkage,
       CArg<"llvm::ArrayRef<mlir::NamedAttribute>", "{}">:$attrs)>,
   ];
 
   let extraClassDeclaration = [{
-    static constexpr llvm::StringRef symbolAttrName() { return "symref"; }
-    static constexpr llvm::StringRef getConstantAttrName() {
+    static constexpr llvm::StringRef symbolAttrNameStr() { return "symref"; }
+    static constexpr llvm::StringRef getConstantAttrNameStr() {
       return "constant";
     }
     static constexpr llvm::StringRef linkageAttrName() { return "linkName"; }
 
     /// The printable type of the global
     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()); }
 
     /// Append the next initializer value to the `GlobalOp` to construct
     /// the variable's initial value.
     void appendInitialValue(mlir::Operation *op);
 
-    /// A GlobalOp has one region.
-    mlir::Region &getRegion() { return (*this)->getRegion(0); }
-
     /// A GlobalOp has one block.
     mlir::Block &getBlock() { return getRegion().front(); }
 
     /// Determine if `linkage` is a supported keyword
     static mlir::ParseResult verifyValidLinkage(StringRef linkage);
 
     bool hasInitializationBody() {
       return ((*this)->getNumRegions() == 1) && !getRegion().empty() &&
[{
       $_state.addAttributes(attrs);
     }]>
   ];
 
   let extraClassDeclaration = [{
     /// Append a dispatch table entry to the table.
     void appendTableEntry(mlir::Operation *op);
 
-    mlir::Region &getRegion() {
-      return (*this)->getRegion(0);
-    }
-
     mlir::Block &getBlock() {
       return getRegion().front();
     }
   }];
 }
 
 def fir_DTEntryOp : fir_Op<"dt_entry", [HasParent<"DispatchTableOp">]> {
   let summary = "map entry in a dispatch table";
def fir_DTEntryOp : fir_Op<"dt_entry", [HasParent<"DispatchTableOp">]> {
 
   let arguments = (ins StrAttr:$method, SymbolRefAttr:$proc);
 
   let parser = "return parseDTEntryOp(parser, result);";
 
   let printer = "::print(p, *this);";
 
   let extraClassDeclaration = [{
-    static constexpr llvm::StringRef getMethodAttrName() { return "method"; }
-    static constexpr llvm::StringRef getProcAttrName() { return "proc"; }
+    static constexpr llvm::StringRef getMethodAttrNameStr() { return "method"; }
+    static constexpr llvm::StringRef getProcAttrNameStr() { return "proc"; }
   }];
 }
 
 def fir_AbsentOp : fir_OneResultOp<"absent", [NoSideEffect]> {
   let summary = "create value to be passed for absent optional function argument";
   let description = [{
     Given the type of a function argument, create a value that will signal that
     an optional argument is absent in the call. On the caller side, fir.is_present

flang/include/flang/Optimizer/Support/Utils.h

 #define FORTRAN_OPTIMIZER_SUPPORT_UTILS_H
 
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BuiltinAttributes.h"
 
 namespace fir {
 /// Return the integer value of a arith::ConstantOp.
 inline std::int64_t toInt(mlir::arith::ConstantOp cop) {
-  return cop.value().cast<mlir::IntegerAttr>().getValue().getSExtValue();
+  return cop.getValue().cast<mlir::IntegerAttr>().getValue().getSExtValue();
 }
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_SUPPORT_UTILS_H

flang/include/flang/Optimizer/Transforms/Factory.h

 
 /// Get origins from fir.shape_shift/fir.shift op. Empty result if
 /// \p shapeVal is empty or is a fir.shape.
 inline std::vector<mlir::Value> getOrigins(mlir::Value shapeVal) {
   if (shapeVal)
     if (auto *shapeOp = shapeVal.getDefiningOp()) {
       if (auto shOp = mlir::dyn_cast<fir::ShapeShiftOp>(shapeOp))
         return shOp.getOrigins();
-      if (auto shOp = mlir::dyn_cast<fir::ShiftOp>(shapeOp))
-        return shOp.getOrigins();
+      if (auto shOp = mlir::dyn_cast<fir::ShiftOp>(shapeOp)) {
+        auto operands = shOp.getOrigins();
+        return {operands.begin(), operands.end()};
+      }
     }
   return {};
 }
 
 /// Convert the normalized indices on array_fetch and array_update to the
 /// dynamic (and non-zero) origin required by array_coor.
 /// Do not adjust any trailing components in the path as they specify a
 /// particular path into the array value and must already correspond to the

flang/lib/Optimizer/CodeGen/CodeGen.cpp

if (!gr.empty()) {
             if (!convertOp)
               continue;
             constant = cast<mlir::arith::ConstantOp>(
                 convertOp.value().getDefiningOp());
           }
           mlir::Type vecType = mlir::VectorType::get(
               insertOp.getType().getShape(), constant.getType());
           auto denseAttr = mlir::DenseElementsAttr::get(
-              vecType.cast<ShapedType>(), constant.value());
+              vecType.cast<ShapedType>(), constant.getValue());
           rewriter.setInsertionPointAfter(insertOp);
           rewriter.replaceOpWithNewOp<mlir::arith::ConstantOp>(
               insertOp, seqTyAttr, denseAttr);
         }
       }
     }
     rewriter.eraseOp(global);
     return success();

flang/lib/Optimizer/Dialect/FIROps.cpp

if (eleTy.isa<fir::SequenceType>())
       return eleTy;
   }
   return t;
 }
 
 std::vector<mlir::Value> fir::ArrayLoadOp::getExtents() {
   if (auto sh = shape())
     if (auto *op = sh.getDefiningOp()) {
-      if (auto shOp = dyn_cast<fir::ShapeOp>(op))
-        return shOp.getExtents();
+      if (auto shOp = dyn_cast<fir::ShapeOp>(op)) {
+        auto extents = shOp.getExtents();
+        return {extents.begin(), extents.end()};
+      }
       return cast<fir::ShapeShiftOp>(op).getExtents();
     }
   return {};
 }
 
 static mlir::LogicalResult verify(fir::ArrayLoadOp op) {
   auto eleTy = fir::dyn_cast_ptrOrBoxEleTy(op.memref().getType());
   auto arrTy = eleTy.dyn_cast<fir::SequenceType>();
static mlir::ParseResult parseCallOp(mlir::OpAsmParser &parser,
   result.addTypes(funcType.getResults());
   result.attributes = attrs;
   return mlir::success();
 }
 
 void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
                         mlir::FuncOp callee, mlir::ValueRange operands) {
   result.addOperands(operands);
-  result.addAttribute(getCalleeAttrName(), SymbolRefAttr::get(callee));
+  result.addAttribute(getCalleeAttrNameStr(), SymbolRefAttr::get(callee));
   result.addTypes(callee.getType().getResults());
 }
 
 void fir::CallOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
                         mlir::SymbolRefAttr callee,
                         llvm::ArrayRef<mlir::Type> results,
                         mlir::ValueRange operands) {
   result.addOperands(operands);
   if (callee)
-    result.addAttribute(getCalleeAttrName(), callee);
+    result.addAttribute(getCalleeAttrNameStr(), callee);
   result.addTypes(results);
 }
 
 //===----------------------------------------------------------------------===//
 // CmpOp
 //===----------------------------------------------------------------------===//
 
 template <typename OPTY>

 static mlir::ParseResult parseDispatchOp(mlir::OpAsmParser &parser,
                                          mlir::OperationState &result) {
   mlir::FunctionType calleeType;
   llvm::SmallVector<mlir::OpAsmParser::OperandType> operands;
   auto calleeLoc = parser.getNameLoc();
   llvm::StringRef calleeName;
   if (failed(parser.parseOptionalKeyword(&calleeName))) {
     mlir::StringAttr calleeAttr;
-    if (parser.parseAttribute(calleeAttr, fir::DispatchOp::getMethodAttrName(),
+    if (parser.parseAttribute(calleeAttr,
+                              fir::DispatchOp::getMethodAttrNameStr(),
                               result.attributes))
       return mlir::failure();
   } else {
-    result.addAttribute(fir::DispatchOp::getMethodAttrName(),
+    result.addAttribute(fir::DispatchOp::getMethodAttrNameStr(),
                         parser.getBuilder().getStringAttr(calleeName));
   }
   if (parser.parseOperandList(operands, mlir::OpAsmParser::Delimiter::Paren) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(calleeType) ||
       parser.addTypesToList(calleeType.getResults(), result.types) ||
       parser.resolveOperands(operands, calleeType.getInputs(), calleeLoc,
                              result.operands))
     return mlir::failure();
   return mlir::success();
 }
 
 static void print(mlir::OpAsmPrinter &p, fir::DispatchOp &op) {
-  p << ' ' << op.getOperation()->getAttr(fir::DispatchOp::getMethodAttrName())
-    << '(';
+  p << ' ' << op.getMethodAttr() << '(';
   p.printOperand(op.object());
   if (!op.args().empty()) {
     p << ", ";
     p.printOperands(op.args());
   }
   p << ") : ";
   p.printFunctionalType(op.getOperation()->getOperandTypes(),
                         op.getOperation()->getResultTypes());
if (mlir::succeeded(parser.parseOptionalKeyword(&linkage))) {
     if (fir::GlobalOp::verifyValidLinkage(linkage))
       return mlir::failure();
     mlir::StringAttr linkAttr = builder.getStringAttr(linkage);
     result.addAttribute(fir::GlobalOp::linkageAttrName(), linkAttr);
   }
 
   // Parse the name as a symbol reference attribute.
   mlir::SymbolRefAttr nameAttr;
-  if (parser.parseAttribute(nameAttr, fir::GlobalOp::symbolAttrName(),
+  if (parser.parseAttribute(nameAttr, fir::GlobalOp::symbolAttrNameStr(),
                             result.attributes))
     return mlir::failure();
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       nameAttr.getRootReference());
 
   bool simpleInitializer = false;
   if (mlir::succeeded(parser.parseOptionalLParen())) {
     Attribute attr;
static ParseResult parseGlobalOp(OpAsmParser &parser, OperationState &result) {
 
   return mlir::success();
 }
 
 static void print(mlir::OpAsmPrinter &p, fir::GlobalOp &op) {
   if (op.linkName().hasValue())
     p << ' ' << op.linkName().getValue();
   p << ' ';
-  p.printAttributeWithoutType(
-      op.getOperation()->getAttr(fir::GlobalOp::symbolAttrName()));
+  p.printAttributeWithoutType(op.getSymrefAttr());
   if (auto val = op.getValueOrNull())
     p << '(' << val << ')';
-  if (op.getOperation()->getAttr(fir::GlobalOp::getConstantAttrName()))
+  if (op.getOperation()->getAttr(fir::GlobalOp::getConstantAttrNameStr()))
     p << " constant";
   p << " : ";
   p.printType(op.getType());
   if (op.hasInitializationBody())
     p.printRegion(op.getOperation()->getRegion(0),
                   /*printEntryBlockArgs=*/false,
                   /*printBlockTerminators=*/true);
 }
 
 void fir::GlobalOp::appendInitialValue(mlir::Operation *op) {
   getBlock().getOperations().push_back(op);
 }
 
 void fir::GlobalOp::build(mlir::OpBuilder &builder, OperationState &result,
                           StringRef name, bool isConstant, Type type,
                           Attribute initialVal, StringAttr linkage,
                           ArrayRef<NamedAttribute> attrs) {
   result.addRegion();
   result.addAttribute(typeAttrName(result.name), mlir::TypeAttr::get(type));
   result.addAttribute(mlir::SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
-  result.addAttribute(symbolAttrName(),
+  result.addAttribute(symbolAttrNameStr(),
                       SymbolRefAttr::get(builder.getContext(), name));
   if (isConstant)
     result.addAttribute(constantAttrName(result.name), builder.getUnitAttr());
   if (initialVal)
     result.addAttribute(initValAttrName(result.name), initialVal);
   if (linkage)
     result.addAttribute(linkageAttrName(), linkage);
   result.attributes.append(attrs.begin(), attrs.end());
if (!insval2 || !isa<fir::UndefOp>(insval2.adt().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]))
       return mlir::failure();
     auto eai =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf.lhs().getDefiningOp());
+        dyn_cast_or_null<fir::ExtractValueOp>(binf.getLhs().getDefiningOp());
     auto ebi =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf.rhs().getDefiningOp());
+        dyn_cast_or_null<fir::ExtractValueOp>(binf.getRhs().getDefiningOp());
     auto ear =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf2.lhs().getDefiningOp());
+        dyn_cast_or_null<fir::ExtractValueOp>(binf2.getLhs().getDefiningOp());
     auto ebr =
-        dyn_cast_or_null<fir::ExtractValueOp>(binf2.rhs().getDefiningOp());
+        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]))
       return mlir::failure();
     rewriter.replaceOpWithNewOp<CpxOp>(op, ear.adt(), ebr.adt());
void fir::IterWhileOp::build(mlir::OpBuilder &builder,
                              mlir::OperationState &result, mlir::Value lb,
                              mlir::Value ub, mlir::Value step,
                              mlir::Value iterate, bool finalCountValue,
                              mlir::ValueRange iterArgs,
                              llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   result.addOperands({lb, ub, step, iterate});
   if (finalCountValue) {
     result.addTypes(builder.getIndexType());
-    result.addAttribute(getFinalValueAttrName(), builder.getUnitAttr());
+    result.addAttribute(getFinalValueAttrNameStr(), builder.getUnitAttr());
   }
   result.addTypes(iterate.getType());
   result.addOperands(iterArgs);
   for (auto v : iterArgs)
     result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block{});
   bodyRegion->front().addArgument(builder.getIndexType());
static mlir::ParseResult parseIterWhileOp(mlir::OpAsmParser &parser,
   }
 
   if (parser.parseOptionalAttrDictWithKeyword(result.attributes))
     return mlir::failure();
 
   llvm::SmallVector<mlir::Type> argTypes;
   // Induction variable (hidden)
   if (prependCount)
-    result.addAttribute(IterWhileOp::getFinalValueAttrName(),
+    result.addAttribute(IterWhileOp::getFinalValueAttrNameStr(),
                         builder.getUnitAttr());
   else
     argTypes.push_back(indexType);
   // Loop carried variables (including iterate)
   argTypes.append(result.types.begin(), result.types.end());
   // Parse the body region.
   auto *body = result.addRegion();
   if (regionArgs.size() != argTypes.size())
if (regionArgs.size() > 1) {
     p << ") -> (";
     llvm::interleaveComma(
         llvm::drop_begin(op.getResultTypes(), op.finalValue() ? 0 : 1), p);
     p << ")";
   } else if (op.finalValue()) {
     p << " -> (" << op.getResultTypes() << ')';
   }
   p.printOptionalAttrDictWithKeyword(op->getAttrs(),
-                                     {IterWhileOp::getFinalValueAttrName()});
+                                     {op.getFinalValueAttrNameStr()});
   p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/true);
 }
 
 mlir::Region &fir::IterWhileOp::getLoopBody() { return region(); }
 
 bool fir::IterWhileOp::isDefinedOutsideOfLoop(mlir::Value value) {
   return !region().isAncestor(value.getParentRegion());

 //===----------------------------------------------------------------------===//
 
 static mlir::ParseResult parseDTEntryOp(mlir::OpAsmParser &parser,
                                         mlir::OperationState &result) {
   llvm::StringRef methodName;
   // allow `methodName` or `"methodName"`
   if (failed(parser.parseOptionalKeyword(&methodName))) {
     mlir::StringAttr methodAttr;
-    if (parser.parseAttribute(methodAttr, fir::DTEntryOp::getMethodAttrName(),
+    if (parser.parseAttribute(methodAttr,
+                              fir::DTEntryOp::getMethodAttrNameStr(),
                               result.attributes))
       return mlir::failure();
   } else {
-    result.addAttribute(fir::DTEntryOp::getMethodAttrName(),
+    result.addAttribute(fir::DTEntryOp::getMethodAttrNameStr(),
                         parser.getBuilder().getStringAttr(methodName));
   }
   mlir::SymbolRefAttr calleeAttr;
   if (parser.parseComma() ||
-      parser.parseAttribute(calleeAttr, fir::DTEntryOp::getProcAttrName(),
+      parser.parseAttribute(calleeAttr, fir::DTEntryOp::getProcAttrNameStr(),
                             result.attributes))
     return mlir::failure();
   return mlir::success();
 }
 
 static void print(mlir::OpAsmPrinter &p, fir::DTEntryOp &op) {
-  p << ' ' << op.getOperation()->getAttr(fir::DTEntryOp::getMethodAttrName())
-    << ", " << op.getOperation()->getAttr(fir::DTEntryOp::getProcAttrName());
+  p << ' ' << op.getMethodAttr() << ", " << op.getProcAttr();
 }
 
 //===----------------------------------------------------------------------===//
 // ReboxOp
 //===----------------------------------------------------------------------===//
 
 /// Get the scalar type related to a fir.box type.
 /// Example: return f32 for !fir.box<!fir.heap<!fir.array<?x?xf32>>.

flang/lib/Optimizer/Transforms/AffinePromotion.cpp

for (unsigned i = 0; i < dimensions; ++i) {
     index = currentPart + index;
     accuExtent = accuExtent * currentExtent;
   }
   return mlir::AffineMap::get(dimensions, dimensions * 3, index);
 }
 
 static Optional<int64_t> constantIntegerLike(const mlir::Value value) {
   if (auto definition = value.getDefiningOp<mlir::arith::ConstantOp>())
-    if (auto stepAttr = definition.value().dyn_cast<IntegerAttr>())
+    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 seqType = refType.getEleTy().dyn_cast_or_null<SequenceType>()) {
       return seqType.getEleTy();

flang/lib/Optimizer/Transforms/ArrayValueCopy.cpp

while (!queue.empty()) {
     } else if (auto update = mlir::dyn_cast<ArrayModifyOp>(owner)) {
       // Keep track of array value modification and thread the return value
       // uses.
       LLVM_DEBUG(llvm::dbgs()
                  << "add modify {" << *owner << "} to array value set\n");
       accesses.push_back(owner);
       appendToQueue(update.getResult(1));
     } else if (auto br = mlir::dyn_cast<mlir::BranchOp>(owner)) {
-      branchOp(br.getDest(), br.destOperands());
+      branchOp(br.getDest(), br.getDestOperands());
     } else if (auto br = mlir::dyn_cast<mlir::CondBranchOp>(owner)) {
       branchOp(br.getTrueDest(), br.getTrueOperands());
       branchOp(br.getFalseDest(), br.getFalseOperands());
     } else if (mlir::isa<ArrayMergeStoreOp>(owner)) {
       // do nothing
     } else {
       llvm::report_fatal_error("array value reached unexpected op");
     }

flang/unittests/Optimizer/Builder/DoLoopHelperTest.cpp

TEST_F(DoLoopHelperTest, createLoopWithCountTest) {
   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());
   EXPECT_EQ(c10, subOp.lhs());
-  checkConstantValue(subOp.rhs(), 1);
-  checkConstantValue(loop.step(), 1);
+  checkConstantValue(subOp.getRhs(), 1);
+  checkConstantValue(loop.getStep(), 1);
 }
 
 TEST_F(DoLoopHelperTest, createLoopWithLowerAndUpperBound) {
   auto firBuilder = getBuilder();
   fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
 
   auto lb = firBuilder.createIntegerConstant(
       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 1);
   auto ub = firBuilder.createIntegerConstant(
       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 20);
   auto loop =
       helper.createLoop(lb, ub, [&](fir::FirOpBuilder &, mlir::Value index) {});
-  checkConstantValue(loop.lowerBound(), 1);
-  checkConstantValue(loop.upperBound(), 20);
-  checkConstantValue(loop.step(), 1);
+  checkConstantValue(loop.getLowerBound(), 1);
+  checkConstantValue(loop.getUpperBound(), 20);
+  checkConstantValue(loop.getStep(), 1);
 }
 
 TEST_F(DoLoopHelperTest, createLoopWithStep) {
   auto firBuilder = getBuilder();
   fir::factory::DoLoopHelper helper(firBuilder, firBuilder.getUnknownLoc());
 
   auto lb = firBuilder.createIntegerConstant(
       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 1);
   auto ub = firBuilder.createIntegerConstant(
       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 20);
   auto step = firBuilder.createIntegerConstant(
       firBuilder.getUnknownLoc(), firBuilder.getIndexType(), 2);
   auto loop = helper.createLoop(
       lb, ub, step, [&](fir::FirOpBuilder &, mlir::Value index) {});
-  checkConstantValue(loop.lowerBound(), 1);
-  checkConstantValue(loop.upperBound(), 20);
-  checkConstantValue(loop.step(), 2);
+  checkConstantValue(loop.getLowerBound(), 1);
+  checkConstantValue(loop.getUpperBound(), 20);
+  checkConstantValue(loop.getStep(), 2);
 }

flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp

 // IfBuilder tests
 //===----------------------------------------------------------------------===//
 
 TEST_F(FIRBuilderTest, genIfThen) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto cdt = createCondition(builder);
   auto ifBuilder = builder.genIfThen(loc, cdt);
-  EXPECT_FALSE(ifBuilder.getIfOp().thenRegion().empty());
-  EXPECT_TRUE(ifBuilder.getIfOp().elseRegion().empty());
+  EXPECT_FALSE(ifBuilder.getIfOp().getThenRegion().empty());
+  EXPECT_TRUE(ifBuilder.getIfOp().getElseRegion().empty());
 }
 
 TEST_F(FIRBuilderTest, genIfThenElse) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto cdt = createCondition(builder);
   auto ifBuilder = builder.genIfThenElse(loc, cdt);
-  EXPECT_FALSE(ifBuilder.getIfOp().thenRegion().empty());
-  EXPECT_FALSE(ifBuilder.getIfOp().elseRegion().empty());
+  EXPECT_FALSE(ifBuilder.getIfOp().getThenRegion().empty());
+  EXPECT_FALSE(ifBuilder.getIfOp().getElseRegion().empty());
 }
 
 TEST_F(FIRBuilderTest, genIfWithThen) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto cdt = createCondition(builder);
   auto ifBuilder = builder.genIfOp(loc, {}, cdt, false);
-  EXPECT_FALSE(ifBuilder.getIfOp().thenRegion().empty());
-  EXPECT_TRUE(ifBuilder.getIfOp().elseRegion().empty());
+  EXPECT_FALSE(ifBuilder.getIfOp().getThenRegion().empty());
+  EXPECT_TRUE(ifBuilder.getIfOp().getElseRegion().empty());
 }
 
 TEST_F(FIRBuilderTest, genIfWithThenAndElse) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto cdt = createCondition(builder);
   auto ifBuilder = builder.genIfOp(loc, {}, cdt, true);
-  EXPECT_FALSE(ifBuilder.getIfOp().thenRegion().empty());
-  EXPECT_FALSE(ifBuilder.getIfOp().elseRegion().empty());
+  EXPECT_FALSE(ifBuilder.getIfOp().getThenRegion().empty());
+  EXPECT_FALSE(ifBuilder.getIfOp().getElseRegion().empty());
 }
 
 //===----------------------------------------------------------------------===//
 // Helper functions tests
 //===----------------------------------------------------------------------===//
 
 TEST_F(FIRBuilderTest, genIsNotNull) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto dummyValue =
       builder.createIntegerConstant(loc, builder.getIndexType(), 0);
   auto res = builder.genIsNotNull(loc, dummyValue);
   EXPECT_TRUE(mlir::isa<arith::CmpIOp>(res.getDefiningOp()));
   auto cmpOp = dyn_cast<arith::CmpIOp>(res.getDefiningOp());
-  EXPECT_EQ(arith::CmpIPredicate::ne, cmpOp.predicate());
+  EXPECT_EQ(arith::CmpIPredicate::ne, cmpOp.getPredicate());
 }
 
 TEST_F(FIRBuilderTest, genIsNull) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto dummyValue =
       builder.createIntegerConstant(loc, builder.getIndexType(), 0);
   auto res = builder.genIsNull(loc, dummyValue);
   EXPECT_TRUE(mlir::isa<arith::CmpIOp>(res.getDefiningOp()));
   auto cmpOp = dyn_cast<arith::CmpIOp>(res.getDefiningOp());
-  EXPECT_EQ(arith::CmpIPredicate::eq, cmpOp.predicate());
+  EXPECT_EQ(arith::CmpIPredicate::eq, cmpOp.getPredicate());
 }
 
 TEST_F(FIRBuilderTest, createZeroConstant) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
 
   auto cst = builder.createNullConstant(loc);
   EXPECT_TRUE(mlir::isa<fir::ZeroOp>(cst.getDefiningOp()));
TEST_F(FIRBuilderTest, createRealZeroConstant) {
   auto builder = getBuilder();
   auto ctx = builder.getContext();
   auto loc = builder.getUnknownLoc();
   auto realTy = mlir::FloatType::getF64(ctx);
   auto cst = builder.createRealZeroConstant(loc, realTy);
   EXPECT_TRUE(mlir::isa<arith::ConstantOp>(cst.getDefiningOp()));
   auto cstOp = dyn_cast<arith::ConstantOp>(cst.getDefiningOp());
   EXPECT_EQ(realTy, cstOp.getType());
-  EXPECT_EQ(0u, cstOp.value().cast<FloatAttr>().getValue().convertToDouble());
+  EXPECT_EQ(
+      0u, cstOp.getValue().cast<FloatAttr>().getValue().convertToDouble());
 }
 
 TEST_F(FIRBuilderTest, createBool) {
   auto builder = getBuilder();
   auto loc = builder.getUnknownLoc();
   auto b = builder.createBool(loc, false);
   checkIntegerConstant(b, builder.getIntegerType(1), 0);
 }

flang/unittests/Optimizer/Builder/Runtime/NumericTest.cpp

void testGenNearest(fir::FirOpBuilder &builder, mlir::Type xType,
   checkCallOp(nearest.getDefiningOp(), fctName, 2, /*addLocArg=*/false);
   auto callOp = mlir::dyn_cast<fir::CallOp>(nearest.getDefiningOp());
   mlir::Value select = callOp.getOperands()[1];
   EXPECT_TRUE(mlir::isa<mlir::SelectOp>(select.getDefiningOp()));
   auto selectOp = mlir::dyn_cast<mlir::SelectOp>(select.getDefiningOp());
   mlir::Value cmp = selectOp.condition();
   EXPECT_TRUE(mlir::isa<mlir::arith::CmpFOp>(cmp.getDefiningOp()));
   auto cmpOp = mlir::dyn_cast<mlir::arith::CmpFOp>(cmp.getDefiningOp());
-  EXPECT_EQ(s, cmpOp.lhs());
+  EXPECT_EQ(s, cmpOp.getLhs());
 }
 
 TEST_F(RuntimeCallTest, genNearestTest) {
   testGenNearest(*firBuilder, f32Ty, f32Ty, "_FortranANearest4");
   testGenNearest(*firBuilder, f64Ty, f32Ty, "_FortranANearest8");
   testGenNearest(*firBuilder, f80Ty, f32Ty, "_FortranANearest10");
   testGenNearest(*firBuilder, f128Ty, f32Ty, "_FortranANearest16");
 }