[mlir] Switch arith, llvm, std & shape dialects to prefixed both form.

[jpienaar]

Summary

Following
https://llvm.discourse.group/t/psa-ods-generated-accessors-will-change-to-have-a-get-prefix-update-you-apis/4476,
this follows flipping these dialects to _Both prefixed form. This
changes the accessors to have a prefix. This was possibly mostly without
breaking breaking changes if the existing convenience methods were used.
The following changes were made to overlapping names & warnings for
skipped:

LLVM::InvokeOp: operands -> callee_operands
LLVM::Global: type -> global_type
GenericAtomicRMW: body -> unnamed (SingleBlock so getBody is defined for unnamed regions)

(https://github.com/jpienaar/llvm-project/blob/main/clang-tools-extra/clang-tidy/misc/AddGetterCheck.cpp
was used to migrate the callers post flipping, using the output from Operator.cpp)

[mehdi_amini]

This will be a breaking change for many people, can you expand in the description (even the title is cryptic for anyone not familiar with the context of the migration).
I don't know if you have a script or something to help downstream to update, but it is worth giving advice in the description as well.

Otherwise LG :)

[jpienaar]

In D112383#3082752, @mehdi_amini wrote:

This will be a breaking change for many people, can you expand in the description (even the title is cryptic for anyone not familiar with the context of the migration).
I don't know if you have a script or something to help downstream to update, but it is worth giving advice in the description as well.

Otherwise LG :)

With prefix both, there ended up being 0 breaking change (well unless one accesses the attributes raw and then there are 3), good idea to duplicate the script used in description.

[jpienaar]

Add more functions to reduce number of breaking changes.

[mehdi_amini]

In D112383#3082815, @jpienaar wrote:

With prefix both, there ended up being 0 breaking change

Ah! Good point, I missed the fact that you used the "both" mode.

(well unless one accesses the attributes raw and then there are 3)

I think the change in attribute names will lead to C++ accessor changed, every in "both" mode, but yeah that's minor.

[mehdi_amini]

In D112383#3082835, @mehdi_amini wrote:

(well unless one accesses the attributes raw and then there are 3)

I think the change in attribute names will lead to C++ accessor changed, every in "both" mode, but yeah that's minor.

Actually can you push this in multiple commits? It is always much easier to have this in isolation (renaming the 3 attributes looks like something that can be standalone ahead of the rest)

[jpienaar]

In D112383#3082836, @mehdi_amini wrote:

In D112383#3082835, @mehdi_amini wrote:

(well unless one accesses the attributes raw and then there are 3)

I think the change in attribute names will lead to C++ accessor changed, every in "both" mode, but yeah that's minor.

Correct, except I added forwarding functions (well in one case it already existed, I just changed the internal function :)).

Actually can you push this in multiple commits? It is always much easier to have this in isolation (renaming the 3 attributes looks like something that can be standalone ahead of the rest)

Good idea

mlir/include/mlir/Dialect/Arithmetic/IR/Arithmetic.h

static void build(OpBuilder &builder, OperationState &result, int64_t value,
                     unsigned width);
 
   /// Build a constant int op that produces an integer of the specified type,
   /// which must be an integer type.
   static void build(OpBuilder &builder, OperationState &result, int64_t value,
                     Type type);
 
   inline int64_t value() {
-    return arith::ConstantOp::value().cast<IntegerAttr>().getInt();
+    return arith::ConstantOp::getValue().cast<IntegerAttr>().getInt();
   }
 
   static bool classof(Operation *op);
 };
 
 /// Specialization of `arith.constant` op that returns a floating point value.
 class ConstantFloatOp : public arith::ConstantOp {
 public:
   using arith::ConstantOp::ConstantOp;
 
   /// Build a constant float op that produces a float of the specified type.
   static void build(OpBuilder &builder, OperationState &result,
                     const APFloat &value, FloatType type);
 
   inline APFloat value() {
-    return arith::ConstantOp::value().cast<FloatAttr>().getValue();
+    return arith::ConstantOp::getValue().cast<FloatAttr>().getValue();
   }
 
   static bool classof(Operation *op);
 };
 
 /// Specialization of `arith.constant` op that returns an integer of index type.
 class ConstantIndexOp : public arith::ConstantOp {
 public:
   using arith::ConstantOp::ConstantOp;
 
   /// Build a constant int op that produces an index.
   static void build(OpBuilder &builder, OperationState &result, int64_t value);
 
   inline int64_t value() {
-    return arith::ConstantOp::value().cast<IntegerAttr>().getInt();
+    return arith::ConstantOp::getValue().cast<IntegerAttr>().getInt();
   }
 
   static bool classof(Operation *op);
 };
 
 } // end namespace arith
 } // end namespace mlir
 

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td

def Arithmetic_Dialect : Dialect {
   let description = [{
     The arithmetic dialect is intended to hold basic integer and floating point
     mathematical operations. This includes unary, binary, and ternary arithmetic
     ops, bitwise and shift ops, cast ops, and compare ops. Operations in this
     dialect also accept vectors and tensors of integers or floats.
   }];
 
   let hasConstantMaterializer = 1;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 // The predicate indicates the type of the comparison to perform:
 // (un)orderedness, (in)equality and less/greater than (or equal to) as
 // well as predicates that are always true or false.
 def Arith_CmpFPredicateAttr : I64EnumAttr<
     "CmpFPredicate", "",
     [

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

def Arith_CmpIOp : Arith_CompareOp<"cmpi"> {
   let builders = [
     OpBuilder<(ins "CmpIPredicate":$predicate, "Value":$lhs, "Value":$rhs), [{
       build($_builder, $_state, ::getI1SameShape(lhs.getType()),
             predicate, lhs, rhs);
     }]>
   ];
 
   let extraClassDeclaration = [{
-    static StringRef getPredicateAttrName() { return "predicate"; }
     static arith::CmpIPredicate getPredicateByName(StringRef name);
-
-    arith::CmpIPredicate getPredicate() {
-      return (arith::CmpIPredicate) (*this)->getAttrOfType<IntegerAttr>(
-          getPredicateAttrName()).getInt();
-    }
   }];
 
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // CmpFOp
 //===----------------------------------------------------------------------===//
def Arith_CmpFOp : Arith_CompareOp<"cmpf"> {
   let builders = [
     OpBuilder<(ins "CmpFPredicate":$predicate, "Value":$lhs, "Value":$rhs), [{
       build($_builder, $_state, ::getI1SameShape(lhs.getType()),
             predicate, lhs, rhs);
     }]>
   ];
 
   let extraClassDeclaration = [{
-    static StringRef getPredicateAttrName() { return "predicate"; }
     static arith::CmpFPredicate getPredicateByName(StringRef name);
-
-    arith::CmpFPredicate getPredicate() {
-      return (arith::CmpFPredicate) (*this)->getAttrOfType<IntegerAttr>(
-          getPredicateAttrName()).getInt();
-    }
   }];
 
   let hasFolder = 1;
 }
 
 #endif // ARITHMETIC_OPS

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

let extraClassDeclaration = [{
     /// Verifies if the given string is a well-formed data layout descriptor.
     /// Uses `reportError` to report errors.
     static LogicalResult verifyDataLayoutString(
         StringRef descr, llvm::function_ref<void (const Twine &)> reportError);
 
     /// Name of the target triple attribute.
     static StringRef getTargetTripleAttrName() { return "llvm.target_triple"; }
   }];
+
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM dialect type constraints.
 //===----------------------------------------------------------------------===//
 
 // LLVM dialect type.
 def LLVM_Type : DialectType<LLVM_Dialect,

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

OpBuilder<(ins "Type":$type, "bool":$isConstant, "Linkage":$linkage,
       CArg<"unsigned", "0">:$addrSpace,
       CArg<"bool", "false">:$dsoLocal,
       CArg<"ArrayRef<NamedAttribute>", "{}">:$attrs)>
   ];
 
   let extraClassDeclaration = [{
     /// Return the LLVM type of the global.
     Type getType() {
-      return global_type();
+      return getGlobalType();
     }
     /// Return the initializer attribute if it exists, or a null attribute.
     Attribute getValueOrNull() {
       return value().getValueOr(Attribute());
     }
     /// Return the initializer region. This may be empty, but if it is not it
     /// terminates in an `llvm.return` op with the initializer value.
     Region &getInitializerRegion() {

mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td

let description = [{
     concatting etc. on how to combine them).
   }];
 
   let cppNamespace = "::mlir::shape";
   let dependentDialects = ["arith::ArithmeticDialect", "tensor::TensorDialect"];
 
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 def Shape_ShapeType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::ShapeType>()">, "shape">,
     BuildableType<"$_builder.getType<::mlir::shape::ShapeType>()"> {
   let description = [{
     `shape.shape` represents either an unranked shape, a ranked shape with
     possibly unknown dimensions or an invalid shape. The rank is of type

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 
 def StandardOps_Dialect : Dialect {
   let name = "std";
   let cppNamespace = "::mlir";
   let dependentDialects = ["arith::ArithmeticDialect"];
   let hasConstantMaterializer = 1;
+  let emitAccessorPrefix = kEmitAccessorPrefix_Both;
 }
 
 // Base class for Standard dialect ops.
 class Std_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<StandardOps_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)
def GenericAtomicRMWOp : Std_Op<"generic_atomic_rmw", [
   let builders = [OpBuilder<(ins "Value":$memref, "ValueRange":$ivs)>];
 
   let extraClassDeclaration = [{
     // TODO: remove post migrating callers.
     Region &body() { return getRegion(); }
 
     // The value stored in memref[ivs].
     Value getCurrentValue() {
-      return body().getArgument(0);
+      return getRegion().getArgument(0);
     }
     MemRefType getMemRefType() {
       return memref().getType().cast<MemRefType>();
     }
   }];
 }
 
 def AtomicYieldOp : Std_Op<"atomic_yield", [
OpBuilder<(ins "Block *":$dest,
       $_state.addSuccessors(dest);
       $_state.addOperands(destOperands);
     }]>];
 
   // BranchOp is fully verified by traits.
   let verifier = ?;
 
   let extraClassDeclaration = [{
-    Block *getDest();
     void setDest(Block *block);
 
     /// Erase the operand at 'index' from the operand list.
     void eraseOperand(unsigned index);
   }];
 
   let hasCanonicalizeMethod = 1;
   let assemblyFormat = [{
let builders = [
     }]>,
     OpBuilder<(ins "StringRef":$callee, "TypeRange":$results,
       CArg<"ValueRange", "{}">:$operands), [{
       build($_builder, $_state, StringAttr::get($_builder.getContext(), callee),
             results, operands);
     }]>];
 
   let extraClassDeclaration = [{
-    StringRef getCallee() { return callee(); }
-    StringAttr getCalleeAttr() { return calleeAttr().getAttr(); }
     FunctionType getCalleeType();
 
     /// Get the argument operands to the called function.
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
 
     operand_iterator arg_operand_begin() { return operand_begin(); }

 
 //===----------------------------------------------------------------------===//
 // CallIndirectOp
 //===----------------------------------------------------------------------===//
 
 def CallIndirectOp : Std_Op<"call_indirect", [
       CallOpInterface,
       TypesMatchWith<"callee input types match argument types",
-                     "callee", "operands",
+                     "callee", "callee_operands",
                      "$_self.cast<FunctionType>().getInputs()">,
       TypesMatchWith<"callee result types match result types",
                      "callee", "results",
                      "$_self.cast<FunctionType>().getResults()">
     ]> {
   let summary = "indirect call operation";
   let description = [{
     The `call_indirect` operation represents an indirect call to a value of
     function type. Functions are first class types in MLIR, and may be passed as
     arguments and merged together with block arguments. The operands and result
     types of the call must match the specified function type.
 
     Function values can be created with the
     [`constant` operation](#stdconstant-constantop).
 
     Example:
 
     ```mlir
     %31 = call_indirect %15(%0, %1)
             : (tensor<16xf32>, tensor<16xf32>) -> tensor<16xf32>
     ```
   }];
 
-  let arguments = (ins FunctionType:$callee, Variadic<AnyType>:$operands);
+  let arguments = (ins FunctionType:$callee,
+                       Variadic<AnyType>:$callee_operands);
   let results = (outs Variadic<AnyType>:$results);
 
   let builders = [
     OpBuilder<(ins "Value":$callee, CArg<"ValueRange", "{}">:$operands), [{
       $_state.operands.push_back(callee);
       $_state.addOperands(operands);
       $_state.addTypes(callee.getType().cast<FunctionType>().getResults());
     }]>];
 
   let extraClassDeclaration = [{
-    Value getCallee() { return getOperand(0); }
+    // TODO: Remove once migrated callers.
+    ValueRange operands() { return getCalleeOperands(); }
 
     /// Get the argument operands to the called function.
     operand_range getArgOperands() {
       return {arg_operand_begin(), arg_operand_end()};
     }
 
     operand_iterator arg_operand_begin() { return ++operand_begin(); }
     operand_iterator arg_operand_end() { return operand_end(); }
 
     /// Return the callee of this operation.
     CallInterfaceCallable getCallableForCallee() { return getCallee(); }
   }];
 
   let verifier = ?;
   let hasCanonicalizeMethod = 1;
 
-  let assemblyFormat = "$callee `(` $operands `)` attr-dict `:` type($callee)";
+  let assemblyFormat =
+    "$callee `(` $callee_operands `)` attr-dict `:` type($callee)";
 }
 
 //===----------------------------------------------------------------------===//
 // CondBranchOp
 //===----------------------------------------------------------------------===//
 
 def CondBranchOp : Std_Op<"cond_br",
     [AttrSizedOperandSegments,
def CondBranchOp : Std_Op<"cond_br",
 
   // CondBranchOp is fully verified by traits.
   let verifier = ?;
 
   let extraClassDeclaration = [{
     // These are the indices into the dests list.
     enum { trueIndex = 0, falseIndex = 1 };
 
-    // The condition operand is the first operand in the list.
-    Value getCondition() { return getOperand(0); }
-
-    /// Return the destination if the condition is true.
-    Block *getTrueDest() {
-      return getSuccessor(trueIndex);
-    }
-
-    /// Return the destination if the condition is false.
-    Block *getFalseDest() {
-      return getSuccessor(falseIndex);
-    }
-
     // Accessors for operands to the 'true' destination.
     Value getTrueOperand(unsigned idx) {
       assert(idx < getNumTrueOperands());
       return getOperand(getTrueDestOperandIndex() + idx);
     }
 
     void setTrueOperand(unsigned idx, Value value) {
       assert(idx < getNumTrueOperands());
       setOperand(getTrueDestOperandIndex() + idx, value);
     }
 
-    operand_range getTrueOperands() { return trueDestOperands(); }
-
     unsigned getNumTrueOperands()  { return getTrueOperands().size(); }
 
     /// Erase the operand at 'index' from the true operand list.
     void eraseTrueOperand(unsigned index)  {
       trueDestOperandsMutable().erase(index);
     }
 
     // Accessors for operands to the 'false' destination.
     Value getFalseOperand(unsigned idx) {
       assert(idx < getNumFalseOperands());
       return getOperand(getFalseDestOperandIndex() + idx);
     }
     void setFalseOperand(unsigned idx, Value value) {
       assert(idx < getNumFalseOperands());
       setOperand(getFalseDestOperandIndex() + idx, value);
     }
 
-    operand_range getFalseOperands() { return falseDestOperands(); }
+    operand_range getTrueOperands() { return getTrueDestOperands(); }
+    operand_range getFalseOperands() { return getFalseDestOperands(); }
 
     unsigned getNumFalseOperands() { return getFalseOperands().size(); }
 
     /// Erase the operand at 'index' from the false operand list.
     void eraseFalseOperand(unsigned index) {
       falseDestOperandsMutable().erase(index);
     }
 
def ConstantOp : Std_Op<"constant",
   let builders = [
     OpBuilder<(ins "Attribute":$value),
     [{ build($_builder, $_state, value.getType(), value); }]>,
     OpBuilder<(ins "Attribute":$value, "Type":$type),
     [{ build($_builder, $_state, type, value); }]>,
   ];
 
   let extraClassDeclaration = [{
-    Attribute getValue() { return (*this)->getAttr("value"); }
-
     /// Returns true if a constant operation can be built with the given value
     /// and result type.
     static bool isBuildableWith(Attribute value, Type type);
   }];
 
   let hasFolder = 1;
 }
 
def SelectOp : Std_Op<"select", [NoSideEffect,
 
   let builders = [
     OpBuilder<(ins "Value":$condition, "Value":$trueValue,
       "Value":$falseValue), [{
       $_state.addOperands({condition, trueValue, falseValue});
       $_state.addTypes(trueValue.getType());
     }]>];
 
-  let extraClassDeclaration = [{
-      Value getCondition() { return condition(); }
-      Value getTrueValue() { return true_value(); }
-      Value getFalseValue() { return false_value(); }
-  }];
-
   let hasCanonicalizer = 1;
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 

mlir/lib/Conversion/ArithmeticToLLVM/ArithmeticToLLVM.cpp

 LogicalResult IndexCastOpLowering::matchAndRewrite(
     arith::IndexCastOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   auto targetType = typeConverter->convertType(op.getResult().getType());
   auto targetElementType =
       typeConverter->convertType(getElementTypeOrSelf(op.getResult()))
           .cast<IntegerType>();
   auto sourceElementType =
-      getElementTypeOrSelf(adaptor.in()).cast<IntegerType>();
+      getElementTypeOrSelf(adaptor.getIn()).cast<IntegerType>();
   unsigned targetBits = targetElementType.getWidth();
   unsigned sourceBits = sourceElementType.getWidth();
 
   if (targetBits == sourceBits)
-    rewriter.replaceOp(op, adaptor.in());
+    rewriter.replaceOp(op, adaptor.getIn());
   else if (targetBits < sourceBits)
-    rewriter.replaceOpWithNewOp<LLVM::TruncOp>(op, targetType, adaptor.in());
+    rewriter.replaceOpWithNewOp<LLVM::TruncOp>(op, targetType, adaptor.getIn());
   else
-    rewriter.replaceOpWithNewOp<LLVM::SExtOp>(op, targetType, adaptor.in());
+    rewriter.replaceOpWithNewOp<LLVM::SExtOp>(op, targetType, adaptor.getIn());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CmpIOpLowering
 //===----------------------------------------------------------------------===//
 
 // Convert arith.cmp predicate into the LLVM dialect CmpPredicate. The two enums
 // share numerical values so just cast.
 template <typename LLVMPredType, typename PredType>
 static LLVMPredType convertCmpPredicate(PredType pred) {
   return static_cast<LLVMPredType>(pred);
 }
 
 LogicalResult
 CmpIOpLowering::matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
-  auto operandType = adaptor.lhs().getType();
+  auto operandType = adaptor.getLhs().getType();
   auto resultType = op.getResult().getType();
 
   // Handle the scalar and 1D vector cases.
   if (!operandType.isa<LLVM::LLVMArrayType>()) {
     rewriter.replaceOpWithNewOp<LLVM::ICmpOp>(
         op, typeConverter->convertType(resultType),
         convertCmpPredicate<LLVM::ICmpPredicate>(op.getPredicate()),
-        adaptor.lhs(), adaptor.rhs());
+        adaptor.getLhs(), adaptor.getRhs());
     return success();
   }
 
   auto vectorType = resultType.dyn_cast<VectorType>();
   if (!vectorType)
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
         OpAdaptor adaptor(operands);
         return rewriter.create<LLVM::ICmpOp>(
             op.getLoc(), llvm1DVectorTy,
             convertCmpPredicate<LLVM::ICmpPredicate>(op.getPredicate()),
-            adaptor.lhs(), adaptor.rhs());
+            adaptor.getLhs(), adaptor.getRhs());
       },
       rewriter);
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CmpFOpLowering
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 CmpFOpLowering::matchAndRewrite(arith::CmpFOp op, OpAdaptor adaptor,
                                 ConversionPatternRewriter &rewriter) const {
-  auto operandType = adaptor.lhs().getType();
+  auto operandType = adaptor.getLhs().getType();
   auto resultType = op.getResult().getType();
 
   // Handle the scalar and 1D vector cases.
   if (!operandType.isa<LLVM::LLVMArrayType>()) {
     rewriter.replaceOpWithNewOp<LLVM::FCmpOp>(
         op, typeConverter->convertType(resultType),
         convertCmpPredicate<LLVM::FCmpPredicate>(op.getPredicate()),
-        adaptor.lhs(), adaptor.rhs());
+        adaptor.getLhs(), adaptor.getRhs());
     return success();
   }
 
   auto vectorType = resultType.dyn_cast<VectorType>();
   if (!vectorType)
     return rewriter.notifyMatchFailure(op, "expected vector result type");
 
   return LLVM::detail::handleMultidimensionalVectors(
       op.getOperation(), adaptor.getOperands(), *getTypeConverter(),
       [&](Type llvm1DVectorTy, ValueRange operands) {
         OpAdaptor adaptor(operands);
         return rewriter.create<LLVM::FCmpOp>(
             op.getLoc(), llvm1DVectorTy,
             convertCmpPredicate<LLVM::FCmpPredicate>(op.getPredicate()),
-            adaptor.lhs(), adaptor.rhs());
+            adaptor.getLhs(), adaptor.getRhs());
       },
       rewriter);
 }
 
 //===----------------------------------------------------------------------===//
 // Pass Definition
 //===----------------------------------------------------------------------===//
 

mlir/lib/Conversion/ArithmeticToSPIRV/ArithmeticToSPIRV.cpp

LogicalResult ConstantCompositeOpPattern::matchAndRewrite(
 
   // arith.constant should only have vector or tenor types.
   assert((srcType.isa<VectorType, RankedTensorType>()));
 
   auto dstType = getTypeConverter()->convertType(srcType);
   if (!dstType)
     return failure();
 
-  auto dstElementsAttr = constOp.value().dyn_cast<DenseElementsAttr>();
+  auto dstElementsAttr = constOp.getValue().dyn_cast<DenseElementsAttr>();
   ShapedType dstAttrType = dstElementsAttr.getType();
   if (!dstElementsAttr)
     return failure();
 
   // If the composite type has more than one dimensions, perform linearization.
   if (srcType.getRank() > 1) {
     if (srcType.isa<RankedTensorType>()) {
       dstAttrType = RankedTensorType::get(srcType.getNumElements(),
if (!srcType.isIntOrIndexOrFloat())
     return failure();
 
   Type dstType = getTypeConverter()->convertType(srcType);
   if (!dstType)
     return failure();
 
   // Floating-point types.
   if (srcType.isa<FloatType>()) {
-    auto srcAttr = constOp.value().cast<FloatAttr>();
+    auto srcAttr = constOp.getValue().cast<FloatAttr>();
     auto dstAttr = srcAttr;
 
     // Floating-point types not supported in the target environment are all
     // converted to float type.
     if (srcType != dstType) {
       dstAttr = convertFloatAttr(srcAttr, dstType.cast<FloatType>(), rewriter);
       if (!dstAttr)
         return failure();
     }
 
     rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
     return success();
   }
 
   // Bool type.
   if (srcType.isInteger(1)) {
     // arith.constant can use 0/1 instead of true/false for i1 values. We need
     // to handle that here.
-    auto dstAttr = convertBoolAttr(constOp.value(), rewriter);
+    auto dstAttr = convertBoolAttr(constOp.getValue(), rewriter);
     if (!dstAttr)
       return failure();
     rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
     return success();
   }
 
   // IndexType or IntegerType. Index values are converted to 32-bit integer
   // values when converting to SPIR-V.
-  auto srcAttr = constOp.value().cast<IntegerAttr>();
+  auto srcAttr = constOp.getValue().cast<IntegerAttr>();
   auto dstAttr =
       convertIntegerAttr(srcAttr, dstType.cast<IntegerType>(), rewriter);
   if (!dstAttr)
     return failure();
   rewriter.replaceOpWithNewOp<spirv::ConstantOp>(constOp, dstType, dstAttr);
   return success();
 }
 

 
 //===----------------------------------------------------------------------===//
 // CmpIOpBooleanPattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult CmpIOpBooleanPattern::matchAndRewrite(
     arith::CmpIOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
-  Type operandType = op.lhs().getType();
+  Type operandType = op.getLhs().getType();
   if (!isBoolScalarOrVector(operandType))
     return failure();
 
   switch (op.getPredicate()) {
 #define DISPATCH(cmpPredicate, spirvOp)                                        \
   case cmpPredicate:                                                           \
     rewriter.replaceOpWithNewOp<spirvOp>(op, op.getResult().getType(),         \
                                          adaptor.lhs(), adaptor.rhs());        \

 
 //===----------------------------------------------------------------------===//
 // CmpIOpPattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 CmpIOpPattern::matchAndRewrite(arith::CmpIOp op, OpAdaptor adaptor,
                                ConversionPatternRewriter &rewriter) const {
-  Type operandType = op.lhs().getType();
+  Type operandType = op.getLhs().getType();
   if (isBoolScalarOrVector(operandType))
     return failure();
 
   switch (op.getPredicate()) {
 #define DISPATCH(cmpPredicate, spirvOp)                                        \
   case cmpPredicate:                                                           \
     if (spirvOp::template hasTrait<OpTrait::spirv::UnsignedOp>() &&            \
         operandType != this->getTypeConverter()->convertType(operandType)) {   \

 //===----------------------------------------------------------------------===//
 // CmpFOpNanKernelPattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult CmpFOpNanKernelPattern::matchAndRewrite(
     arith::CmpFOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   if (op.getPredicate() == arith::CmpFPredicate::ORD) {
-    rewriter.replaceOpWithNewOp<spirv::OrderedOp>(op, adaptor.lhs(),
-                                                  adaptor.rhs());
+    rewriter.replaceOpWithNewOp<spirv::OrderedOp>(op, adaptor.getLhs(),
+                                                  adaptor.getRhs());
     return success();
   }
 
   if (op.getPredicate() == arith::CmpFPredicate::UNO) {
-    rewriter.replaceOpWithNewOp<spirv::UnorderedOp>(op, adaptor.lhs(),
-                                                    adaptor.rhs());
+    rewriter.replaceOpWithNewOp<spirv::UnorderedOp>(op, adaptor.getLhs(),
+                                                    adaptor.getRhs());
     return success();
   }
 
   return failure();
 }
 
 //===----------------------------------------------------------------------===//
 // CmpFOpNanNonePattern
 //===----------------------------------------------------------------------===//
 
 LogicalResult CmpFOpNanNonePattern::matchAndRewrite(
     arith::CmpFOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   if (op.getPredicate() != arith::CmpFPredicate::ORD &&
       op.getPredicate() != arith::CmpFPredicate::UNO)
     return failure();
 
   Location loc = op.getLoc();
 
-  Value lhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.lhs());
-  Value rhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.rhs());
+  Value lhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.getLhs());
+  Value rhsIsNan = rewriter.create<spirv::IsNanOp>(loc, adaptor.getRhs());
 
   Value replace = rewriter.create<spirv::LogicalOrOp>(loc, lhsIsNan, rhsIsNan);
   if (op.getPredicate() == arith::CmpFPredicate::ORD)
     replace = rewriter.create<spirv::LogicalNotOp>(loc, replace);
 
   rewriter.replaceOp(op, replace);
   return success();
 }

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

matchAndRewrite(RuntimeAwaitAndResumeOp op, OpAdaptor adaptor,
 
     // A pointer to coroutine resume intrinsic wrapper.
     addResumeFunction(op->getParentOfType<ModuleOp>());
     auto resumeFnTy = AsyncAPI::resumeFunctionType(op->getContext());
     auto resumePtr = rewriter.create<LLVM::AddressOfOp>(
         op->getLoc(), LLVM::LLVMPointerType::get(resumeFnTy), kResume);
 
     rewriter.create<CallOp>(op->getLoc(), apiFuncName, TypeRange(),
-                            ValueRange({operand, handle, resumePtr.res()}));
+                            ValueRange({operand, handle, resumePtr.getRes()}));
     rewriter.eraseOp(op);
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
matchAndRewrite(RuntimeResumeOp op, OpAdaptor adaptor,
     // A pointer to coroutine resume intrinsic wrapper.
     addResumeFunction(op->getParentOfType<ModuleOp>());
     auto resumeFnTy = AsyncAPI::resumeFunctionType(op->getContext());
     auto resumePtr = rewriter.create<LLVM::AddressOfOp>(
         op->getLoc(), LLVM::LLVMPointerType::get(resumeFnTy), kResume);
 
     // Call async runtime API to execute a coroutine in the managed thread.
     auto coroHdl = adaptor.handle();
-    rewriter.replaceOpWithNewOp<CallOp>(op, TypeRange(), kExecute,
-                                        ValueRange({coroHdl, resumePtr.res()}));
+    rewriter.replaceOpWithNewOp<CallOp>(
+        op, TypeRange(), kExecute, ValueRange({coroHdl, resumePtr.getRes()}));
 
     return success();
   }
 };
 } // namespace
 
 //===----------------------------------------------------------------------===//
 // Convert async.runtime.store to the corresponding runtime API call.

mlir/lib/Conversion/GPUCommon/GPUOpsLowering.cpp

if (!workgroupBuffers.empty())
       zero = rewriter.create<LLVM::ConstantOp>(loc, i32Type,
                                                rewriter.getI32IntegerAttr(0));
     for (auto en : llvm::enumerate(workgroupBuffers)) {
       LLVM::GlobalOp global = en.value();
       Value address = rewriter.create<LLVM::AddressOfOp>(loc, global);
       auto elementType =
           global.getType().cast<LLVM::LLVMArrayType>().getElementType();
       Value memory = rewriter.create<LLVM::GEPOp>(
-          loc, LLVM::LLVMPointerType::get(elementType, global.addr_space()),
+          loc, LLVM::LLVMPointerType::get(elementType, global.getAddrSpace()),
           address, ArrayRef<Value>{zero, zero});
 
       // Build a memref descriptor pointing to the buffer to plug with the
       // existing memref infrastructure. This may use more registers than
       // otherwise necessary given that memref sizes are fixed, but we can try
       // and canonicalize that away later.
       Value attribution = gpuFuncOp.getWorkgroupAttributions()[en.index()];
       auto type = attribution.getType().cast<MemRefType>();

mlir/lib/Conversion/GPUCommon/GPUToLLVMConversion.cpp

rewriter.updateRootInPlace(yieldOp,
                              [&] { yieldOp->setOperands(newOperands); });
   return success();
 }
 
 // Returns whether `value` is the result of an LLVM::CallOp to `functionName`.
 static bool isDefinedByCallTo(Value value, StringRef functionName) {
   assert(value.getType().isa<LLVM::LLVMPointerType>());
   if (auto defOp = value.getDefiningOp<LLVM::CallOp>())
-    return defOp.callee()->equals(functionName);
+    return defOp.getCallee()->equals(functionName);
   return false;
 }
 
 // Converts `gpu.wait` to runtime calls. The converted op synchronizes the host
 // with the stream/event operands. The operands are destroyed. That is, it
 // assumes that it is not used afterwards or elsewhere. Otherwise we will get a
 // runtime error. Eventually, we should guarantee this property.
 LogicalResult ConvertWaitOpToGpuRuntimeCallPattern::matchAndRewrite(

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

private:
   Value createEntryPointNameConstant(StringRef name, Location loc,
                                      OpBuilder &builder);
 
   /// Declares all needed runtime functions.
   void declareVulkanFunctions(Location loc);
 
   /// Checks whether the given LLVM::CallOp is a vulkan launch call op.
   bool isVulkanLaunchCallOp(LLVM::CallOp callOp) {
-    return (callOp.callee() && callOp.callee().getValue() == kVulkanLaunch &&
+    return (callOp.getCallee() &&
+            callOp.getCallee().getValue() == kVulkanLaunch &&
             callOp.getNumOperands() >= kVulkanLaunchNumConfigOperands);
   }
 
   /// Checks whether the given LLVM::CallOp is a "ci_face" vulkan launch call
   /// op.
   bool isCInterfaceVulkanLaunchCallOp(LLVM::CallOp callOp) {
-    return (callOp.callee() &&
-            callOp.callee().getValue() == kCInterfaceVulkanLaunch &&
+    return (callOp.getCallee() &&
+            callOp.getCallee().getValue() == kCInterfaceVulkanLaunch &&
             callOp.getNumOperands() >= kVulkanLaunchNumConfigOperands);
   }
 
   /// Translates the given `vulkanLaunchCallOp` to the sequence of Vulkan
   /// runtime calls.
   void translateVulkanLaunchCall(LLVM::CallOp vulkanLaunchCallOp);
 
   /// Creates call to `bindMemRef` for each memref operand.

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

Value extractSizeOfUnrankedMemRef(Type operandType, memref::DimOp dimOp,
     return rewriter.create<LLVM::LoadOp>(loc, sizePtr);
   }
 
   Optional<int64_t> getConstantDimIndex(memref::DimOp dimOp) const {
     if (Optional<int64_t> idx = dimOp.getConstantIndex())
       return idx;
 
     if (auto constantOp = dimOp.index().getDefiningOp<LLVM::ConstantOp>())
-      return constantOp.value().cast<IntegerAttr>().getValue().getSExtValue();
+      return constantOp.getValue()
+          .cast<IntegerAttr>()
+          .getValue()
+          .getSExtValue();
 
     return llvm::None;
   }
 
   Value extractSizeOfRankedMemRef(Type operandType, memref::DimOp dimOp,
                                   OpAdaptor adaptor,
                                   ConversionPatternRewriter &rewriter) const {
     Location loc = dimOp.getLoc();

mlir/lib/Conversion/SCFToGPU/SCFToGPU.cpp

static LogicalResult processParallelLoop(
   };
 
   auto ensureLaunchIndependent = [&rewriter,
                                   launchIndependent](Value val) -> Value {
     if (launchIndependent(val))
       return val;
     if (auto constOp = val.getDefiningOp<arith::ConstantOp>())
       return rewriter.create<arith::ConstantOp>(constOp.getLoc(),
-                                                constOp.value());
+                                                constOp.getValue());
     return {};
   };
 
   for (auto config : llvm::zip(mapping, parallelOp.getInductionVars(),
                                parallelOp.lowerBound(), parallelOp.upperBound(),
                                parallelOp.step())) {
     Attribute mappingAttribute;
     Value iv, lowerBound, upperBound, step;

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

if (!compare || !select || !terminator)
     return false;
 
   // Block arguments must be compared.
   if (compare->getOperands() != block.getArguments())
     return false;
 
   // Detect whether the comparison is less-than or greater-than, otherwise bail.
   bool isLess;
-  if (llvm::find(lessThanPredicates, compare.predicate()) !=
+  if (llvm::find(lessThanPredicates, compare.getPredicate()) !=
       lessThanPredicates.end()) {
     isLess = true;
-  } else if (llvm::find(greaterThanPredicates, compare.predicate()) !=
+  } else if (llvm::find(greaterThanPredicates, compare.getPredicate()) !=
              greaterThanPredicates.end()) {
     isLess = false;
   } else {
     return false;
   }
 
-  if (select.condition() != compare.getResult())
+  if (select.getCondition() != compare.getResult())
     return false;
 
   // Detect if the operands are swapped between cmpf and select. Match the
   // comparison type with the requested type or with the opposite of the
   // requested type if the operands are swapped. Use generic accessors because
   // std and LLVM versions of select have different operand names but identical
   // positions.
   constexpr unsigned kTrueValue = 1;
   constexpr unsigned kFalseValue = 2;
-  bool sameOperands = select.getOperand(kTrueValue) == compare.lhs() &&
-                      select.getOperand(kFalseValue) == compare.rhs();
-  bool swappedOperands = select.getOperand(kTrueValue) == compare.rhs() &&
-                         select.getOperand(kFalseValue) == compare.lhs();
+  bool sameOperands = select.getOperand(kTrueValue) == compare.getLhs() &&
+                      select.getOperand(kFalseValue) == compare.getRhs();
+  bool swappedOperands = select.getOperand(kTrueValue) == compare.getRhs() &&
+                         select.getOperand(kFalseValue) == compare.getLhs();
   if (!sameOperands && !swappedOperands)
     return false;
 
   if (select.getResult() != terminator.result())
     return false;
 
   // The reduction is a min if it uses less-than predicates with same operands
   // or greather-than predicates with swapped operands. Similarly for max.

mlir/lib/Conversion/ShapeToStandard/ConvertShapeConstraints.cpp

 } // namespace
 
 namespace {
 class ConvertCstrRequireOp : public OpRewritePattern<shape::CstrRequireOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
   LogicalResult matchAndRewrite(shape::CstrRequireOp op,
                                 PatternRewriter &rewriter) const override {
-    rewriter.create<AssertOp>(op.getLoc(), op.pred(), op.msgAttr());
+    rewriter.create<AssertOp>(op.getLoc(), op.getPred(), op.getMsgAttr());
     rewriter.replaceOpWithNewOp<shape::ConstWitnessOp>(op, true);
     return success();
   }
 };
 } // namespace
 
 void mlir::populateConvertShapeConstraintsConversionPatterns(
     RewritePatternSet &patterns) {

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

 };
 } // namespace
 
 LogicalResult
 AnyOpConversion::matchAndRewrite(AnyOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
   // Replace `any` with its first operand.
   // Any operand would be a valid substitution.
-  rewriter.replaceOp(op, {adaptor.inputs().front()});
+  rewriter.replaceOp(op, {adaptor.getInputs().front()});
   return success();
 }
 
 namespace {
 template <typename SrcOpTy, typename DstOpTy>
 class BinaryOpConversion : public OpConversionPattern<SrcOpTy> {
 public:
   using OpConversionPattern<SrcOpTy>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(SrcOpTy op, typename SrcOpTy::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // For now, only error-free types are supported by this lowering.
     if (op.getType().template isa<SizeType>())
       return failure();
 
-    rewriter.replaceOpWithNewOp<DstOpTy>(op, adaptor.lhs(), adaptor.rhs());
+    rewriter.replaceOpWithNewOp<DstOpTy>(op, adaptor.getLhs(),
+                                         adaptor.getRhs());
     return success();
   }
 };
 } // namespace
 
 namespace {
 struct BroadcastOpConverter : public OpConversionPattern<BroadcastOp> {
   using OpConversionPattern<BroadcastOp>::OpConversionPattern;
LogicalResult BroadcastOpConverter::matchAndRewrite(
 
   Value zero = lb.create<arith::ConstantIndexOp>(0);
   Type indexTy = lb.getIndexType();
 
   // Save all the ranks for bounds checking. Because this is a tensor
   // representing the shape extents, the rank is the extent of the only
   // dimension in the tensor.
   SmallVector<Value> ranks, rankDiffs;
-  llvm::append_range(ranks, llvm::map_range(adaptor.shapes(), [&](Value v) {
+  llvm::append_range(ranks, llvm::map_range(adaptor.getShapes(), [&](Value v) {
                        return lb.create<tensor::DimOp>(v, zero);
                      }));
 
   // Find the maximum rank
   Value maxRank = ranks.front();
   for (Value v : llvm::drop_begin(ranks, 1)) {
     Value rankIsGreater =
         lb.create<arith::CmpIOp>(arith::CmpIPredicate::ugt, v, maxRank);
     maxRank = lb.create<SelectOp>(rankIsGreater, v, maxRank);
   }
 
   // Calculate the difference of ranks and the maximum rank for later offsets.
   llvm::append_range(rankDiffs, llvm::map_range(ranks, [&](Value v) {
                        return lb.create<arith::SubIOp>(indexTy, maxRank, v);
                      }));
 
   Value replacement = lb.create<tensor::GenerateOp>(
       getExtentTensorType(lb.getContext()), ValueRange{maxRank},
       [&](OpBuilder &b, Location loc, ValueRange args) {
-        Value broadcastedDim = getBroadcastedDim(
-            ImplicitLocOpBuilder(loc, b), adaptor.shapes(), rankDiffs, args[0]);
+        Value broadcastedDim =
+            getBroadcastedDim(ImplicitLocOpBuilder(loc, b), adaptor.getShapes(),
+                              rankDiffs, args[0]);
 
         b.create<tensor::YieldOp>(loc, broadcastedDim);
       });
   if (replacement.getType() != op.getType())
     replacement = lb.create<tensor::CastOp>(op.getType(), replacement);
   rewriter.replaceOp(op, replacement);
   return success();
 }
LogicalResult ConstShapeOpConverter::matchAndRewrite(
 
   // For now, this lowering supports only extent tensors, not `shape.shape`
   // types.
   if (op.getType().isa<ShapeType>())
     return failure();
 
   auto loc = op.getLoc();
   SmallVector<Value, 4> extentOperands;
-  for (auto extent : op.shape()) {
+  for (auto extent : op.getShape()) {
     extentOperands.push_back(
         rewriter.create<arith::ConstantIndexOp>(loc, extent.getLimitedValue()));
   }
   Type indexTy = rewriter.getIndexType();
   Value tensor =
       rewriter.create<tensor::FromElementsOp>(loc, indexTy, extentOperands);
-  Type resultTy = RankedTensorType::get({op.shape().size()}, indexTy);
+  Type resultTy = RankedTensorType::get({op.getShape().size()}, indexTy);
   rewriter.replaceOpWithNewOp<tensor::CastOp>(op, resultTy, tensor);
   return success();
 }
 
 namespace {
 class ConstSizeOpConversion : public OpConversionPattern<ConstSizeOp> {
 public:
   using OpConversionPattern<ConstSizeOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(ConstSizeOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult ConstSizeOpConversion::matchAndRewrite(
     ConstSizeOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   rewriter.replaceOpWithNewOp<arith::ConstantIndexOp>(
-      op, op.value().getSExtValue());
+      op, op.getValue().getSExtValue());
   return success();
 }
 
 namespace {
 struct IsBroadcastableOpConverter
     : public OpConversionPattern<IsBroadcastableOp> {
   using OpConversionPattern<IsBroadcastableOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(IsBroadcastableOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult IsBroadcastableOpConverter::matchAndRewrite(
     IsBroadcastableOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   // For now, this lowering is only defined on `tensor<?xindex>` operands, not
   // on shapes.
-  if (!llvm::all_of(op.shapes(),
+  if (!llvm::all_of(op.getShapes(),
                     [](Value v) { return !v.getType().isa<ShapeType>(); }))
     return failure();
 
   auto loc = op.getLoc();
   ImplicitLocOpBuilder lb(loc, rewriter);
   Value zero = lb.create<arith::ConstantIndexOp>(0);
   Value one = lb.create<arith::ConstantIndexOp>(1);
   Type indexTy = lb.getIndexType();
 
   // Save all the ranks for bounds checking. Because this is a tensor
   // representing the shape extents, the rank is the extent of the only
   // dimension in the tensor.
   SmallVector<Value> ranks, rankDiffs;
-  llvm::append_range(ranks, llvm::map_range(adaptor.shapes(), [&](Value v) {
+  llvm::append_range(ranks, llvm::map_range(adaptor.getShapes(), [&](Value v) {
                        return lb.create<tensor::DimOp>(v, zero);
                      }));
 
   // Find the maximum rank
   Value maxRank = ranks.front();
   for (Value v : llvm::drop_begin(ranks, 1)) {
     Value rankIsGreater =
         lb.create<arith::CmpIOp>(arith::CmpIPredicate::ugt, v, maxRank);
LogicalResult IsBroadcastableOpConverter::matchAndRewrite(
 
   auto reduceResult = lb.create<ForOp>(
       loc, zero, maxRank, one, ValueRange{trueVal},
       [&](OpBuilder &b, Location loc, Value iv, ValueRange iterArgs) {
         // Find a non-1 dim, if it exists. Note that the first part of this
         // could reuse the Broadcast lowering entirely, but we redo the work
         // here to make optimizations easier between the two loops.
         Value broadcastedDim = getBroadcastedDim(
-            ImplicitLocOpBuilder(loc, b), adaptor.shapes(), rankDiffs, iv);
+            ImplicitLocOpBuilder(loc, b), adaptor.getShapes(), rankDiffs, iv);
 
         Value broadcastable = iterArgs[0];
-        for (auto tup : llvm::zip(adaptor.shapes(), rankDiffs)) {
+        for (auto tup : llvm::zip(adaptor.getShapes(), rankDiffs)) {
           Value shape, rankDiff;
           std::tie(shape, rankDiff) = tup;
           Value outOfBounds = b.create<arith::CmpIOp>(
               loc, arith::CmpIPredicate::ult, iv, rankDiff);
           broadcastable =
               b.create<IfOp>(
                    loc, TypeRange{i1Ty}, outOfBounds,
                    [&](OpBuilder &b, Location loc) {
LogicalResult GetExtentOpConverter::matchAndRewrite(
     GetExtentOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   // For now, only error-free types are supported by this lowering.
   if (op.getType().isa<SizeType>())
     return failure();
 
   // Derive shape extent directly from shape origin if possible. This
   // circumvents the necessity to materialize the shape in memory.
-  if (auto shapeOfOp = op.shape().getDefiningOp<ShapeOfOp>()) {
-    if (shapeOfOp.arg().getType().isa<ShapedType>()) {
-      rewriter.replaceOpWithNewOp<tensor::DimOp>(op, shapeOfOp.arg(),
-                                                 adaptor.dim());
+  if (auto shapeOfOp = op.getShape().getDefiningOp<ShapeOfOp>()) {
+    if (shapeOfOp.getArg().getType().isa<ShapedType>()) {
+      rewriter.replaceOpWithNewOp<tensor::DimOp>(op, shapeOfOp.getArg(),
+                                                 adaptor.getDim());
       return success();
     }
   }
 
-  rewriter.replaceOpWithNewOp<tensor::ExtractOp>(
-      op, rewriter.getIndexType(), adaptor.shape(), ValueRange{adaptor.dim()});
+  rewriter.replaceOpWithNewOp<tensor::ExtractOp>(op, rewriter.getIndexType(),
+                                                 adaptor.getShape(),
+                                                 ValueRange{adaptor.getDim()});
   return success();
 }
 
 namespace {
 class RankOpConverter : public OpConversionPattern<shape::RankOp> {
 public:
   using OpConversionPattern<shape::RankOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(shape::RankOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult
 RankOpConverter::matchAndRewrite(shape::RankOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
   // For now, this lowering supports only error-free types.
   if (op.getType().isa<SizeType>())
     return failure();
 
-  rewriter.replaceOpWithNewOp<tensor::DimOp>(op, adaptor.shape(), 0);
+  rewriter.replaceOpWithNewOp<tensor::DimOp>(op, adaptor.getShape(), 0);
   return success();
 }
 
 namespace {
 /// Converts `shape.reduce` to `scf.for`.
 struct ReduceOpConverter : public OpConversionPattern<shape::ReduceOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(shape::ReduceOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const final;
 };
 } // namespace
 
 LogicalResult
 ReduceOpConverter::matchAndRewrite(shape::ReduceOp op, OpAdaptor adaptor,
                                    ConversionPatternRewriter &rewriter) const {
   // For now, this lowering is only defined on `tensor<?xindex>` operands.
-  if (op.shape().getType().isa<ShapeType>())
+  if (op.getShape().getType().isa<ShapeType>())
     return failure();
 
   auto loc = op.getLoc();
 
   Value zero = rewriter.create<arith::ConstantIndexOp>(loc, 0);
   Value one = rewriter.create<arith::ConstantIndexOp>(loc, 1);
   Type indexTy = rewriter.getIndexType();
   Value rank =
-      rewriter.create<tensor::DimOp>(loc, indexTy, adaptor.shape(), zero);
+      rewriter.create<tensor::DimOp>(loc, indexTy, adaptor.getShape(), zero);
 
   auto loop = rewriter.create<scf::ForOp>(
-      loc, zero, rank, one, op.initVals(),
+      loc, zero, rank, one, op.getInitVals(),
       [&](OpBuilder &b, Location loc, Value iv, ValueRange args) {
-        Value extent = b.create<tensor::ExtractOp>(loc, adaptor.shape(), iv);
+        Value extent = b.create<tensor::ExtractOp>(loc, adaptor.getShape(), iv);
 
         SmallVector<Value, 2> mappedValues{iv, extent};
         mappedValues.append(args.begin(), args.end());
 
         BlockAndValueMapping mapping;
         Block *reduceBody = op.getBody();
         mapping.map(reduceBody->getArguments(), mappedValues);
         for (auto &nested : reduceBody->without_terminator())
struct ShapeEqOpConverter : public OpConversionPattern<ShapeEqOp> {
   matchAndRewrite(ShapeEqOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override;
 };
 } // namespace
 
 LogicalResult
 ShapeEqOpConverter::matchAndRewrite(ShapeEqOp op, OpAdaptor adaptor,
                                     ConversionPatternRewriter &rewriter) const {
-  if (!llvm::all_of(op.shapes(),
+  if (!llvm::all_of(op.getShapes(),
                     [](Value v) { return !v.getType().isa<ShapeType>(); }))
     return failure();
 
   Type i1Ty = rewriter.getI1Type();
-  if (op.shapes().size() <= 1) {
+  if (op.getShapes().size() <= 1) {
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(op, i1Ty,
                                                    rewriter.getBoolAttr(true));
     return success();
   }
 
   auto loc = op.getLoc();
   Type indexTy = rewriter.getIndexType();
   Value zero = rewriter.create<arith::ConstantIndexOp>(loc, 0);
-  Value firstShape = adaptor.shapes().front();
+  Value firstShape = adaptor.getShapes().front();
   Value firstRank =
       rewriter.create<tensor::DimOp>(loc, indexTy, firstShape, zero);
   Value result = nullptr;
   // Generate a linear sequence of compares, all with firstShape as lhs.
-  for (Value shape : adaptor.shapes().drop_front(1)) {
+  for (Value shape : adaptor.getShapes().drop_front(1)) {
     Value rank = rewriter.create<tensor::DimOp>(loc, indexTy, shape, zero);
     Value eqRank = rewriter.create<arith::CmpIOp>(loc, arith::CmpIPredicate::eq,
                                                   firstRank, rank);
     auto same = rewriter.create<IfOp>(
         loc, i1Ty, eqRank,
         [&](OpBuilder &b, Location loc) {
           Value one = b.create<arith::ConstantIndexOp>(loc, 1);
           Value init =
LogicalResult ShapeOfOpConversion::matchAndRewrite(
     ConversionPatternRewriter &rewriter) const {
 
   // For now, only error-free types are supported by this lowering.
   if (op.getType().isa<ShapeType>())
     return failure();
 
   // For ranked tensor arguments, lower to `tensor.from_elements`.
   auto loc = op.getLoc();
-  Value tensor = adaptor.arg();
+  Value tensor = adaptor.getArg();
   Type tensorTy = tensor.getType();
   if (tensorTy.isa<RankedTensorType>()) {
 
     // Build values for individual extents.
     SmallVector<Value, 8> extentValues;
     RankedTensorType rankedTensorTy = tensorTy.cast<RankedTensorType>();
     int64_t rank = rankedTensorTy.getRank();
     for (int64_t i = 0; i < rank; i++) {

 };
 } // namespace
 
 LogicalResult SplitAtOpConversion::matchAndRewrite(
     SplitAtOp op, OpAdaptor adaptor,
     ConversionPatternRewriter &rewriter) const {
   // Error conditions are not implemented, only lower if all operands and
   // results are extent tensors.
-  if (llvm::any_of(ValueRange{op.operand(), op.head(), op.tail()},
+  if (llvm::any_of(ValueRange{op.getOperand(), op.getHead(), op.getTail()},
                    [](Value v) { return v.getType().isa<ShapeType>(); }))
     return failure();
 
   ImplicitLocOpBuilder b(op.getLoc(), rewriter);
   Value zero = b.create<arith::ConstantIndexOp>(0);
-  Value rank = b.create<tensor::DimOp>(adaptor.operand(), zero);
+  Value rank = b.create<tensor::DimOp>(adaptor.getOperand(), zero);
 
   // index < 0 ? index + rank : index
-  Value originalIndex = adaptor.index();
+  Value originalIndex = adaptor.getIndex();
   Value add = b.create<arith::AddIOp>(originalIndex, rank);
   Value indexIsNegative =
       b.create<arith::CmpIOp>(arith::CmpIPredicate::slt, originalIndex, zero);
   Value index = b.create<SelectOp>(indexIsNegative, add, originalIndex);
 
   Value one = b.create<arith::ConstantIndexOp>(1);
   Value head =
-      b.create<tensor::ExtractSliceOp>(adaptor.operand(), zero, index, one);
+      b.create<tensor::ExtractSliceOp>(adaptor.getOperand(), zero, index, one);
   Value tailSize = b.create<arith::SubIOp>(rank, index);
-  Value tail =
-      b.create<tensor::ExtractSliceOp>(adaptor.operand(), index, tailSize, one);
+  Value tail = b.create<tensor::ExtractSliceOp>(adaptor.getOperand(), index,
+                                                tailSize, one);
   rewriter.replaceOp(op, {head, tail});
   return success();
 }
 
 namespace {
 class ToExtentTensorOpConversion
     : public OpConversionPattern<ToExtentTensorOp> {
 public:
   using OpConversionPattern<ToExtentTensorOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(ToExtentTensorOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    if (!adaptor.input().getType().isa<RankedTensorType>())
+    if (!adaptor.getInput().getType().isa<RankedTensorType>())
       return rewriter.notifyMatchFailure(op, "input needs to be a tensor");
 
     rewriter.replaceOpWithNewOp<tensor::CastOp>(op, op.getType(),
-                                                adaptor.input());
+                                                adaptor.getInput());
     return success();
   }
 };
 } // namespace
 
 namespace {
 /// Import the Shape Ops to Std Patterns.
 #include "ShapeToStandard.cpp.inc"

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

matchAndRewrite(AssertOp op, OpAdaptor adaptor,
     // Generate IR to call `abort`.
     Block *failureBlock = rewriter.createBlock(opBlock->getParent());
     rewriter.create<LLVM::CallOp>(loc, abortFunc, llvm::None);
     rewriter.create<LLVM::UnreachableOp>(loc);
 
     // Generate assertion test.
     rewriter.setInsertionPointToEnd(opBlock);
     rewriter.replaceOpWithNewOp<LLVM::CondBrOp>(
-        op, adaptor.arg(), continuationBlock, failureBlock);
+        op, adaptor.getArg(), continuationBlock, failureBlock);
 
     return success();
   }
 };
 
 struct ConstantOpLowering : public ConvertOpToLLVMPattern<ConstantOp> {
   using ConvertOpToLLVMPattern<ConstantOp>::ConvertOpToLLVMPattern;
 

 
 struct RankOpLowering : public ConvertOpToLLVMPattern<RankOp> {
   using ConvertOpToLLVMPattern<RankOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(RankOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
-    Type operandType = op.memrefOrTensor().getType();
+    Type operandType = op.getMemrefOrTensor().getType();
     if (auto unrankedMemRefType = operandType.dyn_cast<UnrankedMemRefType>()) {
-      UnrankedMemRefDescriptor desc(adaptor.memrefOrTensor());
+      UnrankedMemRefDescriptor desc(adaptor.getMemrefOrTensor());
       rewriter.replaceOp(op, {desc.rank(rewriter, loc)});
       return success();
     }
     if (auto rankedMemRefType = operandType.dyn_cast<MemRefType>()) {
       rewriter.replaceOp(
           op, {createIndexConstant(rewriter, loc, rankedMemRefType.getRank())});
       return success();
     }
matchAndRewrite(SplatOp splatOp, OpAdaptor adaptor,
     auto vectorType = typeConverter->convertType(splatOp.getType());
     Value undef = rewriter.create<LLVM::UndefOp>(splatOp.getLoc(), vectorType);
     auto zero = rewriter.create<LLVM::ConstantOp>(
         splatOp.getLoc(),
         typeConverter->convertType(rewriter.getIntegerType(32)),
         rewriter.getZeroAttr(rewriter.getIntegerType(32)));
 
     auto v = rewriter.create<LLVM::InsertElementOp>(
-        splatOp.getLoc(), vectorType, undef, adaptor.input(), zero);
+        splatOp.getLoc(), vectorType, undef, adaptor.getInput(), zero);
 
     int64_t width = splatOp.getType().cast<VectorType>().getDimSize(0);
     SmallVector<int32_t, 4> zeroValues(width, 0);
 
     // Shuffle the value across the desired number of elements.
     ArrayAttr zeroAttrs = rewriter.getI32ArrayAttr(zeroValues);
     rewriter.replaceOpWithNewOp<LLVM::ShuffleVectorOp>(splatOp, v, undef,
                                                        zeroAttrs);
matchAndRewrite(SplatOp splatOp, OpAdaptor adaptor,
 
     // Construct a 1-D vector with the splatted value that we insert in all the
     // places within the returned descriptor.
     Value vdesc = rewriter.create<LLVM::UndefOp>(loc, llvm1DVectorTy);
     auto zero = rewriter.create<LLVM::ConstantOp>(
         loc, typeConverter->convertType(rewriter.getIntegerType(32)),
         rewriter.getZeroAttr(rewriter.getIntegerType(32)));
     Value v = rewriter.create<LLVM::InsertElementOp>(loc, llvm1DVectorTy, vdesc,
-                                                     adaptor.input(), zero);
+                                                     adaptor.getInput(), zero);
 
     // Shuffle the value across the desired number of elements.
     int64_t width = resultType.getDimSize(resultType.getRank() - 1);
     SmallVector<int32_t, 4> zeroValues(width, 0);
     ArrayAttr zeroAttrs = rewriter.getI32ArrayAttr(zeroValues);
     v = rewriter.create<LLVM::ShuffleVectorOp>(loc, v, v, zeroAttrs);
 
     // Iterate of linear index, convert to coords space and insert splatted 1-D
     // vector in each position.
     nDVectorIterate(vectorTypeInfo, rewriter, [&](ArrayAttr position) {
       desc = rewriter.create<LLVM::InsertValueOp>(loc, llvmNDVectorTy, desc, v,
                                                   position);
     });
     rewriter.replaceOp(splatOp, desc);
     return success();
   }
 };
 
 } // namespace
 
 /// Try to match the kind of a std.atomic_rmw to determine whether to use a
 /// lowering to llvm.atomicrmw or fallback to llvm.cmpxchg.
 static Optional<LLVM::AtomicBinOp> matchSimpleAtomicOp(AtomicRMWOp atomicOp) {
-  switch (atomicOp.kind()) {
+  switch (atomicOp.getKind()) {
   case AtomicRMWKind::addf:
     return LLVM::AtomicBinOp::fadd;
   case AtomicRMWKind::addi:
     return LLVM::AtomicBinOp::add;
   case AtomicRMWKind::assign:
     return LLVM::AtomicBinOp::xchg;
   case AtomicRMWKind::maxs:
     return LLVM::AtomicBinOp::max;
struct AtomicRMWOpLowering : public LoadStoreOpLowering<AtomicRMWOp> {
   LogicalResult
   matchAndRewrite(AtomicRMWOp atomicOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (failed(match(atomicOp)))
       return failure();
     auto maybeKind = matchSimpleAtomicOp(atomicOp);
     if (!maybeKind)
       return failure();
-    auto resultType = adaptor.value().getType();
+    auto resultType = adaptor.getValue().getType();
     auto memRefType = atomicOp.getMemRefType();
     auto dataPtr =
-        getStridedElementPtr(atomicOp.getLoc(), memRefType, adaptor.memref(),
-                             adaptor.indices(), rewriter);
+        getStridedElementPtr(atomicOp.getLoc(), memRefType, adaptor.getMemref(),
+                             adaptor.getIndices(), rewriter);
     rewriter.replaceOpWithNewOp<LLVM::AtomicRMWOp>(
-        atomicOp, resultType, *maybeKind, dataPtr, adaptor.value(),
+        atomicOp, resultType, *maybeKind, dataPtr, adaptor.getValue(),
         LLVM::AtomicOrdering::acq_rel);
     return success();
   }
 };
 
 /// Wrap a llvm.cmpxchg operation in a while loop so that the operation can be
 /// retried until it succeeds in atomically storing a new value into memory.
 ///
auto *endBlock = rewriter.createBlock(
         loopBlock->getParent(), std::next(Region::iterator(loopBlock)));
 
     // Operations range to be moved to `endBlock`.
     auto opsToMoveStart = atomicOp->getIterator();
     auto opsToMoveEnd = initBlock->back().getIterator();
 
     // Compute the loaded value and branch to the loop block.
     rewriter.setInsertionPointToEnd(initBlock);
-    auto memRefType = atomicOp.memref().getType().cast<MemRefType>();
-    auto dataPtr = getStridedElementPtr(loc, memRefType, adaptor.memref(),
-                                        adaptor.indices(), rewriter);
+    auto memRefType = atomicOp.getMemref().getType().cast<MemRefType>();
+    auto dataPtr = getStridedElementPtr(loc, memRefType, adaptor.getMemref(),
+                                        adaptor.getIndices(), rewriter);
     Value init = rewriter.create<LLVM::LoadOp>(loc, dataPtr);
     rewriter.create<LLVM::BrOp>(loc, init, loopBlock);
 
     // Prepare the body of the loop block.
     rewriter.setInsertionPointToStart(loopBlock);
 
     // Clone the GenericAtomicRMWOp region and extract the result.
     auto loopArgument = loopBlock->getArgument(0);

mlir/lib/Conversion/StandardToSPIRV/StandardToSPIRV.cpp

 
 //===----------------------------------------------------------------------===//
 // SelectOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 SelectOpPattern::matchAndRewrite(SelectOp op, OpAdaptor adaptor,
                                  ConversionPatternRewriter &rewriter) const {
-  rewriter.replaceOpWithNewOp<spirv::SelectOp>(
-      op, adaptor.condition(), adaptor.true_value(), adaptor.false_value());
+  rewriter.replaceOpWithNewOp<spirv::SelectOp>(op, adaptor.getCondition(),
+                                               adaptor.getTrueValue(),
+                                               adaptor.getFalseValue());
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // SplatOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult
 SplatPattern::matchAndRewrite(SplatOp op, OpAdaptor adaptor,
                               ConversionPatternRewriter &rewriter) const {
   auto dstVecType = op.getType().dyn_cast<VectorType>();
   if (!dstVecType || !spirv::CompositeType::isValid(dstVecType))
     return failure();
-  SmallVector<Value, 4> source(dstVecType.getNumElements(), adaptor.input());
+  SmallVector<Value, 4> source(dstVecType.getNumElements(), adaptor.getInput());
   rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(op, dstVecType,
                                                            source);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Pattern population
 //===----------------------------------------------------------------------===//

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

 }
 
 /// Return true if the constant is a splat to a 2D vector so that it can be
 /// converted to a MMA constant matrix op.
 static bool constantSupportsMMAMatrixType(arith::ConstantOp constantOp) {
   auto vecType = constantOp.getType().dyn_cast<VectorType>();
   if (!vecType || vecType.getRank() != 2)
     return false;
-  return constantOp.value().isa<SplatElementsAttr>();
+  return constantOp.getValue().isa<SplatElementsAttr>();
 }
 
 /// Return true if this is a broadcast from scalar to a 2D vector.
 static bool broadcastSupportsMMAMatrixType(vector::BroadcastOp broadcastOp) {
   return broadcastOp.getVectorType().getRank() == 2 &&
          broadcastOp.source().getType().isa<FloatType>();
 }
 
static void convertContractOp(vector::ContractionOp op,
   valueMapping[op.getResult()] = matmul;
 }
 
 /// Convert a 2D splat ConstantOp to a SubgroupMmaConstantMatrix op.
 static void convertConstantOp(arith::ConstantOp op,
                               llvm::DenseMap<Value, Value> &valueMapping) {
   assert(constantSupportsMMAMatrixType(op));
   OpBuilder b(op);
-  Attribute splat = op.value().cast<SplatElementsAttr>().getSplatValue();
+  Attribute splat = op.getValue().cast<SplatElementsAttr>().getSplatValue();
   auto scalarConstant =
       b.create<arith::ConstantOp>(op.getLoc(), splat.getType(), splat);
   const char *fragType = inferFragType(op);
   auto vecType = op.getType().cast<VectorType>();
   gpu::MMAMatrixType type = gpu::MMAMatrixType::get(
       vecType.getShape(), vecType.getElementType(), llvm::StringRef(fragType));
   auto matrix = b.create<gpu::SubgroupMmaConstantMatrixOp>(op.getLoc(), type,
                                                            scalarConstant);

mlir/lib/Dialect/Affine/Transforms/SuperVectorize.cpp

 /// nullptr, otherwise.
 static arith::ConstantOp vectorizeConstant(arith::ConstantOp constOp,
                                            VectorizationState &state) {
   Type scalarTy = constOp.getType();
   if (!VectorType::isValidElementType(scalarTy))
     return nullptr;
 
   auto vecTy = getVectorType(scalarTy, state.strategy);
-  auto vecAttr = DenseElementsAttr::get(vecTy, constOp.value());
+  auto vecAttr = DenseElementsAttr::get(vecTy, constOp.getValue());
 
   OpBuilder::InsertionGuard guard(state.builder);
   Operation *parentOp = state.builder.getInsertionBlock()->getParentOp();
   // Find the innermost vectorized ancestor loop to insert the vector constant.
   while (parentOp && !state.vecLoopToVecDim.count(parentOp))
     parentOp = parentOp->getParentOp();
   assert(parentOp && state.vecLoopToVecDim.count(parentOp) &&
          isa<AffineForOp>(parentOp) && "Expected a vectorized for op");

 static bool isNeutralElementConst(AtomicRMWKind reductionKind, Value value,
                                   VectorizationState &state) {
   Type scalarTy = value.getType();
   if (!VectorType::isValidElementType(scalarTy))
     return false;
   Attribute valueAttr = getIdentityValueAttr(reductionKind, scalarTy,
                                              state.builder, value.getLoc());
   if (auto constOp = dyn_cast_or_null<arith::ConstantOp>(value.getDefiningOp()))
-    return constOp.value() == valueAttr;
+    return constOp.getValue() == valueAttr;
   return false;
 }
 
 /// Vectorizes a loop with the vectorization strategy in 'state'. A new loop is
 /// created and registered as replacement for the scalar loop. The builder's
 /// insertion point is set to the new loop's body so that subsequent vectorized
 /// operations are inserted into the new loop. If the loop is a vector
 /// dimension, the step of the newly created loop will reflect the vectorization

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 void arith::ConstantOp::getAsmResultNames(
     function_ref<void(Value, StringRef)> setNameFn) {
   auto type = getType();
-  if (auto intCst = value().dyn_cast<IntegerAttr>()) {
+  if (auto intCst = getValue().dyn_cast<IntegerAttr>()) {
     auto intType = type.dyn_cast<IntegerType>();
 
     // Sugar i1 constants with 'true' and 'false'.
     if (intType && intType.getWidth() == 1)
       return setNameFn(getResult(), (intCst.getInt() ? "true" : "false"));
 
     // Otherwise, build a compex name with the value and type.
     SmallString<32> specialNameBuffer;
     llvm::raw_svector_ostream specialName(specialNameBuffer);
     specialName << 'c' << intCst.getInt();
     if (intType)
       specialName << '_' << type;
     setNameFn(getResult(), specialName.str());
   } else {
     setNameFn(getResult(), "cst");
   }
 }
 
 /// TODO: disallow arith.constant to return anything other than signless integer
 /// or float like.
 static LogicalResult verify(arith::ConstantOp op) {
   auto type = op.getType();
   // The value's type must match the return type.
-  if (op.value().getType() != type) {
-    return op.emitOpError() << "value type " << op.value().getType()
+  if (op.getValue().getType() != type) {
+    return op.emitOpError() << "value type " << op.getValue().getType()
                             << " must match return type: " << type;
   }
   // Integer values must be signless.
   if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
     return op.emitOpError("integer return type must be signless");
   // Any float or elements attribute are acceptable.
-  if (!op.value().isa<IntegerAttr, FloatAttr, ElementsAttr>()) {
+  if (!op.getValue().isa<IntegerAttr, FloatAttr, ElementsAttr>()) {
     return op.emitOpError(
         "value must be an integer, float, or elements attribute");
   }
   return success();
 }
 
 bool arith::ConstantOp::isBuildableWith(Attribute value, Type type) {
   // The value's type must be the same as the provided type.
   if (value.getType() != type)
     return false;
   // Integer values must be signless.
   if (type.isa<IntegerType>() && !type.cast<IntegerType>().isSignless())
     return false;
   // Integer, float, and element attributes are buildable.
   return value.isa<IntegerAttr, FloatAttr, ElementsAttr>();
 }
 
 OpFoldResult arith::ConstantOp::fold(ArrayRef<Attribute> operands) {
-  return value();
+  return getValue();
 }
 
 void arith::ConstantIntOp::build(OpBuilder &builder, OperationState &result,
                                  int64_t value, unsigned width) {
   auto type = builder.getIntegerType(width);
   arith::ConstantOp::build(builder, result, type,
                            builder.getIntegerAttr(type, value));
 }

 }
 
 //===----------------------------------------------------------------------===//
 // AddIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::AddIOp::fold(ArrayRef<Attribute> operands) {
   // addi(x, 0) -> x
-  if (matchPattern(rhs(), m_Zero()))
-    return lhs();
+  if (matchPattern(getRhs(), m_Zero()))
+    return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a + b; });
 }
 
 void arith::AddIOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<AddIAddConstant, AddISubConstantRHS, AddISubConstantLHS>(
       context);
 }
 
 //===----------------------------------------------------------------------===//
 // SubIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::SubIOp::fold(ArrayRef<Attribute> operands) {
   // subi(x,x) -> 0
   if (getOperand(0) == getOperand(1))
     return Builder(getContext()).getZeroAttr(getType());
   // subi(x,0) -> x
-  if (matchPattern(rhs(), m_Zero()))
-    return lhs();
+  if (matchPattern(getRhs(), m_Zero()))
+    return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a - b; });
 }
 
 void arith::SubIOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<SubIRHSAddConstant, SubILHSAddConstant, SubIRHSSubConstantRHS,
                   SubIRHSSubConstantLHS, SubILHSSubConstantRHS,
                   SubILHSSubConstantLHS>(context);
 }
 
 //===----------------------------------------------------------------------===//
 // MulIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::MulIOp::fold(ArrayRef<Attribute> operands) {
   // muli(x, 0) -> 0
-  if (matchPattern(rhs(), m_Zero()))
-    return rhs();
+  if (matchPattern(getRhs(), m_Zero()))
+    return getRhs();
   // muli(x, 1) -> x
-  if (matchPattern(rhs(), m_One()))
+  if (matchPattern(getRhs(), m_One()))
     return getOperand(0);
   // TODO: Handle the overflow case.
 
   // default folder
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a * b; });
 }
 
if (div0 || !b) {
       return a;
     }
     return a.udiv(b);
   });
 
   // Fold out division by one. Assumes all tensors of all ones are splats.
   if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
     if (rhs.getValue() == 1)
-      return lhs();
+      return getLhs();
   } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
     if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
-      return lhs();
+      return getLhs();
   }
 
   return div0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
 // DivSIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::DivSIOp::fold(ArrayRef<Attribute> operands) {
   // Don't fold if it would overflow or if it requires a division by zero.
   bool overflowOrDiv0 = false;
   auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
     if (overflowOrDiv0 || !b) {
       overflowOrDiv0 = true;
       return a;
     }
     return a.sdiv_ov(b, overflowOrDiv0);
   });
 
   // Fold out division by one. Assumes all tensors of all ones are splats.
   if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
     if (rhs.getValue() == 1)
-      return lhs();
+      return getLhs();
   } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
     if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
-      return lhs();
+      return getLhs();
   }
 
   return overflowOrDiv0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
 // Ceil and floor division folding helpers
 //===----------------------------------------------------------------------===//
auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
     APInt div = a.sdiv_ov(posB, overflowOrDiv0);
     return zero.ssub_ov(div, overflowOrDiv0);
   });
 
   // Fold out floor division by one. Assumes all tensors of all ones are
   // splats.
   if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
     if (rhs.getValue() == 1)
-      return lhs();
+      return getLhs();
   } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
     if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
-      return lhs();
+      return getLhs();
   }
 
   return overflowOrDiv0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
 // FloorDivSIOp
 //===----------------------------------------------------------------------===//
auto result = constFoldBinaryOp<IntegerAttr>(operands, [&](APInt a, APInt b) {
     APInt ceil = signedCeilNonnegInputs(a, posB, overflowOrDiv0);
     return zero.ssub_ov(ceil, overflowOrDiv0);
   });
 
   // Fold out floor division by one. Assumes all tensors of all ones are
   // splats.
   if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
     if (rhs.getValue() == 1)
-      return lhs();
+      return getLhs();
   } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
     if (rhs.getSplatValue<IntegerAttr>().getValue() == 1)
-      return lhs();
+      return getLhs();
   }
 
   return overflowOrDiv0 ? Attribute() : result;
 }
 
 //===----------------------------------------------------------------------===//
 // RemUIOp
 //===----------------------------------------------------------------------===//

 }
 
 //===----------------------------------------------------------------------===//
 // AndIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::AndIOp::fold(ArrayRef<Attribute> operands) {
   /// and(x, 0) -> 0
-  if (matchPattern(rhs(), m_Zero()))
-    return rhs();
+  if (matchPattern(getRhs(), m_Zero()))
+    return getRhs();
   /// and(x, allOnes) -> x
   APInt intValue;
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isAllOnes())
-    return lhs();
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isAllOnes())
+    return getLhs();
   /// and(x, x) -> x
-  if (lhs() == rhs())
-    return rhs();
+  if (getLhs() == getRhs())
+    return getRhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a & b; });
 }
 
 //===----------------------------------------------------------------------===//
 // OrIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::OrIOp::fold(ArrayRef<Attribute> operands) {
   /// or(x, 0) -> x
-  if (matchPattern(rhs(), m_Zero()))
-    return lhs();
+  if (matchPattern(getRhs(), m_Zero()))
+    return getLhs();
   /// or(x, x) -> x
-  if (lhs() == rhs())
-    return rhs();
+  if (getLhs() == getRhs())
+    return getRhs();
   /// or(x, <all ones>) -> <all ones>
   if (auto rhsAttr = operands[1].dyn_cast_or_null<IntegerAttr>())
     if (rhsAttr.getValue().isAllOnes())
       return rhsAttr;
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a | b; });
 }
 
 //===----------------------------------------------------------------------===//
 // XOrIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::XOrIOp::fold(ArrayRef<Attribute> operands) {
   /// xor(x, 0) -> x
-  if (matchPattern(rhs(), m_Zero()))
-    return lhs();
+  if (matchPattern(getRhs(), m_Zero()))
+    return getLhs();
   /// xor(x, x) -> 0
-  if (lhs() == rhs())
+  if (getLhs() == getRhs())
     return Builder(getContext()).getZeroAttr(getType());
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a ^ b; });
 }
 
 void arith::XOrIOp::getCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {

 
 //===----------------------------------------------------------------------===//
 // Verifiers for integer and floating point extension/truncation ops
 //===----------------------------------------------------------------------===//
 
 // Extend ops can only extend to a wider type.
 template <typename ValType, typename Op>
 static LogicalResult verifyExtOp(Op op) {
-  Type srcType = getElementTypeOrSelf(op.in().getType());
+  Type srcType = getElementTypeOrSelf(op.getIn().getType());
   Type dstType = getElementTypeOrSelf(op.getType());
 
   if (srcType.cast<ValType>().getWidth() >= dstType.cast<ValType>().getWidth())
     return op.emitError("result type ")
            << dstType << " must be wider than operand type " << srcType;
 
   return success();
 }
 
 // Truncate ops can only truncate to a shorter type.
 template <typename ValType, typename Op>
 static LogicalResult verifyTruncateOp(Op op) {
-  Type srcType = getElementTypeOrSelf(op.in().getType());
+  Type srcType = getElementTypeOrSelf(op.getIn().getType());
   Type dstType = getElementTypeOrSelf(op.getType());
 
   if (srcType.cast<ValType>().getWidth() <= dstType.cast<ValType>().getWidth())
     return op.emitError("result type ")
            << dstType << " must be shorter than operand type " << srcType;
 
   return success();
 }
static bool applyCmpPredicateToEqualOperands(arith::CmpIPredicate predicate) {
   }
   llvm_unreachable("unknown cmpi predicate kind");
 }
 
 OpFoldResult arith::CmpIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "cmpi takes two operands");
 
   // cmpi(pred, x, x)
-  if (lhs() == rhs()) {
+  if (getLhs() == getRhs()) {
     auto val = applyCmpPredicateToEqualOperands(getPredicate());
     return BoolAttr::get(getContext(), val);
   }
 
   auto lhs = operands.front().dyn_cast_or_null<IntegerAttr>();
   auto rhs = operands.back().dyn_cast_or_null<IntegerAttr>();
   if (!lhs || !rhs)
     return {};

mlir/lib/Dialect/Arithmetic/Transforms/Bufferize.cpp

 struct BufferizeIndexCastOp : public OpConversionPattern<arith::IndexCastOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(arith::IndexCastOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto tensorType = op.getType().cast<RankedTensorType>();
     rewriter.replaceOpWithNewOp<arith::IndexCastOp>(
-        op, adaptor.in(),
+        op, adaptor.getIn(),
         MemRefType::get(tensorType.getShape(), tensorType.getElementType()));
     return success();
   }
 };
 
 /// Pass to bufferize Arithmetic ops.
 struct ArithmeticBufferizePass
     : public ArithmeticBufferizeBase<ArithmeticBufferizePass> {

mlir/lib/Dialect/Arithmetic/Transforms/ExpandOps.cpp

 ///   2) (n*m>0) ? ((n+x) / m) + 1 : - (-n / m)
 struct CeilDivSIOpConverter : public OpRewritePattern<arith::CeilDivSIOp> {
   using OpRewritePattern::OpRewritePattern;
   LogicalResult matchAndRewrite(arith::CeilDivSIOp op,
                                 PatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
     auto signedCeilDivIOp = cast<arith::CeilDivSIOp>(op);
     Type type = signedCeilDivIOp.getType();
-    Value a = signedCeilDivIOp.lhs();
-    Value b = signedCeilDivIOp.rhs();
+    Value a = signedCeilDivIOp.getLhs();
+    Value b = signedCeilDivIOp.getRhs();
     Value plusOne = rewriter.create<arith::ConstantOp>(
         loc, rewriter.getIntegerAttr(type, 1));
     Value zero = rewriter.create<arith::ConstantOp>(
         loc, rewriter.getIntegerAttr(type, 0));
     Value minusOne = rewriter.create<arith::ConstantOp>(
         loc, rewriter.getIntegerAttr(type, -1));
     // Compute x = (b>0) ? -1 : 1.
     Value compare =

 ///   2)  return (n*m<0) ? - ((-n+x) / m) -1 : n / m
 struct FloorDivSIOpConverter : public OpRewritePattern<arith::FloorDivSIOp> {
   using OpRewritePattern::OpRewritePattern;
   LogicalResult matchAndRewrite(arith::FloorDivSIOp op,
                                 PatternRewriter &rewriter) const final {
     Location loc = op.getLoc();
     arith::FloorDivSIOp signedFloorDivIOp = cast<arith::FloorDivSIOp>(op);
     Type type = signedFloorDivIOp.getType();
-    Value a = signedFloorDivIOp.lhs();
-    Value b = signedFloorDivIOp.rhs();
+    Value a = signedFloorDivIOp.getLhs();
+    Value b = signedFloorDivIOp.getRhs();
     Value plusOne = rewriter.create<arith::ConstantOp>(
         loc, rewriter.getIntegerAttr(type, 1));
     Value zero = rewriter.create<arith::ConstantOp>(
         loc, rewriter.getIntegerAttr(type, 0));
     Value minusOne = rewriter.create<arith::ConstantOp>(
         loc, rewriter.getIntegerAttr(type, -1));
     // Compute x = (b<0) ? 1 : -1.
     Value compare =

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

if (outlined == outlinedFunctions.end())
       return rewriter.notifyMatchFailure(
           op, "operation is not inside the async coroutine function");
 
     Location loc = op->getLoc();
     CoroMachinery &coro = outlined->getSecond();
 
     Block *cont = rewriter.splitBlock(op->getBlock(), Block::iterator(op));
     rewriter.setInsertionPointToEnd(cont->getPrevNode());
-    rewriter.create<CondBranchOp>(loc, adaptor.arg(),
+    rewriter.create<CondBranchOp>(loc, adaptor.getArg(),
                                   /*trueDest=*/cont,
                                   /*trueArgs=*/ArrayRef<Value>(),
                                   /*falseDest=*/setupSetErrorBlock(coro),
                                   /*falseArgs=*/ArrayRef<Value>());
     rewriter.eraseOp(op);
 
     return success();
   }

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

static void printLLVMOpAttrs(OpAsmPrinter &printer, Operation *op,
                              DictionaryAttr attrs) {
   printer.printOptionalAttrDict(processFMFAttr(attrs.getValue()));
 }
 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::CmpOp.
 //===----------------------------------------------------------------------===//
 static void printICmpOp(OpAsmPrinter &p, ICmpOp &op) {
-  p << " \"" << stringifyICmpPredicate(op.predicate()) << "\" "
+  p << " \"" << stringifyICmpPredicate(op.getPredicate()) << "\" "
     << op.getOperand(0) << ", " << op.getOperand(1);
   p.printOptionalAttrDict(op->getAttrs(), {"predicate"});
-  p << " : " << op.lhs().getType();
+  p << " : " << op.getLhs().getType();
 }
 
 static void printFCmpOp(OpAsmPrinter &p, FCmpOp &op) {
-  p << " \"" << stringifyFCmpPredicate(op.predicate()) << "\" "
+  p << " \"" << stringifyFCmpPredicate(op.getPredicate()) << "\" "
     << op.getOperand(0) << ", " << op.getOperand(1);
   p.printOptionalAttrDict(processFMFAttr(op->getAttrs()), {"predicate"});
-  p << " : " << op.lhs().getType();
+  p << " : " << op.getLhs().getType();
 }
 
 // <operation> ::= `llvm.icmp` string-literal ssa-use `,` ssa-use
 //                 attribute-dict? `:` type
 // <operation> ::= `llvm.fcmp` string-literal ssa-use `,` ssa-use
 //                 attribute-dict? `:` type
 template <typename CmpPredicateType>
 static ParseResult parseCmpOp(OpAsmParser &parser, OperationState &result) {

 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::AllocaOp.
 //===----------------------------------------------------------------------===//
 
 static void printAllocaOp(OpAsmPrinter &p, AllocaOp &op) {
   auto elemTy = op.getType().cast<LLVM::LLVMPointerType>().getElementType();
 
-  auto funcTy = FunctionType::get(op.getContext(), {op.arraySize().getType()},
-                                  {op.getType()});
+  auto funcTy = FunctionType::get(
+      op.getContext(), {op.getArraySize().getType()}, {op.getType()});
 
-  p << ' ' << op.arraySize() << " x " << elemTy;
-  if (op.alignment().hasValue() && *op.alignment() != 0)
+  p << ' ' << op.getArraySize() << " x " << elemTy;
+  if (op.getAlignment().hasValue() && *op.getAlignment() != 0)
     p.printOptionalAttrDict(op->getAttrs());
   else
     p.printOptionalAttrDict(op->getAttrs(), {"alignment"});
   p << " : " << funcTy;
 }
 
 // <operation> ::= `llvm.alloca` ssa-use `x` type attribute-dict?
 //                 `:` type `,` type

 
 //===----------------------------------------------------------------------===//
 // LLVM::BrOp
 //===----------------------------------------------------------------------===//
 
 Optional<MutableOperandRange>
 BrOp::getMutableSuccessorOperands(unsigned index) {
   assert(index == 0 && "invalid successor index");
-  return destOperandsMutable();
+  return getDestOperandsMutable();
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM::CondBrOp
 //===----------------------------------------------------------------------===//
 
 Optional<MutableOperandRange>
 CondBrOp::getMutableSuccessorOperands(unsigned index) {
   assert(index < getNumSuccessors() && "invalid successor index");
-  return index == 0 ? trueDestOperandsMutable() : falseDestOperandsMutable();
+  return index == 0 ? getTrueDestOperandsMutable()
+                    : getFalseDestOperandsMutable();
 }
 
 //===----------------------------------------------------------------------===//
 // LLVM::SwitchOp
 //===----------------------------------------------------------------------===//
 
 void SwitchOp::build(OpBuilder &builder, OperationState &result, Value value,
                      Block *defaultDestination, ValueRange defaultOperands,
for (unsigned idx = 0, ie = op.getNumOperands(); idx < ie; idx++) {
     value = op.getOperand(idx);
     bool isFilter = value.getType().isa<LLVMArrayType>();
     if (isFilter) {
       // FIXME: Verify filter clauses when arrays are appropriately handled
     } else {
       // catch - global addresses only.
       // Bitcast ops should have global addresses as their args.
       if (auto bcOp = value.getDefiningOp<BitcastOp>()) {
-        if (auto addrOp = bcOp.arg().getDefiningOp<AddressOfOp>())
+        if (auto addrOp = bcOp.getArg().getDefiningOp<AddressOfOp>())
           continue;
         return op.emitError("constant clauses expected")
                    .attachNote(bcOp.getLoc())
                << "global addresses expected as operand to "
                   "bitcast used in clauses for landingpad";
       }
       // NullOp and AddressOfOp allowed
       if (value.getDefiningOp<NullOp>())
static LogicalResult verify(CallOp &op) {
 
   // Type for the callee, we'll get it differently depending if it is a direct
   // or indirect call.
   Type fnType;
 
   bool isIndirect = false;
 
   // If this is an indirect call, the callee attribute is missing.
-  FlatSymbolRefAttr calleeName = op.calleeAttr();
+  FlatSymbolRefAttr calleeName = op.getCalleeAttr();
   if (!calleeName) {
     isIndirect = true;
     if (!op.getNumOperands())
       return op.emitOpError(
           "must have either a `callee` attribute or at least an operand");
     auto ptrType = op.getOperand(0).getType().dyn_cast<LLVMPointerType>();
     if (!ptrType)
       return op.emitOpError("indirect call expects a pointer as callee: ")
if (op.getNumResults() &&
     return op.emitOpError()
            << "result type mismatch: " << op.getResult(0).getType()
            << " != " << funcType.getReturnType();
 
   return success();
 }
 
 static void printCallOp(OpAsmPrinter &p, CallOp &op) {
-  auto callee = op.callee();
+  auto callee = op.getCallee();
   bool isDirect = callee.hasValue();
 
   // Print the direct callee if present as a function attribute, or an indirect
   // callee (first operand) otherwise.
   p << ' ';
   if (isDirect)
     p.printSymbolName(callee.getValue());
   else
void LLVM::ExtractElementOp::build(OpBuilder &b, OperationState &result,
                                    ArrayRef<NamedAttribute> attrs) {
   auto vectorType = vector.getType();
   auto llvmType = LLVM::getVectorElementType(vectorType);
   build(b, result, llvmType, vector, position);
   result.addAttributes(attrs);
 }
 
 static void printExtractElementOp(OpAsmPrinter &p, ExtractElementOp &op) {
-  p << ' ' << op.vector() << "[" << op.position() << " : "
-    << op.position().getType() << "]";
+  p << ' ' << op.getVector() << "[" << op.getPosition() << " : "
+    << op.getPosition().getType() << "]";
   p.printOptionalAttrDict(op->getAttrs());
-  p << " : " << op.vector().getType();
+  p << " : " << op.getVector().getType();
 }
 
 // <operation> ::= `llvm.extractelement` ssa-use `, ` ssa-use
 //                 attribute-dict? `:` type
 static ParseResult parseExtractElementOp(OpAsmParser &parser,
                                          OperationState &result) {
   llvm::SMLoc loc;
   OpAsmParser::OperandType vector, position;
static ParseResult parseExtractElementOp(OpAsmParser &parser,
   if (!LLVM::isCompatibleVectorType(type))
     return parser.emitError(
         loc, "expected LLVM dialect-compatible vector type for operand #1");
   result.addTypes(LLVM::getVectorElementType(type));
   return success();
 }
 
 static LogicalResult verify(ExtractElementOp op) {
-  Type vectorType = op.vector().getType();
+  Type vectorType = op.getVector().getType();
   if (!LLVM::isCompatibleVectorType(vectorType))
     return op->emitOpError("expected LLVM dialect-compatible vector type for "
                            "operand #1, got")
            << vectorType;
   Type valueType = LLVM::getVectorElementType(vectorType);
-  if (valueType != op.res().getType())
+  if (valueType != op.getRes().getType())
     return op.emitOpError() << "Type mismatch: extracting from " << vectorType
                             << " should produce " << valueType
-                            << " but this op returns " << op.res().getType();
+                            << " but this op returns " << op.getRes().getType();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::ExtractValueOp.
 //===----------------------------------------------------------------------===//
 
 static void printExtractValueOp(OpAsmPrinter &p, ExtractValueOp &op) {
-  p << ' ' << op.container() << op.position();
+  p << ' ' << op.getContainer() << op.getPosition();
   p.printOptionalAttrDict(op->getAttrs(), {"position"});
-  p << " : " << op.container().getType();
+  p << " : " << op.getContainer().getType();
 }
 
 // Extract the type at `position` in the wrapped LLVM IR aggregate type
 // `containerType`.  Position is an integer array attribute where each value
 // is a zero-based position of the element in the aggregate type.  Return the
 // resulting type wrapped in MLIR, or nullptr on error.
 static Type getInsertExtractValueElementType(OpAsmParser &parser,
                                              Type containerType,
static ParseResult parseExtractValueOp(OpAsmParser &parser,
   if (!elementType)
     return failure();
 
   result.addTypes(elementType);
   return success();
 }
 
 OpFoldResult LLVM::ExtractValueOp::fold(ArrayRef<Attribute> operands) {
-  auto insertValueOp = container().getDefiningOp<InsertValueOp>();
+  auto insertValueOp = getContainer().getDefiningOp<InsertValueOp>();
   while (insertValueOp) {
-    if (position() == insertValueOp.position())
+    if (getPosition() == insertValueOp.position())
       return insertValueOp.value();
     insertValueOp = insertValueOp.container().getDefiningOp<InsertValueOp>();
   }
   return {};
 }
 
 static LogicalResult verify(ExtractValueOp op) {
-  Type valueType = getInsertExtractValueElementType(op.container().getType(),
-                                                    op.positionAttr(), op);
+  Type valueType = getInsertExtractValueElementType(op.getContainer().getType(),
+                                                    op.getPositionAttr(), op);
   if (!valueType)
     return failure();
 
-  if (op.res().getType() != valueType)
+  if (op.getRes().getType() != valueType)
     return op.emitOpError()
-           << "Type mismatch: extracting from " << op.container().getType()
+           << "Type mismatch: extracting from " << op.getContainer().getType()
            << " should produce " << valueType << " but this op returns "
-           << op.res().getType();
+           << op.getRes().getType();
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printing/parsing for LLVM::InsertElementOp.
 //===----------------------------------------------------------------------===//
 
 static void printInsertElementOp(OpAsmPrinter &p, InsertElementOp &op) {
while (module && !satisfiesLLVMModule(module))
     module = module->getParentOp();
   assert(module && "unexpected operation outside of a module");
   return dyn_cast_or_null<OpTy>(
       mlir::SymbolTable::lookupSymbolIn(module, name));
 }
 
 GlobalOp AddressOfOp::getGlobal() {
   return lookupSymbolInModule<LLVM::GlobalOp>((*this)->getParentOp(),
-                                              global_name());
+                                              getGlobalName());
 }
 
 LLVMFuncOp AddressOfOp::getFunction() {
   return lookupSymbolInModule<LLVM::LLVMFuncOp>((*this)->getParentOp(),
-                                                global_name());
+                                                getGlobalName());
 }
 
 static LogicalResult verify(AddressOfOp op) {
   auto global = op.getGlobal();
   auto function = op.getFunction();
   if (!global && !function)
     return op.emitOpError(
         "must reference a global defined by 'llvm.mlir.global' or 'llvm.func'");
 
   if (global &&
-      LLVM::LLVMPointerType::get(global.getType(), global.addr_space()) !=
+      LLVM::LLVMPointerType::get(global.getType(), global.getAddrSpace()) !=
           op.getResult().getType())
     return op.emitOpError(
         "the type must be a pointer to the type of the referenced global");
 
   if (function && LLVM::LLVMPointerType::get(function.getType()) !=
                       op.getResult().getType())
     return op.emitOpError(
         "the type must be a pointer to the type of the referenced function");
if (dsoLocal)
     result.addAttribute("dso_local", builder.getUnitAttr());
 
   // Only add an alignment attribute if the "alignment" input
   // is different from 0. The value must also be a power of two, but
   // this is tested in GlobalOp::verify, not here.
   if (alignment != 0)
     result.addAttribute("alignment", builder.getI64IntegerAttr(alignment));
 
-  result.addAttribute(getLinkageAttrName(),
+  result.addAttribute(::getLinkageAttrName(),
                       LinkageAttr::get(builder.getContext(), linkage));
   if (addrSpace != 0)
     result.addAttribute("addr_space", builder.getI32IntegerAttr(addrSpace));
   result.attributes.append(attrs.begin(), attrs.end());
   result.addRegion();
 }
 
 static void printGlobalOp(OpAsmPrinter &p, GlobalOp op) {
-  p << ' ' << stringifyLinkage(op.linkage()) << ' ';
-  if (auto unnamedAddr = op.unnamed_addr()) {
+  p << ' ' << stringifyLinkage(op.getLinkage()) << ' ';
+  if (auto unnamedAddr = op.getUnnamedAddr()) {
     StringRef str = stringifyUnnamedAddr(*unnamedAddr);
     if (!str.empty())
       p << str << ' ';
   }
-  if (op.constant())
+  if (op.getConstant())
     p << "constant ";
-  p.printSymbolName(op.sym_name());
+  p.printSymbolName(op.getSymName());
   p << '(';
   if (auto value = op.getValueOrNull())
     p.printAttribute(value);
   p << ')';
   // Note that the alignment attribute is printed using the
   // default syntax here, even though it is an inherent attribute
   // (as defined in https://mlir.llvm.org/docs/LangRef/#attributes)
   p.printOptionalAttrDict(op->getAttrs(),
                           {SymbolTable::getSymbolAttrName(), "global_type",
                            "constant", "value", getLinkageAttrName(),
                            getUnnamedAddrAttrName()});
 
   // Print the trailing type unless it's a string global.
   if (op.getValueOrNull().dyn_cast_or_null<StringAttr>())
     return;
-  p << " : " << op.global_type();
+  p << " : " << op.getType();
 
   Region &initializer = op.getInitializerRegion();
   if (!initializer.empty())
     p.printRegion(initializer, /*printEntryBlockArgs=*/false);
 }
 
 // Parses one of the keywords provided in the list `keywords` and returns the
 // position of the parsed keyword in the list. If none of the keywords from the
if (*ret.operand_type_begin() != op.getType())
       return op.emitOpError("initializer region type ")
              << *ret.operand_type_begin() << " does not match global type "
              << op.getType();
 
     if (op.getValueOrNull())
       return op.emitOpError("cannot have both initializer value and region");
   }
 
-  if (op.linkage() == Linkage::Common) {
+  if (op.getLinkage() == Linkage::Common) {
     if (Attribute value = op.getValueOrNull()) {
       if (!isZeroAttribute(value)) {
         return op.emitOpError()
                << "expected zero value for '"
                << stringifyLinkage(Linkage::Common) << "' linkage";
       }
     }
   }
 
-  if (op.linkage() == Linkage::Appending) {
+  if (op.getLinkage() == Linkage::Appending) {
     if (!op.getType().isa<LLVMArrayType>()) {
       return op.emitOpError()
              << "expected array type for '"
              << stringifyLinkage(Linkage::Appending) << "' linkage";
     }
   }
 
-  Optional<uint64_t> alignAttr = op.alignment();
+  Optional<uint64_t> alignAttr = op.getAlignment();
   if (alignAttr.hasValue()) {
     uint64_t value = alignAttr.getValue();
     if (!llvm::isPowerOf2_64(value))
       return op->emitError() << "alignment attribute is not a power of 2";
   }
 
   return success();
 }

 void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
                        StringRef name, Type type, LLVM::Linkage linkage,
                        bool dsoLocal, ArrayRef<NamedAttribute> attrs,
                        ArrayRef<DictionaryAttr> argAttrs) {
   result.addRegion();
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute("type", TypeAttr::get(type));
-  result.addAttribute(getLinkageAttrName(),
+  result.addAttribute(::getLinkageAttrName(),
                       LinkageAttr::get(builder.getContext(), linkage));
   result.attributes.append(attrs.begin(), attrs.end());
   if (dsoLocal)
     result.addAttribute("dso_local", builder.getUnitAttr());
   if (argAttrs.empty())
     return;
 
   assert(type.cast<LLVMFunctionType>().getNumParams() == argAttrs.size() &&
static LogicalResult verify(LLVMFuncOp op) {
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Verification for LLVM::ConstantOp.
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(LLVM::ConstantOp op) {
-  if (StringAttr sAttr = op.value().dyn_cast<StringAttr>()) {
+  if (StringAttr sAttr = op.getValue().dyn_cast<StringAttr>()) {
     auto arrayType = op.getType().dyn_cast<LLVMArrayType>();
     if (!arrayType || arrayType.getNumElements() != sAttr.getValue().size() ||
         !arrayType.getElementType().isInteger(8)) {
       return op->emitOpError()
              << "expected array type of " << sAttr.getValue().size()
              << " i8 elements for the string constant";
     }
     return success();
   }
   if (auto structType = op.getType().dyn_cast<LLVMStructType>()) {
     if (structType.getBody().size() != 2 ||
         structType.getBody()[0] != structType.getBody()[1]) {
       return op.emitError() << "expected struct type with two elements of the "
                                "same type, the type of a complex constant";
     }
 
-    auto arrayAttr = op.value().dyn_cast<ArrayAttr>();
+    auto arrayAttr = op.getValue().dyn_cast<ArrayAttr>();
     if (!arrayAttr || arrayAttr.size() != 2 ||
         arrayAttr[0].getType() != arrayAttr[1].getType()) {
       return op.emitOpError() << "expected array attribute with two elements, "
                                  "representing a complex constant";
     }
 
     Type elementType = structType.getBody()[0];
     if (!elementType
              .isa<IntegerType, Float16Type, Float32Type, Float64Type>()) {
       return op.emitError()
              << "expected struct element types to be floating point type or "
                 "integer type";
     }
     return success();
   }
-  if (!op.value().isa<IntegerAttr, ArrayAttr, FloatAttr, ElementsAttr>())
+  if (!op.getValue().isa<IntegerAttr, ArrayAttr, FloatAttr, ElementsAttr>())
     return op.emitOpError()
            << "only supports integer, float, string or elements attributes";
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Utility functions for parsing atomic ops
 //===----------------------------------------------------------------------===//
static ParseResult parseAtomicOrdering(OpAsmParser &parser,
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printer, parser and verifier for LLVM::AtomicRMWOp.
 //===----------------------------------------------------------------------===//
 
 static void printAtomicRMWOp(OpAsmPrinter &p, AtomicRMWOp &op) {
-  p << ' ' << stringifyAtomicBinOp(op.bin_op()) << ' ' << op.ptr() << ", "
-    << op.val() << ' ' << stringifyAtomicOrdering(op.ordering()) << ' ';
+  p << ' ' << stringifyAtomicBinOp(op.getBinOp()) << ' ' << op.getPtr() << ", "
+    << op.getVal() << ' ' << stringifyAtomicOrdering(op.getOrdering()) << ' ';
   p.printOptionalAttrDict(op->getAttrs(), {"bin_op", "ordering"});
-  p << " : " << op.res().getType();
+  p << " : " << op.getRes().getType();
 }
 
 // <operation> ::= `llvm.atomicrmw` keyword ssa-use `,` ssa-use keyword
 //                 attribute-dict? `:` type
 static ParseResult parseAtomicRMWOp(OpAsmParser &parser,
                                     OperationState &result) {
   Type type;
   OpAsmParser::OperandType ptr, val;
   if (parseAtomicBinOp(parser, result, "bin_op") || parser.parseOperand(ptr) ||
       parser.parseComma() || parser.parseOperand(val) ||
       parseAtomicOrdering(parser, result, "ordering") ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(type) ||
       parser.resolveOperand(ptr, LLVM::LLVMPointerType::get(type),
                             result.operands) ||
       parser.resolveOperand(val, type, result.operands))
     return failure();
 
   result.addTypes(type);
   return success();
 }
 
 static LogicalResult verify(AtomicRMWOp op) {
-  auto ptrType = op.ptr().getType().cast<LLVM::LLVMPointerType>();
-  auto valType = op.val().getType();
+  auto ptrType = op.getPtr().getType().cast<LLVM::LLVMPointerType>();
+  auto valType = op.getVal().getType();
   if (valType != ptrType.getElementType())
     return op.emitOpError("expected LLVM IR element type for operand #0 to "
                           "match type for operand #1");
-  auto resType = op.res().getType();
+  auto resType = op.getRes().getType();
   if (resType != valType)
     return op.emitOpError(
         "expected LLVM IR result type to match type for operand #1");
-  if (op.bin_op() == AtomicBinOp::fadd || op.bin_op() == AtomicBinOp::fsub) {
+  if (op.getBinOp() == AtomicBinOp::fadd ||
+      op.getBinOp() == AtomicBinOp::fsub) {
     if (!mlir::LLVM::isCompatibleFloatingPointType(valType))
       return op.emitOpError("expected LLVM IR floating point type");
-  } else if (op.bin_op() == AtomicBinOp::xchg) {
+  } else if (op.getBinOp() == AtomicBinOp::xchg) {
     auto intType = valType.dyn_cast<IntegerType>();
     unsigned intBitWidth = intType ? intType.getWidth() : 0;
     if (intBitWidth != 8 && intBitWidth != 16 && intBitWidth != 32 &&
         intBitWidth != 64 && !valType.isa<BFloat16Type>() &&
         !valType.isa<Float16Type>() && !valType.isa<Float32Type>() &&
         !valType.isa<Float64Type>())
       return op.emitOpError("unexpected LLVM IR type for 'xchg' bin_op");
   } else {
     auto intType = valType.dyn_cast<IntegerType>();
     unsigned intBitWidth = intType ? intType.getWidth() : 0;
     if (intBitWidth != 8 && intBitWidth != 16 && intBitWidth != 32 &&
         intBitWidth != 64)
       return op.emitOpError("expected LLVM IR integer type");
   }
 
-  if (static_cast<unsigned>(op.ordering()) <
+  if (static_cast<unsigned>(op.getOrdering()) <
       static_cast<unsigned>(AtomicOrdering::monotonic))
     return op.emitOpError()
            << "expected at least '"
            << stringifyAtomicOrdering(AtomicOrdering::monotonic)
            << "' ordering";
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printer, parser and verifier for LLVM::AtomicCmpXchgOp.
 //===----------------------------------------------------------------------===//
 
 static void printAtomicCmpXchgOp(OpAsmPrinter &p, AtomicCmpXchgOp &op) {
-  p << ' ' << op.ptr() << ", " << op.cmp() << ", " << op.val() << ' '
-    << stringifyAtomicOrdering(op.success_ordering()) << ' '
-    << stringifyAtomicOrdering(op.failure_ordering());
+  p << ' ' << op.getPtr() << ", " << op.getCmp() << ", " << op.getVal() << ' '
+    << stringifyAtomicOrdering(op.getSuccessOrdering()) << ' '
+    << stringifyAtomicOrdering(op.getFailureOrdering());
   p.printOptionalAttrDict(op->getAttrs(),
                           {"success_ordering", "failure_ordering"});
-  p << " : " << op.val().getType();
+  p << " : " << op.getVal().getType();
 }
 
 // <operation> ::= `llvm.cmpxchg` ssa-use `,` ssa-use `,` ssa-use
 //                 keyword keyword attribute-dict? `:` type
 static ParseResult parseAtomicCmpXchgOp(OpAsmParser &parser,
                                         OperationState &result) {
   auto &builder = parser.getBuilder();
   Type type;
static ParseResult parseAtomicCmpXchgOp(OpAsmParser &parser,
   auto resultType =
       LLVMStructType::getLiteral(builder.getContext(), {type, boolType});
   result.addTypes(resultType);
 
   return success();
 }
 
 static LogicalResult verify(AtomicCmpXchgOp op) {
-  auto ptrType = op.ptr().getType().cast<LLVM::LLVMPointerType>();
+  auto ptrType = op.getPtr().getType().cast<LLVM::LLVMPointerType>();
   if (!ptrType)
     return op.emitOpError("expected LLVM IR pointer type for operand #0");
-  auto cmpType = op.cmp().getType();
-  auto valType = op.val().getType();
+  auto cmpType = op.getCmp().getType();
+  auto valType = op.getVal().getType();
   if (cmpType != ptrType.getElementType() || cmpType != valType)
     return op.emitOpError("expected LLVM IR element type for operand #0 to "
                           "match type for all other operands");
   auto intType = valType.dyn_cast<IntegerType>();
   unsigned intBitWidth = intType ? intType.getWidth() : 0;
   if (!valType.isa<LLVMPointerType>() && intBitWidth != 8 &&
       intBitWidth != 16 && intBitWidth != 32 && intBitWidth != 64 &&
       !valType.isa<BFloat16Type>() && !valType.isa<Float16Type>() &&
       !valType.isa<Float32Type>() && !valType.isa<Float64Type>())
     return op.emitOpError("unexpected LLVM IR type");
-  if (op.success_ordering() < AtomicOrdering::monotonic ||
-      op.failure_ordering() < AtomicOrdering::monotonic)
+  if (op.getSuccessOrdering() < AtomicOrdering::monotonic ||
+      op.getFailureOrdering() < AtomicOrdering::monotonic)
     return op.emitOpError("ordering must be at least 'monotonic'");
-  if (op.failure_ordering() == AtomicOrdering::release ||
-      op.failure_ordering() == AtomicOrdering::acq_rel)
+  if (op.getFailureOrdering() == AtomicOrdering::release ||
+      op.getFailureOrdering() == AtomicOrdering::acq_rel)
     return op.emitOpError("failure ordering cannot be 'release' or 'acq_rel'");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // Printer, parser and verifier for LLVM::FenceOp.
 //===----------------------------------------------------------------------===//
 
static ParseResult parseFenceOp(OpAsmParser &parser, OperationState &result) {
   return success();
 }
 
 static void printFenceOp(OpAsmPrinter &p, FenceOp &op) {
   StringRef syncscopeKeyword = "syncscope";
   p << ' ';
   if (!op->getAttr(syncscopeKeyword).cast<StringAttr>().getValue().empty())
     p << "syncscope(" << op->getAttr(syncscopeKeyword) << ") ";
-  p << stringifyAtomicOrdering(op.ordering());
+  p << stringifyAtomicOrdering(op.getOrdering());
 }
 
 static LogicalResult verify(FenceOp &op) {
-  if (op.ordering() == AtomicOrdering::not_atomic ||
-      op.ordering() == AtomicOrdering::unordered ||
-      op.ordering() == AtomicOrdering::monotonic)
+  if (op.getOrdering() == AtomicOrdering::not_atomic ||
+      op.getOrdering() == AtomicOrdering::unordered ||
+      op.getOrdering() == AtomicOrdering::monotonic)
     return op.emitOpError("can be given only acquire, release, acq_rel, "
                           "and seq_cst orderings");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // LLVMDialect initialization, type parsing, and registration.
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Linalg/Transforms/Hoisting.cpp

 } // namespace
 
 /// Return true if op1 and op2 are the same constant or the same SSA value.
 static bool isEqualOffsetSizeOrStride(OpFoldResult op1, OpFoldResult op2) {
   auto getConstantIntValue = [](OpFoldResult ofr) -> llvm::Optional<int64_t> {
     Attribute attr = ofr.dyn_cast<Attribute>();
     // Note: isa+cast-like pattern allows writing the condition below as 1 line.
     if (!attr && ofr.get<Value>().getDefiningOp<arith::ConstantOp>())
-      attr = ofr.get<Value>().getDefiningOp<arith::ConstantOp>().value();
+      attr = ofr.get<Value>().getDefiningOp<arith::ConstantOp>().getValue();
     if (auto intAttr = attr.dyn_cast_or_null<IntegerAttr>())
       return intAttr.getValue().getSExtValue();
     return llvm::None;
   };
   auto cst1 = getConstantIntValue(op1), cst2 = getConstantIntValue(op2);
   if (cst1 && cst2 && *cst1 == *cst2)
     return true;
   auto v1 = op1.dyn_cast<Value>(), v2 = op2.dyn_cast<Value>();

mlir/lib/Dialect/Linalg/Utils/Utils.cpp

IntegerAttr getSmallestBoundingIndex(Value size) {
   if (auto affineMinOp = size.getDefiningOp<AffineMinOp>()) {
     for (auto e : affineMinOp.getAffineMap().getResults())
       if (auto cst = e.dyn_cast<AffineConstantExpr>())
         boundingConst = boundingConst
                             ? std::min(boundingConst.getValue(), cst.getValue())
                             : cst.getValue();
   } else if (auto constIndexOp = size.getDefiningOp<arith::ConstantOp>()) {
     if (constIndexOp.getType().isa<IndexType>())
-      boundingConst = constIndexOp.value().cast<IntegerAttr>().getInt();
+      boundingConst = constIndexOp.getValue().cast<IntegerAttr>().getInt();
   } else if (auto affineApplyOp = size.getDefiningOp<AffineApplyOp>()) {
     if (auto cExpr = affineApplyOp.getAffineMap()
                          .getResult(0)
                          .dyn_cast<AffineConstantExpr>())
       boundingConst = cExpr.getValue();
   } else if (auto dimOp = size.getDefiningOp<tensor::DimOp>()) {
     auto shape = dimOp.source().getType().dyn_cast<ShapedType>();
     if (auto constOp = dimOp.index().getDefiningOp<arith::ConstantOp>()) {
-      if (auto indexAttr = constOp.value().dyn_cast<IntegerAttr>()) {
+      if (auto indexAttr = constOp.getValue().dyn_cast<IntegerAttr>()) {
         auto dimIndex = indexAttr.getInt();
         if (!shape.isDynamicDim(dimIndex)) {
           boundingConst = shape.getShape()[dimIndex];
         }
       }
     }
   }
   if (boundingConst && *boundingConst >= 0)

mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp

 void DimOp::build(OpBuilder &builder, OperationState &result, Value source,
                   Value index) {
   auto indexTy = builder.getIndexType();
   build(builder, result, indexTy, source, index);
 }
 
 Optional<int64_t> DimOp::getConstantIndex() {
   if (auto constantOp = index().getDefiningOp<arith::ConstantOp>())
-    return constantOp.value().cast<IntegerAttr>().getInt();
+    return constantOp.getValue().cast<IntegerAttr>().getInt();
   return {};
 }
 
 static LogicalResult verify(DimOp op) {
   // Assume unknown index to be in range.
   Optional<int64_t> index = op.getConstantIndex();
   if (!index.hasValue())
     return success();

mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp

struct RemoveConstantIfCondition : public OpRewritePattern<OpTy> {
 
   LogicalResult matchAndRewrite(OpTy op,
                                 PatternRewriter &rewriter) const override {
     // Early return if there is no condition.
     if (!op.ifCond())
       return success();
 
     auto constOp = op.ifCond().template getDefiningOp<arith::ConstantOp>();
-    if (constOp && constOp.value().template cast<IntegerAttr>().getInt())
+    if (constOp && constOp.getValue().template cast<IntegerAttr>().getInt())
       rewriter.updateRootInPlace(op, [&]() { op.ifCondMutable().erase(0); });
     else if (constOp)
       rewriter.eraseOp(op);
 
     return success();
   }
 };
 } // namespace

mlir/lib/Dialect/SCF/SCF.cpp

LogicalResult matchAndRewrite(ForOp op,
     }
 
     auto lb = op.lowerBound().getDefiningOp<arith::ConstantOp>();
     auto ub = op.upperBound().getDefiningOp<arith::ConstantOp>();
     if (!lb || !ub)
       return failure();
 
     // If the loop is known to have 0 iterations, remove it.
-    llvm::APInt lbValue = lb.value().cast<IntegerAttr>().getValue();
-    llvm::APInt ubValue = ub.value().cast<IntegerAttr>().getValue();
+    llvm::APInt lbValue = lb.getValue().cast<IntegerAttr>().getValue();
+    llvm::APInt ubValue = ub.getValue().cast<IntegerAttr>().getValue();
     if (lbValue.sge(ubValue)) {
       rewriter.replaceOp(op, op.getIterOperands());
       return success();
     }
 
     auto step = op.step().getDefiningOp<arith::ConstantOp>();
     if (!step)
       return failure();
 
     // If the loop is known to have 1 iteration, inline its body and remove the
     // loop.
-    llvm::APInt stepValue = step.value().cast<IntegerAttr>().getValue();
+    llvm::APInt stepValue = step.getValue().cast<IntegerAttr>().getValue();
     if ((lbValue + stepValue).sge(ubValue)) {
       SmallVector<Value, 4> blockArgs;
       blockArgs.reserve(op.getNumIterOperands() + 1);
       blockArgs.push_back(op.lowerBound());
       llvm::append_range(blockArgs, op.getIterOperands());
       replaceOpWithRegion(rewriter, op, op.getLoopBody(), blockArgs);
       return success();
     }
struct RemoveStaticCondition : public OpRewritePattern<IfOp> {
   using OpRewritePattern<IfOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(IfOp op,
                                 PatternRewriter &rewriter) const override {
     auto constant = op.condition().getDefiningOp<arith::ConstantOp>();
     if (!constant)
       return failure();
 
-    if (constant.value().cast<BoolAttr>().getValue())
+    if (constant.getValue().cast<BoolAttr>().getValue())
       replaceOpWithRegion(rewriter, op, op.thenRegion());
     else if (!op.elseRegion().empty())
       replaceOpWithRegion(rewriter, op, op.elseRegion());
     else
       rewriter.eraseOp(op);
 
     return success();
   }
for (auto tup :
 
       if (!trueYield.getType().isInteger(1))
         continue;
 
       auto falseYield = falseResult.getDefiningOp<arith::ConstantOp>();
       if (!falseYield)
         continue;
 
-      bool trueVal = trueYield.value().cast<BoolAttr>().getValue();
-      bool falseVal = falseYield.value().cast<BoolAttr>().getValue();
+      bool trueVal = trueYield.getValue().cast<BoolAttr>().getValue();
+      bool falseVal = falseYield.getValue().cast<BoolAttr>().getValue();
       if (!trueVal && falseVal) {
         if (!opResult.use_empty()) {
           Value notCond = rewriter.create<arith::XOrIOp>(
               op.getLoc(), op.condition(),
               rewriter.create<arith::ConstantOp>(
                   op.getLoc(), i1Ty, rewriter.getIntegerAttr(i1Ty, 1)));
           opResult.replaceAllUsesWith(notCond);
           changed = true;

mlir/lib/Dialect/Shape/IR/Shape.cpp

 bool shape::isExtentTensorType(Type type) {
   auto ranked = type.dyn_cast<RankedTensorType>();
   return ranked && ranked.getRank() == 1 && ranked.getElementType().isIndex();
 }
 
 LogicalResult shape::getShapeVec(Value input,
                                  SmallVectorImpl<int64_t> &shapeValues) {
   if (auto inputOp = input.getDefiningOp<ShapeOfOp>()) {
-    auto type = inputOp.arg().getType().dyn_cast<ShapedType>();
+    auto type = inputOp.getArg().getType().dyn_cast<ShapedType>();
     if (!type.hasRank())
       return failure();
     shapeValues = llvm::to_vector<6>(type.getShape());
     return success();
   } else if (auto inputOp = input.getDefiningOp<ConstShapeOp>()) {
-    shapeValues = llvm::to_vector<6>(inputOp.shape().getValues<int64_t>());
+    shapeValues = llvm::to_vector<6>(inputOp.getShape().getValues<int64_t>());
     return success();
   } else if (auto inputOp = input.getDefiningOp<arith::ConstantOp>()) {
     shapeValues = llvm::to_vector<6>(
-        inputOp.value().cast<DenseIntElementsAttr>().getValues<int64_t>());
+        inputOp.getValue().cast<DenseIntElementsAttr>().getValues<int64_t>());
     return success();
   } else {
     return failure();
   }
 }
 
 static bool isErrorPropagationPossible(TypeRange operandTypes) {
   return llvm::any_of(operandTypes, [](Type ty) {
if (auto arr = attribute.second.dyn_cast<ArrayAttr>()) {
           return op->emitError(
               "only SymbolRefAttr allowed in shape.lib attribute array");
 
         auto shapeFnLib = dyn_cast<shape::FunctionLibraryOp>(
             SymbolTable::lookupSymbolIn(op, it.cast<SymbolRefAttr>()));
         if (!shapeFnLib)
           return op->emitError()
                  << it << " does not refer to FunctionLibraryOp";
-        for (auto mapping : shapeFnLib.mapping()) {
+        for (auto mapping : shapeFnLib.getMapping()) {
           if (!key.insert(mapping.first).second) {
             return op->emitError("only one op to shape mapping allowed, found "
                                  "multiple for `")
                    << mapping.first << "`";
           }
         }
       }
       return success();
static ParseResult parseAssumingOp(OpAsmParser &parser,
 
   // Parse the optional attribute list.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
   return success();
 }
 
 static void print(OpAsmPrinter &p, AssumingOp op) {
-  bool yieldsResults = !op.results().empty();
+  bool yieldsResults = !op.getResults().empty();
 
-  p << " " << op.witness();
+  p << " " << op.getWitness();
   if (yieldsResults) {
     p << " -> (" << op.getResultTypes() << ")";
   }
-  p.printRegion(op.doRegion(),
+  p.printRegion(op.getDoRegion(),
                 /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/yieldsResults);
   p.printOptionalAttrDict(op->getAttrs());
 }
 
 namespace {
 // Removes AssumingOp with a passing witness and inlines the region.
 struct AssumingWithTrue : public OpRewritePattern<AssumingOp> {
   using OpRewritePattern<AssumingOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AssumingOp op,
                                 PatternRewriter &rewriter) const override {
-    auto witness = op.witness().getDefiningOp<ConstWitnessOp>();
-    if (!witness || !witness.passingAttr())
+    auto witness = op.getWitness().getDefiningOp<ConstWitnessOp>();
+    if (!witness || !witness.getPassingAttr())
       return failure();
 
     AssumingOp::inlineRegionIntoParent(op, rewriter);
     return success();
   }
 };
 
 struct AssumingOpRemoveUnusedResults : public OpRewritePattern<AssumingOp> {
   using OpRewritePattern<AssumingOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AssumingOp op,
                                 PatternRewriter &rewriter) const override {
     Block *body = op.getBody();
     auto yieldOp = llvm::cast<AssumingYieldOp>(body->getTerminator());
 
     // Find used values.
     SmallVector<Value, 4> newYieldOperands;
     Value opResult, yieldOperand;
-    for (auto it : llvm::zip(op.getResults(), yieldOp.operands())) {
+    for (auto it : llvm::zip(op.getResults(), yieldOp.getOperands())) {
       std::tie(opResult, yieldOperand) = it;
       if (!opResult.getUses().empty()) {
         newYieldOperands.push_back(yieldOperand);
       }
     }
 
     // Rewrite only if redundant results exist.
     if (newYieldOperands.size() == yieldOp->getNumOperands())
       return failure();
 
     // Replace yield op in the old assuming op's body and move the entire region
     // to the new assuming op.
     rewriter.setInsertionPointToEnd(body);
     auto newYieldOp =
         rewriter.replaceOpWithNewOp<AssumingYieldOp>(yieldOp, newYieldOperands);
     rewriter.setInsertionPoint(op);
     auto newOp = rewriter.create<AssumingOp>(
-        op.getLoc(), newYieldOp->getOperandTypes(), op.witness());
-    newOp.doRegion().takeBody(op.doRegion());
+        op.getLoc(), newYieldOp->getOperandTypes(), op.getWitness());
+    newOp.getDoRegion().takeBody(op.getDoRegion());
 
     // Use the new results to replace the previously used ones.
     SmallVector<Value, 4> replacementValues;
     auto src = newOp.getResults().begin();
     for (auto it : op.getResults()) {
       if (it.getUses().empty())
         replacementValues.push_back(nullptr);
       else
void AssumingOp::getSuccessorRegions(
   // AssumingOp has unconditional control flow into the region and back to the
   // parent, so return the correct RegionSuccessor purely based on the index
   // being None or 0.
   if (index.hasValue()) {
     regions.push_back(RegionSuccessor(getResults()));
     return;
   }
 
-  regions.push_back(RegionSuccessor(&doRegion()));
+  regions.push_back(RegionSuccessor(&getDoRegion()));
 }
 
 void AssumingOp::inlineRegionIntoParent(AssumingOp &op,
                                         PatternRewriter &rewriter) {
   auto *blockBeforeAssuming = rewriter.getInsertionBlock();
   auto *assumingBlock = op.getBody();
   auto initPosition = rewriter.getInsertionPoint();
   auto *blockAfterAssuming =
       rewriter.splitBlock(blockBeforeAssuming, initPosition);
 
   // Remove the AssumingOp and AssumingYieldOp.
   auto &yieldOp = assumingBlock->back();
-  rewriter.inlineRegionBefore(op.doRegion(), blockAfterAssuming);
+  rewriter.inlineRegionBefore(op.getDoRegion(), blockAfterAssuming);
   rewriter.replaceOp(op, yieldOp.getOperands());
   rewriter.eraseOp(&yieldOp);
 
   // Merge blocks together as there was no branching behavior from the
   // AssumingOp.
   rewriter.mergeBlocks(assumingBlock, blockBeforeAssuming);
   rewriter.mergeBlocks(blockAfterAssuming, blockBeforeAssuming);
 }

 
 bool mlir::shape::AddOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // SizeType is compatible with IndexType.
   return eachHasOnlyOneOfTypes<SizeType, IndexType>(l, r);
 }
 
 OpFoldResult mlir::shape::AddOp::fold(ArrayRef<Attribute> operands) {
   // add(x, 0) -> x
-  if (matchPattern(rhs(), m_Zero()))
-    return lhs();
+  if (matchPattern(getRhs(), m_Zero()))
+    return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a + b; });
 }
 
 //===----------------------------------------------------------------------===//
 // AssumingAllOp
 //===----------------------------------------------------------------------===//
 
 namespace {
 struct AssumingAllToCstrEqCanonicalization
     : public OpRewritePattern<AssumingAllOp> {
   using OpRewritePattern<AssumingAllOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AssumingAllOp op,
                                 PatternRewriter &rewriter) const override {
     SmallVector<Value, 8> shapes;
-    for (Value w : op.inputs()) {
+    for (Value w : op.getInputs()) {
       auto cstrEqOp = w.getDefiningOp<CstrEqOp>();
       if (!cstrEqOp)
         return failure();
-      bool disjointShapes = llvm::none_of(cstrEqOp.shapes(), [&](Value s) {
+      bool disjointShapes = llvm::none_of(cstrEqOp.getShapes(), [&](Value s) {
         return llvm::is_contained(shapes, s);
       });
-      if (!shapes.empty() && !cstrEqOp.shapes().empty() && disjointShapes)
+      if (!shapes.empty() && !cstrEqOp.getShapes().empty() && disjointShapes)
         return failure();
-      shapes.append(cstrEqOp.shapes().begin(), cstrEqOp.shapes().end());
+      shapes.append(cstrEqOp.getShapes().begin(), cstrEqOp.getShapes().end());
     }
     rewriter.replaceOpWithNewOp<CstrEqOp>(op, shapes);
     return success();
   }
 };
 
 template <typename OpTy>
 struct RemoveDuplicateOperandsPattern : public OpRewritePattern<OpTy> {
void AssumingAllOp::build(OpBuilder &b, OperationState &state,
   build(b, state, b.getType<WitnessType>(), inputs);
 }
 
 //===----------------------------------------------------------------------===//
 // BroadcastOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult BroadcastOp::fold(ArrayRef<Attribute> operands) {
-  if (shapes().size() == 1) {
+  if (getShapes().size() == 1) {
     // Otherwise, we need a cast which would be a canonicalization, not folding.
-    if (shapes().front().getType() != getType())
+    if (getShapes().front().getType() != getType())
       return nullptr;
-    return shapes().front();
+    return getShapes().front();
   }
 
   // TODO: Support folding with more than 2 input shapes
-  if (shapes().size() > 2)
+  if (getShapes().size() > 2)
     return nullptr;
 
   if (!operands[0] || !operands[1])
     return nullptr;
   auto lhsShape = llvm::to_vector<6>(
       operands[0].cast<DenseIntElementsAttr>().getValues<int64_t>());
   auto rhsShape = llvm::to_vector<6>(
       operands[1].cast<DenseIntElementsAttr>().getValues<int64_t>());
struct RemoveEmptyShapeOperandsPattern : public OpRewritePattern<OpTy> {
   LogicalResult matchAndRewrite(OpTy op,
                                 PatternRewriter &rewriter) const override {
     auto isPotentiallyNonEmptyShape = [](Value shape) {
       if (auto extentTensorTy = shape.getType().dyn_cast<RankedTensorType>()) {
         if (extentTensorTy.getDimSize(0) == 0)
           return false;
       }
       if (auto constShape = shape.getDefiningOp<ConstShapeOp>()) {
-        if (constShape.shape().empty())
+        if (constShape.getShape().empty())
           return false;
       }
       return true;
     };
     auto newOperands = llvm::to_vector<8>(
         llvm::make_filter_range(op->getOperands(), isPotentiallyNonEmptyShape));
 
     // Reduce op to equivalent without empty shape operands.

 struct BroadcastForwardSingleOperandPattern
     : public OpRewritePattern<BroadcastOp> {
   using OpRewritePattern<BroadcastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(BroadcastOp op,
                                 PatternRewriter &rewriter) const override {
     if (op.getNumOperands() != 1)
       return failure();
-    Value replacement = op.shapes().front();
+    Value replacement = op.getShapes().front();
 
     // Insert cast if needed.
     if (replacement.getType() != op.getType()) {
       auto loc = op.getLoc();
       if (op.getType().isa<ShapeType>()) {
         replacement = rewriter.create<FromExtentTensorOp>(loc, replacement);
       } else {
         assert(!op.getType().isa<ShapeType>() &&

 struct BroadcastFoldConstantOperandsPattern
     : public OpRewritePattern<BroadcastOp> {
   using OpRewritePattern<BroadcastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(BroadcastOp op,
                                 PatternRewriter &rewriter) const override {
     SmallVector<int64_t, 8> foldedConstantShape;
     SmallVector<Value, 8> newShapeOperands;
-    for (Value shape : op.shapes()) {
+    for (Value shape : op.getShapes()) {
       if (auto constShape = shape.getDefiningOp<ConstShapeOp>()) {
         SmallVector<int64_t, 8> newFoldedConstantShape;
         if (OpTrait::util::getBroadcastedShape(
                 foldedConstantShape,
-                llvm::to_vector<8>(constShape.shape().getValues<int64_t>()),
+                llvm::to_vector<8>(constShape.getShape().getValues<int64_t>()),
                 newFoldedConstantShape)) {
           foldedConstantShape = newFoldedConstantShape;
           continue;
         }
       }
       newShapeOperands.push_back(shape);
     }
 
LogicalResult matchAndRewrite(BroadcastOp op,
                                 PatternRewriter &rewriter) const override {
     // Only concretize dynamic extent tensor result types.
     auto resultTy = op.getType().dyn_cast<RankedTensorType>();
     if (!resultTy || !resultTy.isDynamicDim(0))
       return failure();
 
     // Infer resulting shape rank if possible.
     int64_t maxRank = 0;
-    for (Value shape : op.shapes()) {
+    for (Value shape : op.getShapes()) {
       if (auto extentTensorTy = shape.getType().dyn_cast<RankedTensorType>()) {
         // Cannot infer resulting shape rank if any operand is dynamically
         // ranked.
         if (extentTensorTy.isDynamicDim(0))
           return failure();
         maxRank = std::max(maxRank, extentTensorTy.getDimSize(0));
       }
     }
 
     auto newOp = rewriter.create<BroadcastOp>(
-        op.getLoc(), getExtentTensorType(getContext(), maxRank), op.shapes());
+        op.getLoc(), getExtentTensorType(getContext(), maxRank),
+        op.getShapes());
     rewriter.replaceOpWithNewOp<tensor::CastOp>(op, op.getType(), newOp);
     return success();
   }
 };
 } // namespace
 
 void BroadcastOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                               MLIRContext *context) {

 //===----------------------------------------------------------------------===//
 // ConstShapeOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, ConstShapeOp &op) {
   p << " ";
   p.printOptionalAttrDict(op->getAttrs(), /*elidedAttrs=*/{"shape"});
   p << "[";
-  interleaveComma(op.shape().getValues<int64_t>(), p,
+  interleaveComma(op.getShape().getValues<int64_t>(), p,
                   [&](int64_t i) { p << i; });
   p << "] : ";
   p.printType(op.getType());
 }
 
 static ParseResult parseConstShapeOp(OpAsmParser &parser,
                                      OperationState &result) {
   if (parser.parseOptionalAttrDict(result.attributes))
static ParseResult parseConstShapeOp(OpAsmParser &parser,
   result.addAttribute("shape", builder.getIndexTensorAttr(ints));
   Type resultTy;
   if (parser.parseColonType(resultTy))
     return failure();
   result.types.push_back(resultTy);
   return success();
 }
 
-OpFoldResult ConstShapeOp::fold(ArrayRef<Attribute>) { return shapeAttr(); }
+OpFoldResult ConstShapeOp::fold(ArrayRef<Attribute>) { return getShapeAttr(); }
 
 void ConstShapeOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                                MLIRContext *context) {
   patterns.add<TensorCastConstShape>(context);
 }
 
 LogicalResult mlir::shape::ConstShapeOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
if ([&] {
         return OpTrait::util::staticallyKnownBroadcastable(extents);
       }())
     return BoolAttr::get(getContext(), true);
 
   // Lastly, see if folding can be completed based on what constraints are known
   // on the input shapes.
   if ([&] {
         SmallVector<SmallVector<int64_t, 6>, 6> extents;
-        for (auto shapeValue : shapes()) {
+        for (auto shapeValue : getShapes()) {
           extents.emplace_back();
           if (failed(getShapeVec(shapeValue, extents.back())))
             return false;
         }
         return OpTrait::util::staticallyKnownBroadcastable(extents);
       }())
     return BoolAttr::get(getContext(), true);
 

 // ConstSizeOp
 //===----------------------------------------------------------------------===//
 
 void ConstSizeOp::build(OpBuilder &builder, OperationState &result,
                         int64_t value) {
   build(builder, result, builder.getIndexAttr(value));
 }
 
-OpFoldResult ConstSizeOp::fold(ArrayRef<Attribute>) { return valueAttr(); }
+OpFoldResult ConstSizeOp::fold(ArrayRef<Attribute>) { return getValueAttr(); }
 
 void ConstSizeOp::getAsmResultNames(
     llvm::function_ref<void(Value, StringRef)> setNameFn) {
   SmallString<4> buffer;
   llvm::raw_svector_ostream os(buffer);
-  os << "c" << value();
+  os << "c" << getValue();
   setNameFn(getResult(), os.str());
 }
 
 //===----------------------------------------------------------------------===//
 // ConstWitnessOp
 //===----------------------------------------------------------------------===//
 
-OpFoldResult ConstWitnessOp::fold(ArrayRef<Attribute>) { return passingAttr(); }
+OpFoldResult ConstWitnessOp::fold(ArrayRef<Attribute>) {
+  return getPassingAttr();
+}
 
 //===----------------------------------------------------------------------===//
 // CstrRequireOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult CstrRequireOp::fold(ArrayRef<Attribute> operands) {
   return operands[0];
 }

 
 void FunctionLibraryOp::build(OpBuilder &builder, OperationState &result,
                               StringRef name) {
   result.attributes.push_back(builder.getNamedAttr(
       ::mlir::SymbolTable::getSymbolAttrName(), builder.getStringAttr(name)));
 }
 
 FuncOp FunctionLibraryOp::getShapeFunction(Operation *op) {
-  auto attr = mapping()
+  auto attr = getMapping()
                   .get(op->getName().getIdentifier())
                   .dyn_cast_or_null<FlatSymbolRefAttr>();
   if (!attr)
     return nullptr;
   return lookupSymbol<FuncOp>(attr);
 }
 
 ParseResult parseFunctionLibraryOp(OpAsmParser &parser,

 void print(OpAsmPrinter &p, FunctionLibraryOp op) {
   p << ' ';
   p.printSymbolName(op.getName());
   p.printOptionalAttrDictWithKeyword(
       op->getAttrs(), {SymbolTable::getSymbolAttrName(), "mapping"});
   p.printRegion(op.getOperation()->getRegion(0), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/false);
   p << " mapping ";
-  p.printAttributeWithoutType(op.mappingAttr());
+  p.printAttributeWithoutType(op.getMappingAttr());
 }
 
 //===----------------------------------------------------------------------===//
 // GetExtentOp
 //===----------------------------------------------------------------------===//
 
 Optional<int64_t> GetExtentOp::getConstantDim() {
-  if (auto constSizeOp = dim().getDefiningOp<ConstSizeOp>())
-    return constSizeOp.value().getLimitedValue();
-  if (auto constantOp = dim().getDefiningOp<arith::ConstantOp>())
-    return constantOp.value().cast<IntegerAttr>().getInt();
+  if (auto constSizeOp = getDim().getDefiningOp<ConstSizeOp>())
+    return constSizeOp.getValue().getLimitedValue();
+  if (auto constantOp = getDim().getDefiningOp<arith::ConstantOp>())
+    return constantOp.getValue().cast<IntegerAttr>().getInt();
   return llvm::None;
 }
 
 OpFoldResult GetExtentOp::fold(ArrayRef<Attribute> operands) {
   auto elements = operands[0].dyn_cast_or_null<DenseIntElementsAttr>();
   if (!elements)
     return nullptr;
   Optional<int64_t> dim = getConstantDim();

 
 namespace {
 struct RankShapeOfCanonicalizationPattern
     : public OpRewritePattern<shape::RankOp> {
   using OpRewritePattern<shape::RankOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(shape::RankOp op,
                                 PatternRewriter &rewriter) const override {
-    auto shapeOfOp = op.shape().getDefiningOp<ShapeOfOp>();
+    auto shapeOfOp = op.getShape().getDefiningOp<ShapeOfOp>();
     if (!shapeOfOp)
       return failure();
     auto rankedTensorType =
-        shapeOfOp.arg().getType().dyn_cast<RankedTensorType>();
+        shapeOfOp.getArg().getType().dyn_cast<RankedTensorType>();
     if (!rankedTensorType)
       return failure();
     int64_t rank = rankedTensorType.getRank();
     if (op.getType().isa<IndexType>()) {
       rewriter.replaceOpWithNewOp<arith::ConstantIndexOp>(op.getOperation(),
                                                           rank);
     } else if (op.getType().isa<shape::SizeType>()) {
       rewriter.replaceOpWithNewOp<shape::ConstSizeOp>(op.getOperation(), rank);

 }
 
 //===----------------------------------------------------------------------===//
 // MaxOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MaxOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
   // If operands are equal, just propagate one.
-  if (lhs() == rhs())
-    return lhs();
+  if (getLhs() == getRhs())
+    return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MaxOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())

 }
 
 //===----------------------------------------------------------------------===//
 // MinOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MinOp::fold(llvm::ArrayRef<mlir::Attribute> operands) {
   // If operands are equal, just propagate one.
-  if (lhs() == rhs())
-    return lhs();
+  if (getLhs() == getRhs())
+    return getLhs();
   return nullptr;
 }
 
 LogicalResult mlir::shape::MinOp::inferReturnTypes(
     MLIRContext *context, Optional<Location> location, ValueRange operands,
     DictionaryAttr attributes, RegionRange regions,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   if (operands[0].getType() == operands[1].getType())

 }
 
 namespace {
 struct ShapeOfWithTensor : public OpRewritePattern<shape::ShapeOfOp> {
   using OpRewritePattern<shape::ShapeOfOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(shape::ShapeOfOp op,
                                 PatternRewriter &rewriter) const override {
-    if (!op.arg().getType().isa<ShapedType>())
+    if (!op.getArg().getType().isa<ShapedType>())
       return failure();
     if (op.getType().isa<ShapedType>())
       return failure();
 
-    rewriter.replaceOpWithNewOp<shape::ShapeOfOp>(op.getOperation(), op.arg());
+    rewriter.replaceOpWithNewOp<shape::ShapeOfOp>(op.getOperation(),
+                                                  op.getArg());
     return success();
   }
 };
 
 // Canonicalize
 // ```
 // %0 = shape.shape_of %arg : tensor<?x?x?xf32> -> tensor<3xindex>
 // %1 = tensor.cast %0 : tensor<3xindex> to tensor<?xindex>
LogicalResult matchAndRewrite(tensor::CastOp op,
     if (!ty || ty.getRank() != 1)
       return failure();
 
     auto shapeOfOp = op.source().getDefiningOp<ShapeOfOp>();
     if (!shapeOfOp)
       return failure();
 
     // Argument type must be ranked and must not conflict.
-    auto argTy = shapeOfOp.arg().getType().dyn_cast<RankedTensorType>();
+    auto argTy = shapeOfOp.getArg().getType().dyn_cast<RankedTensorType>();
     if (!argTy || (!ty.isDynamicDim(0) && ty.getDimSize(0) != argTy.getRank()))
       return failure();
 
-    rewriter.replaceOpWithNewOp<ShapeOfOp>(op, ty, shapeOfOp.arg());
+    rewriter.replaceOpWithNewOp<ShapeOfOp>(op, ty, shapeOfOp.getArg());
     return success();
   }
 };
 } // namespace
 
 void ShapeOfOp::getCanonicalizationPatterns(RewritePatternSet &patterns,
                                             MLIRContext *context) {
   patterns.add<ShapeOfCastExtentTensor, ShapeOfWithTensor,
void ReduceOp::build(OpBuilder &builder, OperationState &result, Value shape,
   for (Type initValType : initVals.getTypes()) {
     bodyBlock.addArgument(initValType);
     result.addTypes(initValType);
   }
 }
 
 static LogicalResult verify(ReduceOp op) {
   // Verify block arg types.
-  Block &block = op.region().front();
+  Block &block = op.getRegion().front();
 
   // The block takes index, extent, and aggregated values as arguments.
-  auto blockArgsCount = op.initVals().size() + 2;
+  auto blockArgsCount = op.getInitVals().size() + 2;
   if (block.getNumArguments() != blockArgsCount)
     return op.emitOpError() << "ReduceOp body is expected to have "
                             << blockArgsCount << " arguments";
 
   // The first block argument is the index and must always be of type `index`.
   if (!block.getArgument(0).getType().isa<IndexType>())
     return op.emitOpError(
         "argument 0 of ReduceOp body is expected to be of IndexType");
 
   // The second block argument is the extent and must be of type `size` or
   // `index`, depending on whether the reduce operation is applied to a shape or
   // to an extent tensor.
   Type extentTy = block.getArgument(1).getType();
-  if (op.shape().getType().isa<ShapeType>()) {
+  if (op.getShape().getType().isa<ShapeType>()) {
     if (!extentTy.isa<SizeType>())
       return op.emitOpError("argument 1 of ReduceOp body is expected to be of "
                             "SizeType if the ReduceOp operates on a ShapeType");
   } else {
     if (!extentTy.isa<IndexType>())
       return op.emitOpError(
           "argument 1 of ReduceOp body is expected to be of IndexType if the "
           "ReduceOp operates on an extent tensor");
   }
 
-  for (auto type : llvm::enumerate(op.initVals()))
+  for (auto type : llvm::enumerate(op.getInitVals()))
     if (block.getArgument(type.index() + 2).getType() != type.value().getType())
       return op.emitOpError()
              << "type mismatch between argument " << type.index() + 2
              << " of ReduceOp body and initial value " << type.index();
   return success();
 }
 
 static ParseResult parseReduceOp(OpAsmParser &parser, OperationState &result) {
static ParseResult parseReduceOp(OpAsmParser &parser, OperationState &result) {
   // Parse attributes.
   if (parser.parseOptionalAttrDict(result.attributes))
     return failure();
 
   return success();
 }
 
 static void print(OpAsmPrinter &p, ReduceOp op) {
-  p << '(' << op.shape() << ", " << op.initVals()
-    << ") : " << op.shape().getType();
+  p << '(' << op.getShape() << ", " << op.getInitVals()
+    << ") : " << op.getShape().getType();
   p.printOptionalArrowTypeList(op.getResultTypes());
-  p.printRegion(op.region());
+  p.printRegion(op.getRegion());
   p.printOptionalAttrDict(op->getAttrs());
 }
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Shape/IR/ShapeOps.cpp.inc"

mlir/lib/Dialect/Shape/Transforms/ShapeToShapeLowering.cpp

 NumElementsOpConverter::matchAndRewrite(NumElementsOp op,
                                         PatternRewriter &rewriter) const {
   auto loc = op.getLoc();
   Type valueType = op.getResult().getType();
   Value init = op->getDialect()
                    ->materializeConstant(rewriter, rewriter.getIndexAttr(1),
                                          valueType, loc)
                    ->getResult(0);
-  ReduceOp reduce = rewriter.create<ReduceOp>(loc, op.shape(), init);
+  ReduceOp reduce = rewriter.create<ReduceOp>(loc, op.getShape(), init);
 
   // Generate reduce operator.
   Block *body = reduce.getBody();
   OpBuilder b = OpBuilder::atBlockEnd(body);
   Value product = b.create<MulOp>(loc, valueType, body->getArgument(1),
                                   body->getArgument(2));
   b.create<shape::YieldOp>(loc, product);
 
-  rewriter.replaceOp(op, reduce.result());
+  rewriter.replaceOp(op, reduce.getResult());
   return success();
 }
 
 namespace {
 struct ShapeToShapeLowering
     : public ShapeToShapeLoweringBase<ShapeToShapeLowering> {
   void runOnFunction() override;
 };

mlir/lib/Dialect/Shape/Transforms/StructuralTypeConversions.cpp

matchAndRewrite(AssumingOp op, OpAdaptor adaptor,
     SmallVector<Type, 2> newResultTypes;
     newResultTypes.reserve(op.getNumResults());
     for (auto result : op.getResults()) {
       auto originalType = result.getType();
       Type convertedType = getTypeConverter()->convertType(originalType);
       newResultTypes.push_back(convertedType);
     }
 
-    auto newAssumingOp =
-        rewriter.create<AssumingOp>(op.getLoc(), newResultTypes, op.witness());
-    rewriter.inlineRegionBefore(op.doRegion(), newAssumingOp.doRegion(),
-                                newAssumingOp.doRegion().end());
+    auto newAssumingOp = rewriter.create<AssumingOp>(
+        op.getLoc(), newResultTypes, op.getWitness());
+    rewriter.inlineRegionBefore(op.getDoRegion(), newAssumingOp.getDoRegion(),
+                                newAssumingOp.getDoRegion().end());
     rewriter.replaceOp(op, newAssumingOp.getResults());
 
     return success();
   }
 };
 } // namespace
 
 namespace {

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // TensorDialect Operations.
 //===----------------------------------------------------------------------===//
 
 static LogicalResult isInBounds(Value dim, Value tensor) {
   if (auto constantOp = dim.getDefiningOp<arith::ConstantOp>()) {
-    unsigned d = constantOp.value().cast<IntegerAttr>().getInt();
+    unsigned d = constantOp.getValue().cast<IntegerAttr>().getInt();
     if (d >= tensor.getType().cast<RankedTensorType>().getRank())
       return failure();
   }
   return success(); // in bounds, or symbolic
 }
 
 static LogicalResult isMatchingWidth(Value result, unsigned width) {
   Type etp = result.getType().cast<MemRefType>().getElementType();
if (rank != op.sizes().size())
     return op.emitError("unexpected mismatch between tensor rank and sizes: ")
            << rank << " vs. " << op.sizes().size();
   auto shape = ttp.getShape();
   for (unsigned i = 0; i < rank; i++) {
     if (shape[i] == ShapedType::kDynamicSize)
       continue;
     auto constantOp = op.sizes()[i].getDefiningOp<arith::ConstantOp>();
     if (!constantOp ||
-        constantOp.value().cast<IntegerAttr>().getInt() != shape[i])
+        constantOp.getValue().cast<IntegerAttr>().getInt() != shape[i])
       return op.emitError("unexpected mismatch with static dimension size ")
              << shape[i];
   }
   return success();
 }
 
 static LogicalResult verify(ConvertOp op) {
   if (auto tp1 = op.source().getType().dyn_cast<RankedTensorType>()) {

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

 }
 
 /// If the tensor is a sparse constant, generates and returns the pair of
 /// the constants for the indices and the values.
 static Optional<std::pair<Value, Value>>
 genSplitSparseConstant(ConversionPatternRewriter &rewriter, Location loc,
                        Value tensor) {
   if (auto constOp = tensor.getDefiningOp<arith::ConstantOp>()) {
-    if (auto attr = constOp.value().dyn_cast<SparseElementsAttr>()) {
+    if (auto attr = constOp.getValue().dyn_cast<SparseElementsAttr>()) {
       DenseElementsAttr indicesAttr = attr.getIndices();
       Value indices = rewriter.create<arith::ConstantOp>(loc, indicesAttr);
       DenseElementsAttr valuesAttr = attr.getValues();
       Value values = rewriter.create<arith::ConstantOp>(loc, valuesAttr);
       return std::make_pair(indices, values);
     }
   }
   return {};

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

 }
 
 //===----------------------------------------------------------------------===//
 // AssertOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult AssertOp::canonicalize(AssertOp op, PatternRewriter &rewriter) {
   // Erase assertion if argument is constant true.
-  if (matchPattern(op.arg(), m_One())) {
+  if (matchPattern(op.getArg(), m_One())) {
     rewriter.eraseOp(op);
     return success();
   }
   return failure();
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicRMWOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(AtomicRMWOp op) {
   if (op.getMemRefType().getRank() != op.getNumOperands() - 2)
     return op.emitOpError(
         "expects the number of subscripts to be equal to memref rank");
-  switch (op.kind()) {
+  switch (op.getKind()) {
   case AtomicRMWKind::addf:
   case AtomicRMWKind::maxf:
   case AtomicRMWKind::minf:
   case AtomicRMWKind::mulf:
-    if (!op.value().getType().isa<FloatType>())
+    if (!op.getValue().getType().isa<FloatType>())
       return op.emitOpError()
-             << "with kind '" << stringifyAtomicRMWKind(op.kind())
+             << "with kind '" << stringifyAtomicRMWKind(op.getKind())
              << "' expects a floating-point type";
     break;
   case AtomicRMWKind::addi:
   case AtomicRMWKind::maxs:
   case AtomicRMWKind::maxu:
   case AtomicRMWKind::mins:
   case AtomicRMWKind::minu:
   case AtomicRMWKind::muli:
-    if (!op.value().getType().isa<IntegerType>())
+    if (!op.getValue().getType().isa<IntegerType>())
       return op.emitOpError()
-             << "with kind '" << stringifyAtomicRMWKind(op.kind())
+             << "with kind '" << stringifyAtomicRMWKind(op.getKind())
              << "' expects an integer type";
     break;
   default:
     break;
   }
   return success();
 }
 
if (auto memrefType = memref.getType().dyn_cast<MemRefType>()) {
 
     Region *bodyRegion = result.addRegion();
     bodyRegion->push_back(new Block());
     bodyRegion->addArgument(elementType);
   }
 }
 
 static LogicalResult verify(GenericAtomicRMWOp op) {
-  auto &body = op.body();
+  auto &body = op.getRegion();
   if (body.getNumArguments() != 1)
     return op.emitOpError("expected single number of entry block arguments");
 
   if (op.getResult().getType() != body.getArgument(0).getType())
     return op.emitOpError(
         "expected block argument of the same type result type");
 
   bool hasSideEffects =
static ParseResult parseGenericAtomicRMWOp(OpAsmParser &parser,
   if (parser.parseRegion(*body, llvm::None, llvm::None) ||
       parser.parseOptionalAttrDict(result.attributes))
     return failure();
   result.types.push_back(memrefType.cast<MemRefType>().getElementType());
   return success();
 }
 
 static void print(OpAsmPrinter &p, GenericAtomicRMWOp op) {
-  p << ' ' << op.memref() << "[" << op.indices()
-    << "] : " << op.memref().getType();
-  p.printRegion(op.body());
+  p << ' ' << op.getMemref() << "[" << op.getIndices()
+    << "] : " << op.getMemref().getType();
+  p.printRegion(op.getRegion());
   p.printOptionalAttrDict(op->getAttrs());
 }
 
 //===----------------------------------------------------------------------===//
 // AtomicYieldOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(AtomicYieldOp op) {
   Type parentType = op->getParentOp()->getResultTypes().front();
-  Type resultType = op.result().getType();
+  Type resultType = op.getResult().getType();
   if (parentType != resultType)
     return op.emitOpError() << "types mismatch between yield op: " << resultType
                             << " and its parent: " << parentType;
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // BranchOp
static LogicalResult simplifyPassThroughBr(BranchOp op,
   return success();
 }
 
 LogicalResult BranchOp::canonicalize(BranchOp op, PatternRewriter &rewriter) {
   return success(succeeded(simplifyBrToBlockWithSinglePred(op, rewriter)) ||
                  succeeded(simplifyPassThroughBr(op, rewriter)));
 }
 
-Block *BranchOp::getDest() { return getSuccessor(); }
-
 void BranchOp::setDest(Block *block) { return setSuccessor(block); }
 
 void BranchOp::eraseOperand(unsigned index) { (*this)->eraseOperand(index); }
 
 Optional<MutableOperandRange>
 BranchOp::getMutableSuccessorOperands(unsigned index) {
   assert(index == 0 && "invalid successor index");
-  return destOperandsMutable();
+  return getDestOperandsMutable();
 }
 
-Block *BranchOp::getSuccessorForOperands(ArrayRef<Attribute>) { return dest(); }
+Block *BranchOp::getSuccessorForOperands(ArrayRef<Attribute>) {
+  return getDest();
+}
 
 //===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult CallOp::verifySymbolUses(SymbolTableCollection &symbolTable) {
   // Check that the callee attribute was specified.
   auto fnAttr = (*this)->getAttrOfType<FlatSymbolRefAttr>("callee");

 ///
 ///  -> cond_br %cond, ^bbN(...), ^bbK(...)
 ///
 struct SimplifyPassThroughCondBranch : public OpRewritePattern<CondBranchOp> {
   using OpRewritePattern<CondBranchOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CondBranchOp condbr,
                                 PatternRewriter &rewriter) const override {
-    Block *trueDest = condbr.trueDest(), *falseDest = condbr.falseDest();
+    Block *trueDest = condbr.getTrueDest(), *falseDest = condbr.getFalseDest();
     ValueRange trueDestOperands = condbr.getTrueOperands();
     ValueRange falseDestOperands = condbr.getFalseOperands();
     SmallVector<Value, 4> trueDestOperandStorage, falseDestOperandStorage;
 
     // Try to collapse one of the current successors.
     LogicalResult collapsedTrue =
         collapseBranch(trueDest, trueDestOperands, trueDestOperandStorage);
     LogicalResult collapsedFalse =

 struct SimplifyCondBranchIdenticalSuccessors
     : public OpRewritePattern<CondBranchOp> {
   using OpRewritePattern<CondBranchOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(CondBranchOp condbr,
                                 PatternRewriter &rewriter) const override {
     // Check that the true and false destinations are the same and have the same
     // operands.
-    Block *trueDest = condbr.trueDest();
-    if (trueDest != condbr.falseDest())
+    Block *trueDest = condbr.getTrueDest();
+    if (trueDest != condbr.getFalseDest())
       return failure();
 
     // If all of the operands match, no selects need to be generated.
     OperandRange trueOperands = condbr.getTrueOperands();
     OperandRange falseOperands = condbr.getFalseOperands();
     if (trueOperands == falseOperands) {
       rewriter.replaceOpWithNewOp<BranchOp>(condbr, trueDest, trueOperands);
       return success();
LogicalResult matchAndRewrite(CondBranchOp condbr,
 
     // Check that the predecessor terminates with a conditional branch to this
     // block and that it branches on the same condition.
     auto predBranch = dyn_cast<CondBranchOp>(predecessor->getTerminator());
     if (!predBranch || condbr.getCondition() != predBranch.getCondition())
       return failure();
 
     // Fold this branch to an unconditional branch.
-    if (currentBlock == predBranch.trueDest())
-      rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.trueDest(),
-                                            condbr.trueDestOperands());
+    if (currentBlock == predBranch.getTrueDest())
+      rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getTrueDest(),
+                                            condbr.getTrueDestOperands());
     else
-      rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.falseDest(),
-                                            condbr.falseDestOperands());
+      rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.getFalseDest(),
+                                            condbr.getFalseDestOperands());
     return success();
   }
 };
 
 ///   cond_br %arg0, ^trueB, ^falseB
 ///
 /// ^trueB:
 ///   "test.consumer1"(%arg0) : (i1) -> ()
LogicalResult matchAndRewrite(CondBranchOp condbr,
 
     // TODO These checks can be expanded to encompas any use with only
     // either the true of false edge as a predecessor. For now, we fall
     // back to checking the single predecessor is given by the true/fasle
     // destination, thereby ensuring that only that edge can reach the
     // op.
     if (condbr.getTrueDest()->getSinglePredecessor()) {
       for (OpOperand &use :
-           llvm::make_early_inc_range(condbr.condition().getUses())) {
+           llvm::make_early_inc_range(condbr.getCondition().getUses())) {
         if (use.getOwner()->getBlock() == condbr.getTrueDest()) {
           replaced = true;
 
           if (!constantTrue)
             constantTrue = rewriter.create<arith::ConstantOp>(
                 condbr.getLoc(), ty, rewriter.getBoolAttr(true));
 
           rewriter.updateRootInPlace(use.getOwner(),
                                      [&] { use.set(constantTrue); });
         }
       }
     }
     if (condbr.getFalseDest()->getSinglePredecessor()) {
       for (OpOperand &use :
-           llvm::make_early_inc_range(condbr.condition().getUses())) {
+           llvm::make_early_inc_range(condbr.getCondition().getUses())) {
         if (use.getOwner()->getBlock() == condbr.getFalseDest()) {
           replaced = true;
 
           if (!constantFalse)
             constantFalse = rewriter.create<arith::ConstantOp>(
                 condbr.getLoc(), ty, rewriter.getBoolAttr(false));
 
           rewriter.updateRootInPlace(use.getOwner(),
results.add<SimplifyConstCondBranchPred, SimplifyPassThroughCondBranch,
               SimplifyCondBranchIdenticalSuccessors,
               SimplifyCondBranchFromCondBranchOnSameCondition,
               CondBranchTruthPropagation>(context);
 }
 
 Optional<MutableOperandRange>
 CondBranchOp::getMutableSuccessorOperands(unsigned index) {
   assert(index < getNumSuccessors() && "invalid successor index");
-  return index == trueIndex ? trueDestOperandsMutable()
-                            : falseDestOperandsMutable();
+  return index == trueIndex ? getTrueDestOperandsMutable()
+                            : getFalseDestOperandsMutable();
 }
 
 Block *CondBranchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
   if (IntegerAttr condAttr = operands.front().dyn_cast_or_null<IntegerAttr>())
-    return condAttr.getValue().isOneValue() ? trueDest() : falseDest();
+    return condAttr.getValue().isOneValue() ? getTrueDest() : getFalseDest();
   return nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantOp
 //===----------------------------------------------------------------------===//
 
 static void print(OpAsmPrinter &p, ConstantOp &op) {

 //===----------------------------------------------------------------------===//
 // MaxSIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MaxSIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // maxsi(x,x) -> x
-  if (lhs() == rhs())
-    return rhs();
+  if (getLhs() == getRhs())
+    return getRhs();
 
   APInt intValue;
   // maxsi(x,MAX_INT) -> MAX_INT
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
       intValue.isMaxSignedValue())
-    return rhs();
+    return getRhs();
 
   // maxsi(x, MIN_INT) -> x
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
       intValue.isMinSignedValue())
-    return lhs();
+    return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, APInt b) { return llvm::APIntOps::smax(a, b); });
 }
 
 //===----------------------------------------------------------------------===//
 // MaxUIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MaxUIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // maxui(x,x) -> x
-  if (lhs() == rhs())
-    return rhs();
+  if (getLhs() == getRhs())
+    return getRhs();
 
   APInt intValue;
   // maxui(x,MAX_INT) -> MAX_INT
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
-    return rhs();
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
+    return getRhs();
 
   // maxui(x, MIN_INT) -> x
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
-    return lhs();
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
+    return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, APInt b) { return llvm::APIntOps::umax(a, b); });
 }
 
 //===----------------------------------------------------------------------===//
 // MinSIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MinSIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // minsi(x,x) -> x
-  if (lhs() == rhs())
-    return rhs();
+  if (getLhs() == getRhs())
+    return getRhs();
 
   APInt intValue;
   // minsi(x,MIN_INT) -> MIN_INT
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
       intValue.isMinSignedValue())
-    return rhs();
+    return getRhs();
 
   // minsi(x, MAX_INT) -> x
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) &&
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) &&
       intValue.isMaxSignedValue())
-    return lhs();
+    return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, APInt b) { return llvm::APIntOps::smin(a, b); });
 }
 
 //===----------------------------------------------------------------------===//
 // MinUIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MinUIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // minui(x,x) -> x
-  if (lhs() == rhs())
-    return rhs();
+  if (getLhs() == getRhs())
+    return getRhs();
 
   APInt intValue;
   // minui(x,MIN_INT) -> MIN_INT
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
-    return rhs();
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMinValue())
+    return getRhs();
 
   // minui(x, MAX_INT) -> x
-  if (matchPattern(rhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
-    return lhs();
+  if (matchPattern(getRhs(), m_ConstantInt(&intValue)) && intValue.isMaxValue())
+    return getLhs();
 
   return constFoldBinaryOp<IntegerAttr>(
       operands, [](APInt a, APInt b) { return llvm::APIntOps::umin(a, b); });
 }
 
 //===----------------------------------------------------------------------===//
 // RankOp
 //===----------------------------------------------------------------------===//
if (!matchPattern(op.getTrueValue(), m_Zero()))
       return failure();
 
     if (!matchPattern(op.getFalseValue(), m_One()))
       return failure();
 
     if (!op.getType().isInteger(1))
       return failure();
 
-    rewriter.replaceOpWithNewOp<arith::XOrIOp>(op, op.condition(),
+    rewriter.replaceOpWithNewOp<arith::XOrIOp>(op, op.getCondition(),
                                                op.getFalseValue());
     return success();
   }
 };
 
 void SelectOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
                                            MLIRContext *context) {
   results.insert<SelectToNot>(context);
OpFoldResult SelectOp::fold(ArrayRef<Attribute> operands) {
   if (matchPattern(condition, m_One()))
     return trueVal;
 
   // select false, %0, %1 => %1
   if (matchPattern(condition, m_Zero()))
     return falseVal;
 
   if (auto cmp = dyn_cast_or_null<arith::CmpIOp>(condition.getDefiningOp())) {
-    auto pred = cmp.predicate();
+    auto pred = cmp.getPredicate();
     if (pred == arith::CmpIPredicate::eq || pred == arith::CmpIPredicate::ne) {
-      auto cmpLhs = cmp.lhs();
-      auto cmpRhs = cmp.rhs();
+      auto cmpLhs = cmp.getLhs();
+      auto cmpRhs = cmp.getRhs();
 
       // %0 = arith.cmpi eq, %arg0, %arg1
       // %1 = select %0, %arg0, %arg1 => %arg1
 
       // %0 = arith.cmpi ne, %arg0, %arg1
       // %1 = select %0, %arg0, %arg1 => %arg0
 
       if ((cmpLhs == trueVal && cmpRhs == falseVal) ||
for (int64_t i = 0, size = caseValues.size(); i < size; ++i) {
     p << caseValues.getValue<APInt>(i).getLimitedValue();
     p << ": ";
     p.printSuccessorAndUseList(caseDestinations[i], caseOperands[i]);
   }
   p.printNewline();
 }
 
 static LogicalResult verify(SwitchOp op) {
-  auto caseValues = op.case_values();
-  auto caseDestinations = op.caseDestinations();
+  auto caseValues = op.getCaseValues();
+  auto caseDestinations = op.getCaseDestinations();
 
   if (!caseValues && caseDestinations.empty())
     return success();
 
-  Type flagType = op.flag().getType();
+  Type flagType = op.getFlag().getType();
   Type caseValueType = caseValues->getType().getElementType();
   if (caseValueType != flagType)
     return op.emitOpError()
            << "'flag' type (" << flagType << ") should match case value type ("
            << caseValueType << ")";
 
   if (caseValues &&
       caseValues->size() != static_cast<int64_t>(caseDestinations.size()))
     return op.emitOpError() << "number of case values (" << caseValues->size()
                             << ") should match number of "
                                "case destinations ("
                             << caseDestinations.size() << ")";
   return success();
 }
 
 Optional<MutableOperandRange>
 SwitchOp::getMutableSuccessorOperands(unsigned index) {
   assert(index < getNumSuccessors() && "invalid successor index");
-  return index == 0 ? defaultOperandsMutable()
+  return index == 0 ? getDefaultOperandsMutable()
                     : getCaseOperandsMutable(index - 1);
 }
 
 Block *SwitchOp::getSuccessorForOperands(ArrayRef<Attribute> operands) {
-  Optional<DenseIntElementsAttr> caseValues = case_values();
+  Optional<DenseIntElementsAttr> caseValues = getCaseValues();
 
   if (!caseValues)
-    return defaultDestination();
+    return getDefaultDestination();
 
-  SuccessorRange caseDests = caseDestinations();
+  SuccessorRange caseDests = getCaseDestinations();
   if (auto value = operands.front().dyn_cast_or_null<IntegerAttr>()) {
-    for (int64_t i = 0, size = case_values()->size(); i < size; ++i)
+    for (int64_t i = 0, size = getCaseValues()->size(); i < size; ++i)
       if (value == caseValues->getValue<IntegerAttr>(i))
         return caseDests[i];
-    return defaultDestination();
+    return getDefaultDestination();
   }
   return nullptr;
 }
 
 /// switch %flag : i32, [
 ///   default:  ^bb1
 /// ]
 ///  -> br ^bb1
 static LogicalResult simplifySwitchWithOnlyDefault(SwitchOp op,
                                                    PatternRewriter &rewriter) {
-  if (!op.caseDestinations().empty())
+  if (!op.getCaseDestinations().empty())
     return failure();
 
-  rewriter.replaceOpWithNewOp<BranchOp>(op, op.defaultDestination(),
-                                        op.defaultOperands());
+  rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
+                                        op.getDefaultOperands());
   return success();
 }
 
 /// switch %flag : i32, [
 ///   default: ^bb1,
 ///   42: ^bb1,
 ///   43: ^bb2
 /// ]
 /// ->
 /// switch %flag : i32, [
 ///   default: ^bb1,
 ///   43: ^bb2
 /// ]
 static LogicalResult
 dropSwitchCasesThatMatchDefault(SwitchOp op, PatternRewriter &rewriter) {
   SmallVector<Block *> newCaseDestinations;
   SmallVector<ValueRange> newCaseOperands;
   SmallVector<APInt> newCaseValues;
   bool requiresChange = false;
-  auto caseValues = op.case_values();
-  auto caseDests = op.caseDestinations();
+  auto caseValues = op.getCaseValues();
+  auto caseDests = op.getCaseDestinations();
 
   for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
-    if (caseDests[i] == op.defaultDestination() &&
-        op.getCaseOperands(i) == op.defaultOperands()) {
+    if (caseDests[i] == op.getDefaultDestination() &&
+        op.getCaseOperands(i) == op.getDefaultOperands()) {
       requiresChange = true;
       continue;
     }
     newCaseDestinations.push_back(caseDests[i]);
     newCaseOperands.push_back(op.getCaseOperands(i));
     newCaseValues.push_back(caseValues->getValue<APInt>(i));
   }
 
   if (!requiresChange)
     return failure();
 
-  rewriter.replaceOpWithNewOp<SwitchOp>(op, op.flag(), op.defaultDestination(),
-                                        op.defaultOperands(), newCaseValues,
-                                        newCaseDestinations, newCaseOperands);
+  rewriter.replaceOpWithNewOp<SwitchOp>(
+      op, op.getFlag(), op.getDefaultDestination(), op.getDefaultOperands(),
+      newCaseValues, newCaseDestinations, newCaseOperands);
   return success();
 }
 
 /// Helper for folding a switch with a constant value.
 /// switch %c_42 : i32, [
 ///   default: ^bb1 ,
 ///   42: ^bb2,
 ///   43: ^bb3
 /// ]
 /// -> br ^bb2
 static void foldSwitch(SwitchOp op, PatternRewriter &rewriter,
                        APInt caseValue) {
-  auto caseValues = op.case_values();
+  auto caseValues = op.getCaseValues();
   for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
     if (caseValues->getValue<APInt>(i) == caseValue) {
-      rewriter.replaceOpWithNewOp<BranchOp>(op, op.caseDestinations()[i],
+      rewriter.replaceOpWithNewOp<BranchOp>(op, op.getCaseDestinations()[i],
                                             op.getCaseOperands(i));
       return;
     }
   }
-  rewriter.replaceOpWithNewOp<BranchOp>(op, op.defaultDestination(),
-                                        op.defaultOperands());
+  rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
+                                        op.getDefaultOperands());
 }
 
 /// switch %c_42 : i32, [
 ///   default: ^bb1,
 ///   42: ^bb2,
 ///   43: ^bb3
 /// ]
 /// -> br ^bb2
 static LogicalResult simplifyConstSwitchValue(SwitchOp op,
                                               PatternRewriter &rewriter) {
   APInt caseValue;
-  if (!matchPattern(op.flag(), m_ConstantInt(&caseValue)))
+  if (!matchPattern(op.getFlag(), m_ConstantInt(&caseValue)))
     return failure();
 
   foldSwitch(op, rewriter, caseValue);
   return success();
 }
 
 /// switch %c_42 : i32, [
 ///   default: ^bb1,
 ///   42: ^bb2,
 /// ]
 /// ^bb2:
 ///   br ^bb3
 /// ->
 /// switch %c_42 : i32, [
 ///   default: ^bb1,
 ///   42: ^bb3,
 /// ]
 static LogicalResult simplifyPassThroughSwitch(SwitchOp op,
                                                PatternRewriter &rewriter) {
   SmallVector<Block *> newCaseDests;
   SmallVector<ValueRange> newCaseOperands;
   SmallVector<SmallVector<Value>> argStorage;
-  auto caseValues = op.case_values();
-  auto caseDests = op.caseDestinations();
+  auto caseValues = op.getCaseValues();
+  auto caseDests = op.getCaseDestinations();
   bool requiresChange = false;
   for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
     Block *caseDest = caseDests[i];
     ValueRange caseOperands = op.getCaseOperands(i);
     argStorage.emplace_back();
     if (succeeded(collapseBranch(caseDest, caseOperands, argStorage.back())))
       requiresChange = true;
 
     newCaseDests.push_back(caseDest);
     newCaseOperands.push_back(caseOperands);
   }
 
-  Block *defaultDest = op.defaultDestination();
-  ValueRange defaultOperands = op.defaultOperands();
+  Block *defaultDest = op.getDefaultDestination();
+  ValueRange defaultOperands = op.getDefaultOperands();
   argStorage.emplace_back();
 
   if (succeeded(
           collapseBranch(defaultDest, defaultOperands, argStorage.back())))
     requiresChange = true;
 
   if (!requiresChange)
     return failure();
 
-  rewriter.replaceOpWithNewOp<SwitchOp>(op, op.flag(), defaultDest,
+  rewriter.replaceOpWithNewOp<SwitchOp>(op, op.getFlag(), defaultDest,
                                         defaultOperands, caseValues.getValue(),
                                         newCaseDests, newCaseOperands);
   return success();
 }
 
 /// switch %flag : i32, [
 ///   default: ^bb1,
 ///   42: ^bb2,
simplifySwitchFromSwitchOnSameCondition(SwitchOp op,
   Block *predecessor = currentBlock->getSinglePredecessor();
   if (!predecessor)
     return failure();
 
   // Check that the predecessor terminates with a switch branch to this block
   // and that it branches on the same condition and that this branch isn't the
   // default destination.
   auto predSwitch = dyn_cast<SwitchOp>(predecessor->getTerminator());
-  if (!predSwitch || op.flag() != predSwitch.flag() ||
-      predSwitch.defaultDestination() == currentBlock)
+  if (!predSwitch || op.getFlag() != predSwitch.getFlag() ||
+      predSwitch.getDefaultDestination() == currentBlock)
     return failure();
 
   // Fold this switch to an unconditional branch.
   APInt caseValue;
   bool isDefault = true;
-  SuccessorRange predDests = predSwitch.caseDestinations();
-  Optional<DenseIntElementsAttr> predCaseValues = predSwitch.case_values();
+  SuccessorRange predDests = predSwitch.getCaseDestinations();
+  Optional<DenseIntElementsAttr> predCaseValues = predSwitch.getCaseValues();
   for (int64_t i = 0, size = predCaseValues->size(); i < size; ++i) {
     if (currentBlock == predDests[i]) {
       caseValue = predCaseValues->getValue<APInt>(i);
       isDefault = false;
       break;
     }
   }
   if (isDefault)
-    rewriter.replaceOpWithNewOp<BranchOp>(op, op.defaultDestination(),
-                                          op.defaultOperands());
+    rewriter.replaceOpWithNewOp<BranchOp>(op, op.getDefaultDestination(),
+                                          op.getDefaultOperands());
   else
     foldSwitch(op, rewriter, caseValue);
   return success();
 }
 
 /// switch %flag : i32, [
 ///   default: ^bb1,
 ///   42: ^bb2
simplifySwitchFromDefaultSwitchOnSameCondition(SwitchOp op,
   Block *predecessor = currentBlock->getSinglePredecessor();
   if (!predecessor)
     return failure();
 
   // Check that the predecessor terminates with a switch branch to this block
   // and that it branches on the same condition and that this branch is the
   // default destination.
   auto predSwitch = dyn_cast<SwitchOp>(predecessor->getTerminator());
-  if (!predSwitch || op.flag() != predSwitch.flag() ||
-      predSwitch.defaultDestination() != currentBlock)
+  if (!predSwitch || op.getFlag() != predSwitch.getFlag() ||
+      predSwitch.getDefaultDestination() != currentBlock)
     return failure();
 
   // Delete case values that are not possible here.
   DenseSet<APInt> caseValuesToRemove;
-  auto predDests = predSwitch.caseDestinations();
-  auto predCaseValues = predSwitch.case_values();
+  auto predDests = predSwitch.getCaseDestinations();
+  auto predCaseValues = predSwitch.getCaseValues();
   for (int64_t i = 0, size = predCaseValues->size(); i < size; ++i)
     if (currentBlock != predDests[i])
       caseValuesToRemove.insert(predCaseValues->getValue<APInt>(i));
 
   SmallVector<Block *> newCaseDestinations;
   SmallVector<ValueRange> newCaseOperands;
   SmallVector<APInt> newCaseValues;
   bool requiresChange = false;
 
-  auto caseValues = op.case_values();
-  auto caseDests = op.caseDestinations();
+  auto caseValues = op.getCaseValues();
+  auto caseDests = op.getCaseDestinations();
   for (int64_t i = 0, size = caseValues->size(); i < size; ++i) {
     if (caseValuesToRemove.contains(caseValues->getValue<APInt>(i))) {
       requiresChange = true;
       continue;
     }
     newCaseDestinations.push_back(caseDests[i]);
     newCaseOperands.push_back(op.getCaseOperands(i));
     newCaseValues.push_back(caseValues->getValue<APInt>(i));
   }
 
   if (!requiresChange)
     return failure();
 
-  rewriter.replaceOpWithNewOp<SwitchOp>(op, op.flag(), op.defaultDestination(),
-                                        op.defaultOperands(), newCaseValues,
-                                        newCaseDestinations, newCaseOperands);
+  rewriter.replaceOpWithNewOp<SwitchOp>(
+      op, op.getFlag(), op.getDefaultDestination(), op.getDefaultOperands(),
+      newCaseValues, newCaseDestinations, newCaseOperands);
   return success();
 }
 
 void SwitchOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
   results.add(&simplifySwitchWithOnlyDefault)
       .add(&dropSwitchCasesThatMatchDefault)
       .add(&simplifyConstSwitchValue)

mlir/lib/Dialect/StandardOps/Transforms/Bufferize.cpp

 
 namespace {
 class BufferizeSelectOp : public OpConversionPattern<SelectOp> {
 public:
   using OpConversionPattern::OpConversionPattern;
   LogicalResult
   matchAndRewrite(SelectOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    if (!op.condition().getType().isa<IntegerType>())
+    if (!op.getCondition().getType().isa<IntegerType>())
       return rewriter.notifyMatchFailure(op, "requires scalar condition");
 
-    rewriter.replaceOpWithNewOp<SelectOp>(
-        op, adaptor.condition(), adaptor.true_value(), adaptor.false_value());
+    rewriter.replaceOpWithNewOp<SelectOp>(op, adaptor.getCondition(),
+                                          adaptor.getTrueValue(),
+                                          adaptor.getFalseValue());
     return success();
   }
 };
 } // namespace
 
 void mlir::populateStdBufferizePatterns(BufferizeTypeConverter &typeConverter,
                                         RewritePatternSet &patterns) {
   patterns.add<BufferizeSelectOp>(typeConverter, patterns.getContext());
target.addLegalDialect<scf::SCFDialect, StandardOpsDialect,
                            memref::MemRefDialect>();
 
     populateStdBufferizePatterns(typeConverter, patterns);
     // We only bufferize the case of tensor selected type and scalar condition,
     // as that boils down to a select over memref descriptors (don't need to
     // touch the data).
     target.addDynamicallyLegalOp<SelectOp>([&](SelectOp op) {
       return typeConverter.isLegal(op.getType()) ||
-             !op.condition().getType().isa<IntegerType>();
+             !op.getCondition().getType().isa<IntegerType>();
     });
     if (failed(
             applyPartialConversion(getFunction(), target, std::move(patterns))))
       signalPassFailure();
   }
 };
 } // namespace
 
 std::unique_ptr<Pass> mlir::createStdBufferizePass() {
   return std::make_unique<StdBufferizePass>();
 }

mlir/lib/Dialect/StandardOps/Transforms/ExpandOps.cpp

 /// }
 struct AtomicRMWOpConverter : public OpRewritePattern<AtomicRMWOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(AtomicRMWOp op,
                                 PatternRewriter &rewriter) const final {
     arith::CmpFPredicate predicate;
-    switch (op.kind()) {
+    switch (op.getKind()) {
     case AtomicRMWKind::maxf:
       predicate = arith::CmpFPredicate::OGT;
       break;
     case AtomicRMWKind::minf:
       predicate = arith::CmpFPredicate::OLT;
       break;
     default:
       return failure();
     }
 
     auto loc = op.getLoc();
-    auto genericOp =
-        rewriter.create<GenericAtomicRMWOp>(loc, op.memref(), op.indices());
+    auto genericOp = rewriter.create<GenericAtomicRMWOp>(loc, op.getMemref(),
+                                                         op.getIndices());
     OpBuilder bodyBuilder =
         OpBuilder::atBlockEnd(genericOp.getBody(), rewriter.getListener());
 
     Value lhs = genericOp.getCurrentValue();
-    Value rhs = op.value();
+    Value rhs = op.getValue();
     Value cmp = bodyBuilder.create<arith::CmpFOp>(loc, predicate, lhs, rhs);
     Value select = bodyBuilder.create<SelectOp>(loc, cmp, lhs, rhs);
     bodyBuilder.create<AtomicYieldOp>(loc, select);
 
     rewriter.replaceOp(op, genericOp.getResult());
     return success();
   }
 };

 
 template <typename OpTy, arith::CmpFPredicate pred>
 struct MaxMinFOpConverter : public OpRewritePattern<OpTy> {
 public:
   using OpRewritePattern<OpTy>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(OpTy op,
                                 PatternRewriter &rewriter) const final {
-    Value lhs = op.lhs();
-    Value rhs = op.rhs();
+    Value lhs = op.getLhs();
+    Value rhs = op.getRhs();
 
     Location loc = op.getLoc();
     Value cmp = rewriter.create<arith::CmpFOp>(loc, pred, lhs, rhs);
     Value select = rewriter.create<SelectOp>(loc, cmp, lhs, rhs);
 
     auto floatType = getElementTypeOrSelf(lhs.getType()).cast<FloatType>();
     Value isNaN = rewriter.create<arith::CmpFOp>(loc, arith::CmpFPredicate::UNO,
                                                  lhs, rhs);

 };
 
 template <typename OpTy, arith::CmpIPredicate pred>
 struct MaxMinIOpConverter : public OpRewritePattern<OpTy> {
 public:
   using OpRewritePattern<OpTy>::OpRewritePattern;
   LogicalResult matchAndRewrite(OpTy op,
                                 PatternRewriter &rewriter) const final {
-    Value lhs = op.lhs();
-    Value rhs = op.rhs();
+    Value lhs = op.getLhs();
+    Value rhs = op.getRhs();
 
     Location loc = op.getLoc();
     Value cmp = rewriter.create<arith::CmpIOp>(loc, pred, lhs, rhs);
     rewriter.replaceOpWithNewOp<SelectOp>(op, cmp, lhs, rhs);
     return success();
   }
 };
 
 struct StdExpandOpsPass : public StdExpandOpsBase<StdExpandOpsPass> {
   void runOnFunction() override {
     MLIRContext &ctx = getContext();
 
     RewritePatternSet patterns(&ctx);
     populateStdExpandOpsPatterns(patterns);
     arith::populateArithmeticExpandOpsPatterns(patterns);
 
     ConversionTarget target(getContext());
 
     target.addLegalDialect<arith::ArithmeticDialect, memref::MemRefDialect,
                            StandardOpsDialect>();
     target.addIllegalOp<arith::CeilDivSIOp, arith::FloorDivSIOp>();
     target.addDynamicallyLegalOp<AtomicRMWOp>([](AtomicRMWOp op) {
-      return op.kind() != AtomicRMWKind::maxf &&
-             op.kind() != AtomicRMWKind::minf;
+      return op.getKind() != AtomicRMWKind::maxf &&
+             op.getKind() != AtomicRMWKind::minf;
     });
     target.addDynamicallyLegalOp<memref::ReshapeOp>([](memref::ReshapeOp op) {
       return !op.shape().getType().cast<MemRefType>().hasStaticShape();
     });
     // clang-format off
     target.addIllegalOp<
       MaxFOp,
       MaxSIOp,

mlir/lib/Dialect/StandardOps/Transforms/FuncConversions.cpp

matchAndRewrite(CallOp callOp, OpAdaptor adaptor,
     SmallVector<Type, 1> convertedResults;
     if (failed(typeConverter->convertTypes(callOp.getResultTypes(),
                                            convertedResults)))
       return failure();
 
     // Substitute with the new result types from the corresponding FuncType
     // conversion.
     rewriter.replaceOpWithNewOp<CallOp>(
-        callOp, callOp.callee(), convertedResults, adaptor.getOperands());
+        callOp, callOp.getCallee(), convertedResults, adaptor.getOperands());
     return success();
   }
 };
 } // end anonymous namespace
 
 void mlir::populateCallOpTypeConversionPattern(RewritePatternSet &patterns,
                                                TypeConverter &converter) {
   patterns.add<CallOpSignatureConversion>(converter, patterns.getContext());

mlir/lib/Dialect/StandardOps/Transforms/TensorConstantBufferize.cpp

 
 memref::GlobalOp GlobalCreator::getGlobalFor(arith::ConstantOp constantOp) {
   auto type = constantOp.getType().cast<RankedTensorType>();
 
   BufferizeTypeConverter typeConverter;
 
   // If we already have a global for this constant value, no need to do
   // anything else.
-  auto it = globals.find(constantOp.value());
+  auto it = globals.find(constantOp.getValue());
   if (it != globals.end())
     return cast<memref::GlobalOp>(it->second);
 
   // Create a builder without an insertion point. We will insert using the
   // symbol table to guarantee unique names.
   OpBuilder globalBuilder(moduleOp.getContext());
   SymbolTable symbolTable(moduleOp);
 
   // Create a pretty name.
   SmallString<64> buf;
   llvm::raw_svector_ostream os(buf);
   interleave(type.getShape(), os, "x");
   os << "x" << type.getElementType();
 
   // Add an optional alignment to the global memref.
   IntegerAttr memrefAlignment =
       alignment > 0 ? IntegerAttr::get(globalBuilder.getI64Type(), alignment)
                     : IntegerAttr();
 
   auto global = globalBuilder.create<memref::GlobalOp>(
       constantOp.getLoc(), (Twine("__constant_") + os.str()).str(),
       /*sym_visibility=*/globalBuilder.getStringAttr("private"),
       /*type=*/typeConverter.convertType(type).cast<MemRefType>(),
-      /*initial_value=*/constantOp.value().cast<ElementsAttr>(),
+      /*initial_value=*/constantOp.getValue().cast<ElementsAttr>(),
       /*constant=*/true,
       /*alignment=*/memrefAlignment);
   symbolTable.insert(global);
   // The symbol table inserts at the end of the module, but globals are a bit
   // nicer if they are at the beginning.
   global->moveBefore(&moduleOp.front());
-  globals[constantOp.value()] = global;
+  globals[constantOp.getValue()] = global;
   return global;
 }
 
 namespace {
 class BufferizeTensorConstantOp
     : public OpConversionPattern<arith::ConstantOp> {
 public:
   BufferizeTensorConstantOp(GlobalCreator &globals,

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

void DimOp::build(OpBuilder &builder, OperationState &result, Value source,
                   int64_t index) {
   auto loc = result.location;
   Value indexValue = builder.create<arith::ConstantIndexOp>(loc, index);
   build(builder, result, source, indexValue);
 }
 
 Optional<int64_t> DimOp::getConstantIndex() {
   if (auto constantOp = index().getDefiningOp<arith::ConstantOp>())
-    return constantOp.value().cast<IntegerAttr>().getInt();
+    return constantOp.getValue().cast<IntegerAttr>().getInt();
   return {};
 }
 
 static LogicalResult verify(DimOp op) {
   // Assume unknown index to be in range.
   Optional<int64_t> index = op.getConstantIndex();
   if (!index.hasValue())
     return success();

mlir/lib/Dialect/Vector/VectorOps.cpp

 /// looks "under the hood" of a constant value with dense attributes
 /// and a constant mask operation (since the client may be called at
 /// various stages during progressive lowering).
 static MaskFormat get1DMaskFormat(Value mask) {
   if (auto c = mask.getDefiningOp<arith::ConstantOp>()) {
     // Inspect constant dense values. We count up for bits that
     // are set, count down for bits that are cleared, and bail
     // when a mix is detected.
-    if (auto denseElts = c.value().dyn_cast<DenseIntElementsAttr>()) {
+    if (auto denseElts = c.getValue().dyn_cast<DenseIntElementsAttr>()) {
       int64_t val = 0;
       for (bool b : denseElts.getValues<bool>())
         if (b && val >= 0)
           val++;
         else if (!b && val <= 0)
           val--;
         else
           return MaskFormat::Unknown;
auto canonicalize = [&](Value maybeContraction,
                             Value otherOperand) -> vector::ContractionOp {
       vector::ContractionOp contractionOp =
           dyn_cast_or_null<vector::ContractionOp>(
               maybeContraction.getDefiningOp());
       if (!contractionOp)
         return vector::ContractionOp();
       if (auto maybeZero = dyn_cast_or_null<arith::ConstantOp>(
               contractionOp.acc().getDefiningOp())) {
-        if (maybeZero.value() ==
+        if (maybeZero.getValue() ==
             rewriter.getZeroAttr(contractionOp.acc().getType())) {
           BlockAndValueMapping bvm;
           bvm.map(contractionOp.acc(), otherOperand);
           auto newContraction =
               cast<vector::ContractionOp>(rewriter.clone(*contractionOp, bvm));
           rewriter.replaceOp(addOp, newContraction.getResult());
           return newContraction;
         }
public:
   LogicalResult matchAndRewrite(ExtractStridedSliceOp extractStridedSliceOp,
                                 PatternRewriter &rewriter) const override {
     // Return if 'extractStridedSliceOp' operand is not defined by a
     // ConstantOp.
     auto constantOp =
         extractStridedSliceOp.vector().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
-    auto dense = constantOp.value().dyn_cast<SplatElementsAttr>();
+    auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
     auto newAttr = DenseElementsAttr::get(extractStridedSliceOp.getType(),
                                           dense.getSplatValue());
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(extractStridedSliceOp,
                                                    newAttr);
     return success();
   }

 public:
   using OpRewritePattern<ExtractStridedSliceOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
     auto splat = op.vector().getDefiningOp<SplatOp>();
     if (!splat)
       return failure();
-    rewriter.replaceOpWithNewOp<SplatOp>(op, op.getType(), splat.input());
+    rewriter.replaceOpWithNewOp<SplatOp>(op, op.getType(), splat.getInput());
     return success();
   }
 };
 
 } // end anonymous namespace
 
 void ExtractStridedSliceOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
public:
   using OpRewritePattern<ShapeCastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ShapeCastOp shapeCastOp,
                                 PatternRewriter &rewriter) const override {
     auto constantOp = shapeCastOp.source().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
     // Only handle splat for now.
-    auto dense = constantOp.value().dyn_cast<SplatElementsAttr>();
+    auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
     auto newAttr = DenseElementsAttr::get(
         shapeCastOp.getType().cast<VectorType>(), dense.getSplatValue());
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(shapeCastOp, newAttr);
     return success();
   }
 };

mlir/lib/Dialect/Vector/VectorUtils.cpp

for (unsigned i = 0, e = transferA.indices().size(); i < e; i++) {
     auto indexB = transferB.indices()[i].getDefiningOp<arith::ConstantOp>();
     // If any of the indices are dynamic we cannot prove anything.
     if (!indexA || !indexB)
       continue;
 
     if (i < rankOffset) {
       // For leading dimensions, if we can prove that index are different we
       // know we are accessing disjoint slices.
-      if (indexA.value().cast<IntegerAttr>().getInt() !=
-          indexB.value().cast<IntegerAttr>().getInt())
+      if (indexA.getValue().cast<IntegerAttr>().getInt() !=
+          indexB.getValue().cast<IntegerAttr>().getInt())
         return true;
     } else {
       // For this dimension, we slice a part of the memref we need to make sure
       // the intervals accessed don't overlap.
-      int64_t distance = std::abs(indexA.value().cast<IntegerAttr>().getInt() -
-                                  indexB.value().cast<IntegerAttr>().getInt());
+      int64_t distance =
+          std::abs(indexA.getValue().cast<IntegerAttr>().getInt() -
+                   indexB.getValue().cast<IntegerAttr>().getInt());
       if (distance >= transferA.getVectorType().getDimSize(i - rankOffset))
         return true;
     }
   }
   return false;
 }
 
 bool mlir::isDisjointTransferSet(VectorTransferOpInterface transferA,

mlir/lib/TableGen/Operator.cpp

getGetterOrSetterNames(bool isGetter, const Operator &op, StringRef name) {
   Dialect::EmitPrefix prefixType = op.getDialect().getEmitAccessorPrefix();
   std::string prefix;
   if (prefixType != Dialect::EmitPrefix::Raw)
     prefix = isGetter ? "get" : "set";
 
   SmallVector<std::string, 2> names;
   bool rawToo = prefixType == Dialect::EmitPrefix::Both;
 
+  // Whether to skip generating prefixed form for argument. This just does some
+  // basic checks.
+  //
+  // There are a little bit more invasive checks possible for cases where not
+  // all ops have the trait that would cause overlap. For many cases here,
+  // renaming would be better (e.g., we can only guard in limited manner against
+  // methods from traits and interfaces here, so avoiding these in op definition
+  // is safer).
   auto skip = [&](StringRef newName) {
-    bool shouldSkip = newName == "getOperands";
+    bool shouldSkip = newName == "getAttributeNames" ||
+                      newName == "getAttributes" || newName == "getOperation" ||
+                      newName == "getType";
+    if (newName == "getOperands") {
+      // To reduce noise, skip generating the prefixed form and the warning if
+      // $operands correspond to single variadic argument.
+      if (op.getNumOperands() == 1 && op.getNumVariableLengthOperands() == 1)
+        return true;
+      shouldSkip = true;
+    }
     if (!shouldSkip)
       return false;
 
     // This note could be avoided where the final function generated would
     // have been identical. But preferably in the op definition avoiding using
     // the generic name and then getting a more specialize type is better.
     PrintNote(op.getLoc(),
               "Skipping generation of prefixed accessor `" + newName +
                   "` as it overlaps with default one; generating raw form (`" +
                   name + "`) still");
     return true;
   };
 
   if (!prefix.empty()) {
     names.push_back(
         prefix + convertToCamelFromSnakeCase(name, /*capitalizeFirst=*/true));
     // Skip cases which would overlap with default ones for now.
     if (skip(names.back())) {
       rawToo = true;
       names.clear();
-    } else {
+    } else if (rawToo) {
       LLVM_DEBUG(llvm::errs() << "WITH_GETTER(\"" << op.getQualCppClassName()
-                              << "::" << names.back() << "\");\n"
+                              << "::" << name << "\")\n"
                               << "WITH_GETTER(\"" << op.getQualCppClassName()
-                              << "Adaptor::" << names.back() << "\");\n";);
+                              << "Adaptor::" << name << "\")\n";);
     }
   }
 
   if (prefix.empty() || rawToo)
     names.push_back(name.str());
   return names;
 }
 
 SmallVector<std::string, 2> Operator::getGetterNames(StringRef name) const {
   return getGetterOrSetterNames(/*isGetter=*/true, *this, name);
 }
 
 SmallVector<std::string, 2> Operator::getSetterNames(StringRef name) const {
   return getGetterOrSetterNames(/*isGetter=*/false, *this, name);
 }

mlir/lib/Target/Cpp/TranslateToCpp.cpp

static LogicalResult printOperation(CppEmitter &emitter,
   Attribute value = constantOp.value();
 
   return printConstantOp(emitter, operation, value);
 }
 
 static LogicalResult printOperation(CppEmitter &emitter,
                                     arith::ConstantOp constantOp) {
   Operation *operation = constantOp.getOperation();
-  Attribute value = constantOp.value();
+  Attribute value = constantOp.getValue();
 
   return printConstantOp(emitter, operation, value);
 }
 
 static LogicalResult printOperation(CppEmitter &emitter,
                                     mlir::ConstantOp constantOp) {
   Operation *operation = constantOp.getOperation();
-  Attribute value = constantOp.value();
+  Attribute value = constantOp.getValue();
 
   return printConstantOp(emitter, operation, value);
 }
 
 static LogicalResult printOperation(CppEmitter &emitter, BranchOp branchOp) {
   raw_ostream &os = emitter.ostream();
   Block &successor = *branchOp.getSuccessor();
 

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

if (GV->hasInitializer() && !valueAttr) {
     currentEntryBlock = b.createBlock(&r);
     b.setInsertionPoint(currentEntryBlock, currentEntryBlock->begin());
     Value v = processConstant(GV->getInitializer());
     if (!v)
       return nullptr;
     b.create<ReturnOp>(op.getLoc(), ArrayRef<Value>({v}));
   }
   if (GV->hasAtLeastLocalUnnamedAddr())
-    op.unnamed_addrAttr(UnnamedAddrAttr::get(
+    op.setUnnamedAddrAttr(UnnamedAddrAttr::get(
         context, convertUnnamedAddrFromLLVM(GV->getUnnamedAddr())));
   if (GV->hasSection())
-    op.sectionAttr(b.getStringAttr(GV->getSection()));
+    op.setSectionAttr(b.getStringAttr(GV->getSection()));
 
   return globals[GV] = op;
 }
 
 Value Importer::processConstant(llvm::Constant *c) {
   OpBuilder bEntry(currentEntryBlock, currentEntryBlock->begin());
   if (Attribute attr = getConstantAsAttr(c)) {
     // These constants can be represented as attributes.

mlir/lib/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.cpp

if (isa<LLVM::CallOp>(opInst)) {
     // Check that LLVM call returns void for 0-result functions.
     return success(result->getType()->isVoidTy());
   }
 
   if (auto inlineAsmOp = dyn_cast<LLVM::InlineAsmOp>(opInst)) {
     // TODO: refactor function type creation which usually occurs in std-LLVM
     // conversion.
     SmallVector<Type, 8> operandTypes;
-    operandTypes.reserve(inlineAsmOp.operands().size());
-    for (auto t : inlineAsmOp.operands().getTypes())
+    operandTypes.reserve(inlineAsmOp.getOperands().size());
+    for (auto t : inlineAsmOp.getOperands().getTypes())
       operandTypes.push_back(t);
 
     Type resultType;
     if (inlineAsmOp.getNumResults() == 0) {
       resultType = LLVM::LLVMVoidType::get(&moduleTranslation.getContext());
     } else {
       assert(inlineAsmOp.getNumResults() == 1);
       resultType = inlineAsmOp.getResultTypes()[0];
     }
     auto ft = LLVM::LLVMFunctionType::get(resultType, operandTypes);
     llvm::InlineAsm *inlineAsmInst =
         inlineAsmOp.asm_dialect().hasValue()
             ? llvm::InlineAsm::get(
                   static_cast<llvm::FunctionType *>(
                       moduleTranslation.convertType(ft)),
                   inlineAsmOp.asm_string(), inlineAsmOp.constraints(),
                   inlineAsmOp.has_side_effects(), inlineAsmOp.is_align_stack(),
                   convertAsmDialectToLLVM(*inlineAsmOp.asm_dialect()))
             : llvm::InlineAsm::get(
                   static_cast<llvm::FunctionType *>(
                       moduleTranslation.convertType(ft)),
                   inlineAsmOp.asm_string(), inlineAsmOp.constraints(),
                   inlineAsmOp.has_side_effects(), inlineAsmOp.is_align_stack());
     llvm::Value *result = builder.CreateCall(
-        inlineAsmInst, moduleTranslation.lookupValues(inlineAsmOp.operands()));
+        inlineAsmInst,
+        moduleTranslation.lookupValues(inlineAsmOp.getOperands()));
     if (opInst.getNumResults() != 0)
       moduleTranslation.mapValue(opInst.getResult(0), result);
     return success();
   }
 
   if (auto invOp = dyn_cast<LLVM::InvokeOp>(opInst)) {
     auto operands = moduleTranslation.lookupValues(opInst.getOperands());
     ArrayRef<llvm::Value *> operandsRef(operands);
#include "mlir/Dialect/LLVMIR/LLVMConversions.inc"
   if (auto brOp = dyn_cast<LLVM::BrOp>(opInst)) {
     llvm::BranchInst *branch =
         builder.CreateBr(moduleTranslation.lookupBlock(brOp.getSuccessor()));
     moduleTranslation.mapBranch(&opInst, branch);
     setLoopMetadata(opInst, *branch, builder, moduleTranslation);
     return success();
   }
   if (auto condbrOp = dyn_cast<LLVM::CondBrOp>(opInst)) {
-    auto weights = condbrOp.branch_weights();
+    auto weights = condbrOp.getBranchWeights();
     llvm::MDNode *branchWeights = nullptr;
     if (weights) {
       // Map weight attributes to LLVM metadata.
       auto trueWeight =
           weights.getValue().getValue(0).cast<IntegerAttr>().getInt();
       auto falseWeight =
           weights.getValue().getValue(1).cast<IntegerAttr>().getInt();
       branchWeights =

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

static Value getPHISourceValue(Block *current, Block *pred,
   (void)successors;
 
   // For instructions that branch based on a condition value, we need to take
   // the operands for the branch that was taken.
   if (auto condBranchOp = dyn_cast<LLVM::CondBrOp>(terminator)) {
     // For conditional branches, we take the operands from either the "true" or
     // the "false" branch.
     return condBranchOp.getSuccessor(0) == current
-               ? condBranchOp.trueDestOperands()[index]
-               : condBranchOp.falseDestOperands()[index];
+               ? condBranchOp.getTrueDestOperands()[index]
+               : condBranchOp.getFalseDestOperands()[index];
   }
 
   if (auto switchOp = dyn_cast<LLVM::SwitchOp>(terminator)) {
     // For switches, we take the operands from either the default case, or from
     // the case branch that was taken.
     if (switchOp.defaultDestination() == current)
       return switchOp.defaultOperands()[index];
     for (auto i : llvm::enumerate(switchOp.caseDestinations()))
if (op.getValueOrNull()) {
             llvmModule->getContext(), strAttr.getValue(), /*AddNull=*/false);
         type = cst->getType();
       } else if (!(cst = getLLVMConstant(type, op.getValueOrNull(), op.getLoc(),
                                          *this))) {
         return failure();
       }
     }
 
-    auto linkage = convertLinkageToLLVM(op.linkage());
-    auto addrSpace = op.addr_space();
+    auto linkage = convertLinkageToLLVM(op.getLinkage());
+    auto addrSpace = op.getAddrSpace();
 
     // LLVM IR requires constant with linkage other than external or weak
     // external to have initializers. If MLIR does not provide an initializer,
     // default to undef.
     bool dropInitializer = shouldDropGlobalInitializer(linkage, cst);
     if (!dropInitializer && !cst)
       cst = llvm::UndefValue::get(type);
     else if (dropInitializer && cst)
       cst = nullptr;
 
     auto *var = new llvm::GlobalVariable(
-        *llvmModule, type, op.constant(), linkage, cst, op.sym_name(),
+        *llvmModule, type, op.getConstant(), linkage, cst, op.getSymName(),
         /*InsertBefore=*/nullptr, llvm::GlobalValue::NotThreadLocal, addrSpace);
 
-    if (op.unnamed_addr().hasValue())
-      var->setUnnamedAddr(convertUnnamedAddrToLLVM(*op.unnamed_addr()));
+    if (op.getUnnamedAddr().hasValue())
+      var->setUnnamedAddr(convertUnnamedAddrToLLVM(*op.getUnnamedAddr()));
 
-    if (op.section().hasValue())
-      var->setSection(*op.section());
+    if (op.getSection().hasValue())
+      var->setSection(*op.getSection());
 
-    addRuntimePreemptionSpecifier(op.dso_local(), var);
+    addRuntimePreemptionSpecifier(op.getDsoLocal(), var);
 
-    Optional<uint64_t> alignment = op.alignment();
+    Optional<uint64_t> alignment = op.getAlignment();
     if (alignment.hasValue())
       var->setAlignment(llvm::MaybeAlign(alignment.getValue()));
 
     globalsMapping.try_emplace(op, var);
   }
 
   // Convert global variable bodies. This is done after all global variables
   // have been created in LLVM IR because a global body may refer to another

 LogicalResult ModuleTranslation::createAliasScopeMetadata() {
   mlirModule->walk([&](LLVM::MetadataOp metadatas) {
     // Create the domains first, so they can be reference below in the scopes.
     DenseMap<Operation *, llvm::MDNode *> aliasScopeDomainMetadataMapping;
     metadatas.walk([&](LLVM::AliasScopeDomainMetadataOp op) {
       llvm::LLVMContext &ctx = llvmModule->getContext();
       llvm::SmallVector<llvm::Metadata *, 2> operands;
       operands.push_back({}); // Placeholder for self-reference
-      if (Optional<StringRef> description = op.description())
+      if (Optional<StringRef> description = op.getDescription())
         operands.push_back(llvm::MDString::get(ctx, description.getValue()));
       llvm::MDNode *domain = llvm::MDNode::get(ctx, operands);
       domain->replaceOperandWith(0, domain); // Self-reference for uniqueness
       aliasScopeDomainMetadataMapping.insert({op, domain});
     });
 
     // Now create the scopes, referencing the domains created above.
     metadatas.walk([&](LLVM::AliasScopeMetadataOp op) {
       llvm::LLVMContext &ctx = llvmModule->getContext();
       assert(isa<LLVM::MetadataOp>(op->getParentOp()));
       auto metadataOp = dyn_cast<LLVM::MetadataOp>(op->getParentOp());
       Operation *domainOp =
-          SymbolTable::lookupNearestSymbolFrom(metadataOp, op.domainAttr());
+          SymbolTable::lookupNearestSymbolFrom(metadataOp, op.getDomainAttr());
       llvm::MDNode *domain = aliasScopeDomainMetadataMapping.lookup(domainOp);
       assert(domain && "Scope's domain should already be valid");
       llvm::SmallVector<llvm::Metadata *, 3> operands;
       operands.push_back({}); // Placeholder for self-reference
       operands.push_back(domain);
-      if (Optional<StringRef> description = op.description())
+      if (Optional<StringRef> description = op.getDescription())
         operands.push_back(llvm::MDString::get(ctx, description.getValue()));
       llvm::MDNode *scope = llvm::MDNode::get(ctx, operands);
       scope->replaceOperandWith(0, scope); // Self-reference for uniqueness
       aliasScopeMetadataMapping.insert({op, scope});
     });
   });
   return success();
 }

mlir/lib/Transforms/BufferResultsToOutParams.cpp

for (Value memref : replaceWithOutParams) {
       memref.replaceAllUsesWith(outParam);
       outParams.push_back(outParam);
     }
 
     auto newOperands = llvm::to_vector<6>(op.getOperands());
     newOperands.append(outParams.begin(), outParams.end());
     auto newResultTypes = llvm::to_vector<6>(llvm::map_range(
         replaceWithNewCallResults, [](Value v) { return v.getType(); }));
-    auto newCall = builder.create<CallOp>(op.getLoc(), op.calleeAttr(),
+    auto newCall = builder.create<CallOp>(op.getLoc(), op.getCalleeAttr(),
                                           newResultTypes, newOperands);
     for (auto t : llvm::zip(replaceWithNewCallResults, newCall.getResults()))
       std::get<0>(t).replaceAllUsesWith(std::get<1>(t));
     op.erase();
   });
 
   return failure(didFail);
 }

mlir/lib/Transforms/NormalizeMemRefs.cpp

for (FuncOp &funcOp : normalizableFuncs) {
                                             normalizableFuncs);
         break;
       }
     }
   }
 
   // Functions called by this function.
   funcOp.walk([&](CallOp callOp) {
-    StringAttr callee = callOp.getCalleeAttr();
+    StringAttr callee = callOp.getCalleeAttr().getAttr();
     for (FuncOp &funcOp : normalizableFuncs) {
       // We compare FuncOp and callee's name.
       if (callee == funcOp.getNameAttr()) {
         setCalleesAndCallersNonNormalizable(funcOp, moduleOp,
                                             normalizableFuncs);
         break;
       }
     }