[mlir] Flip Vector dialect accessors used to prefixed form.

[jpienaar]

Summary

This has been on _Both for a couple of weeks. Flip usages in core with
intention to flip flag to _Prefixed in follow up. Needed to add a couple
of helper methods in AffineOps and Linalg to facilitate a pure flag flip
in follow up as some of these classes are used in templates and so
sensitive to Vector dialect changes.

[rriddle]

Awesome, thanks!

mlir/include/mlir/Dialect/Affine/IR/AffineOps.td

code extraClassDeclarationBase = [{
     void setMemRef(Value value) { setOperand(getMemRefOperandIndex(), value); }
 
     /// Returns the affine map used to index the memref for this operation.
     AffineMapAttr getAffineMapAttr() {
       return (*this)->getAttr(getMapAttrName()).cast<AffineMapAttr>();
     }
 
     static StringRef getMapAttrName() { return "map"; }
+
+    // TODO: Remove once prefixing is flipped.
+    operand_range getIndices() { return indices(); }
   }];
 }
 
 def AffineLoadOp : AffineLoadOpBase<"load"> {
   let summary = "affine load operation";
   let description = [{
     The "affine.load" op reads an element from a memref, where the index
     for each memref dimension is an affine expression of loop induction
code extraClassDeclarationBase = [{
     void setMemRef(Value value) { setOperand(getMemRefOperandIndex(), value); }
 
     /// Returns the affine map used to index the memref for this operation.
     AffineMapAttr getAffineMapAttr() {
       return (*this)->getAttr(getMapAttrName()).cast<AffineMapAttr>();
     }
 
     static StringRef getMapAttrName() { return "map"; }
+
+    // TODO: Remove once prefixing is flipped.
+    operand_range getIndices() { return indices(); }
   }];
 }
 
 def AffineStoreOp : AffineStoreOpBase<"store"> {
   let summary = "affine store operation";
   let description = [{
     The "affine.store" op writes an element to a memref, where the index
     for each memref dimension is an affine expression of loop induction

mlir/include/mlir/Dialect/Linalg/IR/LinalgInterfaces.td

let extraClassDeclaration = [{
     /// `createFlatListOfOperandStaticDims`.
     SmallVector<int64_t, 4> computeStaticLoopSizes();
 
     /// Returns the value that expresses the shape of the output in terms of
     /// shape of the input operands where possible
     LogicalResult reifyResultShapes(OpBuilder &b,
         ReifiedRankedShapedTypeDims &reifiedReturnShapes);
 
+    // TODO: Remove once prefixing is flipped.
+    ArrayAttr getIteratorTypes() { return iterator_types(); }
+
     //========================================================================//
     // Helper functions to mutate the `operand_segment_sizes` attribute.
     // These are useful when cloning and changing operand types.
     //========================================================================//
     void setNumInputs(unsigned num) { setOperandSegmentAt(0, num); }
     void setNumOutputBuffers(unsigned num) { setOperandSegmentAt(1, num); }
 
     private:

mlir/include/mlir/Dialect/Utils/StructuredOpsUtils.h

struct Red : public IteratorType {
     Red() : IteratorType(getReductionIteratorTypeName()) {}
   };
   struct Win : public IteratorType {
     Win() : IteratorType(getWindowIteratorTypeName()) {}
   };
 
   StructuredGenerator(OpBuilder &builder, StructuredOpInterface op)
       : builder(builder), ctx(op.getContext()), loc(op.getLoc()),
-        iterators(op.iterator_types()), maps(op.getIndexingMaps()), op(op) {}
+        iterators(op.getIteratorTypes()), maps(op.getIndexingMaps()), op(op) {}
 
   bool iters(ArrayRef<IteratorType> its) {
     if (its.size() != iterators.size())
       return false;
     for (int i = 0, e = its.size(); i != e; ++i) {
       if (!its[i].isOfType(iterators[i]))
         return false;
     }

mlir/include/mlir/Dialect/Vector/IR/VectorOps.td

OpBuilder<(ins "Value":$lhs, "Value":$rhs, "Value":$acc,
       "ArrayRef<ArrayRef<AffineExpr>>":$indexingExprs,
       "ArrayRef<StringRef>":$iteratorTypes)>,
     OpBuilder<(ins "Value":$lhs, "Value":$rhs, "Value":$acc,
       "ArrayAttr":$indexingMaps, "ArrayAttr":$iteratorTypes,
       "CombiningKind":$kind)>
   ];
   let extraClassDeclaration = [{
     VectorType getLhsType() {
-      return lhs().getType().cast<VectorType>();
+      return getLhs().getType().cast<VectorType>();
     }
     VectorType getRhsType() {
-      return rhs().getType().cast<VectorType>();
+      return getRhs().getType().cast<VectorType>();
     }
-    Type getAccType() { return acc().getType(); }
+    Type getAccType() { return getAcc().getType(); }
     VectorType getLHSVectorMaskType() {
-      if (llvm::size(masks()) != 2) return VectorType();
+      if (llvm::size(getMasks()) != 2) return VectorType();
       return getOperand(3).getType().cast<VectorType>();
     }
     VectorType getRHSVectorMaskType() {
-      if (llvm::size(masks()) != 2) return VectorType();
+      if (llvm::size(getMasks()) != 2) return VectorType();
       return getOperand(4).getType().cast<VectorType>();
     }
     Type getResultType() { return getResult().getType(); }
     ArrayRef<StringRef> getTraitAttrNames();
     static unsigned getAccOperandIndex() { return 2; }
 
     // Returns the bounds of each dimension in the iteration space spanned
     // by the iterator types of this operation.
let description = [{
 
     %3 = vector.reduction <xor>, %2 : vector<4xi32> into i32
 
     %4 = vector.reduction <mul>, %0, %1 : vector<16xf32> into f32
     ```
   }];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
   }];
   let builders = [
     // Builder that infers the type of `dest`.
     OpBuilder<(ins "CombiningKind":$kind, "Value":$vector, "Value":$acc)>,
     // Builder that infers the type of `dest` and has no accumulator.
     OpBuilder<(ins "CombiningKind":$kind, "Value":$vector)>
   ];
let builders = [
     OpBuilder<(ins "Value":$source, "ArrayRef<bool>":$reductionMask,
                    "CombiningKind":$kind)>
   ];
   let extraClassDeclaration = [{
     static StringRef getKindAttrStrName() { return "kind"; }
     static StringRef getReductionDimsAttrStrName() { return "reduction_dims"; }
 
     VectorType getSourceVectorType() {
-      return source().getType().cast<VectorType>();
+      return getSource().getType().cast<VectorType>();
     }
     Type getDestType() {
-      return dest().getType();
+      return getDest().getType();
     }
 
     bool isReducedDim(int64_t d) {
       assert(d >= 0 && d < static_cast<int64_t>(getReductionMask().size()) &&
         "d overflows the number of dims");
       return getReductionMask()[d];
     }
 
     SmallVector<bool> getReductionMask() {
       SmallVector<bool> res(getSourceVectorType().getRank(), false);
-      for (auto ia : reduction_dims().getAsRange<IntegerAttr>())
+      for (auto ia : getReductionDims().getAsRange<IntegerAttr>())
         res[ia.getInt()] = true;
       return res;
     }
     static SmallVector<bool> getReductionMask(
         ArrayRef<int64_t> reductionDims, unsigned sourceRank) {
       SmallVector<bool> res(sourceRank, false);
       for (auto idx : reductionDims)
         res[idx] = true;
let description = [{
 
     ```mlir
     %0 = arith.constant 0.0 : f32
     %1 = vector.broadcast %0 : f32 to vector<16xf32>
     %2 = vector.broadcast %1 : vector<16xf32> to vector<4x16xf32>
     ```
   }];
   let extraClassDeclaration = [{
-    Type getSourceType() { return source().getType(); }
+    Type getSourceType() { return getSource().getType(); }
     VectorType getVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($vector)";
   let hasFolder = 1;
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
def Vector_ShuffleOp :
   }];
   let builders = [
     OpBuilder<(ins "Value":$v1, "Value":$v2, "ArrayRef<int64_t>")>
   ];
   let hasFolder = 1;
   let extraClassDeclaration = [{
     static StringRef getMaskAttrStrName() { return "mask"; }
     VectorType getV1VectorType() {
-      return v1().getType().cast<VectorType>();
+      return getV1().getType().cast<VectorType>();
     }
     VectorType getV2VectorType() {
-      return v2().getType().cast<VectorType>();
+      return getV2().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "operands $mask attr-dict `:` type(operands)";
   let hasVerifier = 1;
 }
 
 def Vector_ExtractElementOp :
   Vector_Op<"extractelement", [NoSideEffect,
def Vector_ExtractElementOp :
   let builders = [
     // 0-D builder.
     OpBuilder<(ins "Value":$source)>,
     // 1-D + position builder.
     OpBuilder<(ins "Value":$source, "Value":$position)>,
   ];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
   }];
   let hasVerifier = 1;
 }
 
 def Vector_ExtractOp :
   Vector_Op<"extract", [NoSideEffect,
      PredOpTrait<"operand and result have same element type",
let builders = [
     OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes the values in `position` are defined by
     // ConstantIndexOp.
     OpBuilder<(ins "Value":$source, "ValueRange":$position)>
   ];
   let extraClassDeclaration = [{
     static StringRef getPositionAttrStrName() { return "position"; }
     VectorType getVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
     static bool isCompatibleReturnTypes(TypeRange l, TypeRange r);
   }];
   let assemblyFormat = "$vector `` $position attr-dict `:` type($vector)";
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
let description = [{
     ```
   }];
   let builders = [
     OpBuilder<(ins "Value":$vector, "ValueRange":$ids,
                   "ArrayRef<int64_t>":$multiplicity,
                   "AffineMap":$map)>];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return getResult().getType().cast<VectorType>();
     }
     void getMultiplicity(SmallVectorImpl<int64_t> &multiplicity);
     AffineMap map();
   }];
   let assemblyFormat = [{
let description = [{
     Example:
 
     ```mlir
     %3 = vector.fma %0, %1, %2: vector<8x16xf32>
     ```
   }];
   let assemblyFormat = "$lhs `,` $rhs `,` $acc attr-dict `:` type($lhs)";
   let extraClassDeclaration = [{
-    VectorType getVectorType() { return lhs().getType().cast<VectorType>(); }
+    VectorType getVectorType() { return getLhs().getType().cast<VectorType>(); }
   }];
 }
 
 def Vector_InsertElementOp :
   Vector_Op<"insertelement", [NoSideEffect,
      TypesMatchWith<"source operand type matches element type of result",
                     "result", "source",
                     "$_self.cast<ShapedType>().getElementType()">,
let assemblyFormat = [{
     type($result)
   }];
 
   let builders = [
     // 0-D builder.
     OpBuilder<(ins "Value":$source, "Value":$dest)>,
   ];
   let extraClassDeclaration = [{
-    Type getSourceType() { return source().getType(); }
+    Type getSourceType() { return getSource().getType(); }
     VectorType getDestVectorType() {
-      return dest().getType().cast<VectorType>();
+      return getDest().getType().cast<VectorType>();
     }
   }];
   let hasVerifier = 1;
 }
 
 def Vector_InsertOp :
   Vector_Op<"insert", [NoSideEffect,
      PredOpTrait<"source operand and result have same element type",
def Vector_InsertOp :
   let builders = [
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<int64_t>":$position)>,
     // Convenience builder which assumes all values are constant indices.
     OpBuilder<(ins "Value":$source, "Value":$dest, "ValueRange":$position)>
   ];
   let extraClassDeclaration = [{
     static StringRef getPositionAttrStrName() { return "position"; }
-    Type getSourceType() { return source().getType(); }
+    Type getSourceType() { return getSource().getType(); }
     VectorType getDestVectorType() {
-      return dest().getType().cast<VectorType>();
+      return getDest().getType().cast<VectorType>();
     }
   }];
 
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
 
let description = [{
     ```mlir
     %v = vector.insert_map %ev %v[%id] : vector<1xf32> into vector<32xf32>
     %v1 = vector.insert_map %ev1, %v1[%arg0, %arg1] : vector<2x4x1xf32>
       into vector<64x4x32xf32>
     ```
   }];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
       return getResult().getType().cast<VectorType>();
     }
     // Return a map indicating the dimension mapping to the given ids.
     AffineMap map();
   }];
   let assemblyFormat = [{
def Vector_InsertStridedSliceOp :
   let builders = [
     OpBuilder<(ins "Value":$source, "Value":$dest,
       "ArrayRef<int64_t>":$offsets, "ArrayRef<int64_t>":$strides)>
   ];
   let extraClassDeclaration = [{
     static StringRef getOffsetsAttrStrName() { return "offsets"; }
     static StringRef getStridesAttrStrName() { return "strides"; }
     VectorType getSourceVectorType() {
-      return source().getType().cast<VectorType>();
+      return getSource().getType().cast<VectorType>();
     }
     VectorType getDestVectorType() {
-      return dest().getType().cast<VectorType>();
+      return getDest().getType().cast<VectorType>();
     }
     bool hasNonUnitStrides() {
-      return llvm::any_of(strides(), [](Attribute attr) {
+      return llvm::any_of(getStrides(), [](Attribute attr) {
         return attr.cast<IntegerAttr>().getInt() != 1;
       });
     }
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 }
let description = [{
     ```
   }];
   let builders = [
     // Build an op without mask, use the type of `acc` as the return type.
     OpBuilder<(ins "Value":$lhs, "Value":$rhs, "Value":$acc)>
   ];
   let extraClassDeclaration = [{
     VectorType getOperandVectorTypeLHS() {
-      return lhs().getType().cast<VectorType>();
+      return getLhs().getType().cast<VectorType>();
     }
     Type getOperandTypeRHS() {
-      return rhs().getType();
+      return getRhs().getType();
     }
     VectorType getOperandVectorTypeACC() {
-      return (llvm::size(acc()) == 0)
+      return (llvm::size(getAcc()) == 0)
         ? VectorType()
-        : (*acc().begin()).getType().cast<VectorType>();
+        : (*getAcc().begin()).getType().cast<VectorType>();
     }
     VectorType getVectorType() {
       return getResult().getType().cast<VectorType>();
     }
     static constexpr StringRef getKindAttrStrName() {
       return "kind";
     }
     static CombiningKind getDefaultKind() {
Example
                         [i, -, -, -]],
                        [[j, k, l, m],
                         [n, o, p, q],
                         [r, -, -, -]]]
   }];
 
   let extraClassDeclaration = [{
     VectorType getInputVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
     VectorType getOutputVectorType() {
       return getResult().getType().cast<VectorType>();
     }
 
     /// Returns as integer value the number of input shape operands.
-    int64_t getNumInputShapeSizes() { return input_shape().size(); }
+    int64_t getNumInputShapeSizes() { return getInputShape().size(); }
 
     /// Returns as integer value the number of output shape operands.
-    int64_t getNumOutputShapeSizes() { return output_shape().size(); }
+    int64_t getNumOutputShapeSizes() { return getOutputShape().size(); }
 
     void getFixedVectorSizes(SmallVectorImpl<int64_t> &results);
 
     static StringRef getFixedVectorSizesAttrStrName() {
       return "fixed_vector_sizes";
     }
     static StringRef getInputShapeAttrStrName() { return "input_shape"; }
     static StringRef getOutputShapeAttrStrName() { return "output_shape"; }
def Vector_ExtractStridedSliceOp :
   let builders = [
     OpBuilder<(ins "Value":$source, "ArrayRef<int64_t>":$offsets,
       "ArrayRef<int64_t>":$sizes, "ArrayRef<int64_t>":$strides)>
   ];
   let extraClassDeclaration = [{
     static StringRef getOffsetsAttrStrName() { return "offsets"; }
     static StringRef getSizesAttrStrName() { return "sizes"; }
     static StringRef getStridesAttrStrName() { return "strides"; }
-    VectorType getVectorType(){ return vector().getType().cast<VectorType>(); }
+    VectorType getVectorType(){ return getVector().getType().cast<VectorType>(); }
     void getOffsets(SmallVectorImpl<int64_t> &results);
     bool hasNonUnitStrides() {
-      return llvm::any_of(strides(), [](Attribute attr) {
+      return llvm::any_of(getStrides(), [](Attribute attr) {
         return attr.cast<IntegerAttr>().getInt() != 1;
       });
     }
   }];
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
   let assemblyFormat = "$vector attr-dict `:` type($vector) `to` type(results)";
def Vector_LoadOp : Vector_Op<"load"> {
 
   let arguments = (ins Arg<AnyMemRef, "the reference to load from",
       [MemRead]>:$base,
       Variadic<Index>:$indices);
   let results = (outs AnyVector:$result);
 
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
 
     VectorType getVectorType() {
-      return result().getType().cast<VectorType>();
+      return getResult().getType().cast<VectorType>();
     }
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 
   let assemblyFormat =
       "$base `[` $indices `]` attr-dict `:` type($base) `,` type($result)";
def Vector_StoreOp : Vector_Op<"store"> {
 
   let arguments = (ins AnyVector:$valueToStore,
       Arg<AnyMemRef, "the reference to store to",
       [MemWrite]>:$base,
       Variadic<Index>:$indices);
 
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
 
     VectorType getVectorType() {
-      return valueToStore().getType().cast<VectorType>();
+      return getValueToStore().getType().cast<VectorType>();
     }
   }];
 
   let hasFolder = 1;
   let hasVerifier = 1;
 
   let assemblyFormat = "$valueToStore `,` $base `[` $indices `]` attr-dict "
                        "`:` type($base) `,` type($valueToStore)";
%0 = vector.maskedload %base[%i], %mask, %pass_thru
        : memref<?xf32>, vector<8xi1>, vector<8xf32> into vector<8xf32>
 
     %1 = vector.maskedload %base[%i, %j], %mask, %pass_thru
        : memref<?x?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>
     ```
   }];
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
     VectorType getMaskVectorType() {
-      return mask().getType().cast<VectorType>();
+      return getMask().getType().cast<VectorType>();
     }
     VectorType getPassThruVectorType() {
-      return pass_thru().getType().cast<VectorType>();
+      return getPassThru().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
-      return result().getType().cast<VectorType>();
+      return getResult().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$base `[` $indices `]` `,` $mask `,` $pass_thru attr-dict `:` "
     "type($base) `,` type($mask) `,` type($pass_thru) `into` type($result)";
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
 }
vector.maskedstore %base[%i], %mask, %value
       : memref<?xf32>, vector<8xi1>, vector<8xf32>
 
     vector.maskedstore %base[%i, %j], %mask, %value
       : memref<?x?xf32>, vector<16xi1>, vector<16xf32>
     ```
   }];
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
     VectorType getMaskVectorType() {
-      return mask().getType().cast<VectorType>();
+      return getMask().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
-      return valueToStore().getType().cast<VectorType>();
+      return getValueToStore().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
       "$base `[` $indices `]` `,` $mask `,` $valueToStore "
       "attr-dict `:` type($base) `,` type($mask) `,` type($valueToStore)";
   let hasCanonicalizer = 1;
   let hasFolder = 1;
   let hasVerifier = 1;
%0 = vector.gather %base[%c0][%v], %mask, %pass_thru
        : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>
 
     %1 = vector.gather %base[%i, %j][%v], %mask, %pass_thru
        : memref<16x16xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32> into vector<16xf32>
     ```
   }];
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
     VectorType getIndexVectorType() {
-      return index_vec().getType().cast<VectorType>();
+      return getIndexVec().getType().cast<VectorType>();
     }
     VectorType getMaskVectorType() {
-      return mask().getType().cast<VectorType>();
+      return getMask().getType().cast<VectorType>();
     }
     VectorType getPassThruVectorType() {
-      return pass_thru().getType().cast<VectorType>();
+      return getPassThru().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
-      return result().getType().cast<VectorType>();
+      return getResult().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
     "$base `[` $indices `]` `[` $index_vec `]` `,` "
     "$mask `,` $pass_thru attr-dict `:` type($base) `,` "
     "type($index_vec)  `,` type($mask) `,` type($pass_thru) "
     "`into` type($result)";
   let hasCanonicalizer = 1;
vector.scatter %base[%c0][%v], %mask, %value
         : memref<?xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32>
 
     vector.scatter %base[%i, %j][%v], %mask, %value
         : memref<16x16xf32>, vector<16xi32>, vector<16xi1>, vector<16xf32>
     ```
   }];
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
     VectorType getIndexVectorType() {
-      return index_vec().getType().cast<VectorType>();
+      return getIndexVec().getType().cast<VectorType>();
     }
     VectorType getMaskVectorType() {
-      return mask().getType().cast<VectorType>();
+      return getMask().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
-      return valueToStore().getType().cast<VectorType>();
+      return getValueToStore().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
       "$base `[` $indices `]` `[` $index_vec `]` `,` "
       "$mask `,` $valueToStore attr-dict `:` type($base) `,` "
       "type($index_vec)  `,` type($mask) `,` type($valueToStore)";
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
%0 = vector.expandload %base[%i], %mask, %pass_thru
        : memref<?xf32>, vector<8xi1>, vector<8xf32> into vector<8xf32>
 
     %1 = vector.expandload %base[%i, %j], %mask, %pass_thru
        : memref<?x?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>
     ```
   }];
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
     VectorType getMaskVectorType() {
-      return mask().getType().cast<VectorType>();
+      return getMask().getType().cast<VectorType>();
     }
     VectorType getPassThruVectorType() {
-      return pass_thru().getType().cast<VectorType>();
+      return getPassThru().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
-      return result().getType().cast<VectorType>();
+      return getResult().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$base `[` $indices `]` `,` $mask `,` $pass_thru attr-dict `:` "
     "type($base) `,` type($mask) `,` type($pass_thru) `into` type($result)";
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
 
vector.compressstore %base[%i], %mask, %value
       : memref<?xf32>, vector<8xi1>, vector<8xf32>
 
     vector.compressstore %base[%i, %j], %mask, %value
       : memref<?x?xf32>, vector<16xi1>, vector<16xf32>
     ```
   }];
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return base().getType().cast<MemRefType>();
+      return getBase().getType().cast<MemRefType>();
     }
     VectorType getMaskVectorType() {
-      return mask().getType().cast<VectorType>();
+      return getMask().getType().cast<VectorType>();
     }
     VectorType getVectorType() {
-      return valueToStore().getType().cast<VectorType>();
+      return getValueToStore().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
       "$base `[` $indices `]` `,` $mask `,` $valueToStore attr-dict `:` "
       "type($base) `,` type($mask) `,` type($valueToStore)";
   let hasCanonicalizer = 1;
   let hasVerifier = 1;
 }
let description = [{
 
     // Example casting to a higher vector rank.
     %3 = vector.shape_cast %2 : vector<10x12x8xf32> to vector<5x2x3x4x8xf32>
 
     ```
   }];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
-      return source().getType().cast<VectorType>();
+      return getSource().getType().cast<VectorType>();
     }
     VectorType getResultVectorType() {
       return getResult().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
   let hasFolder = 1;
   let hasCanonicalizer = 1;
let description = [{
     %5 = vector.bitcast %4 : vector<5x1x4x3xf32> to vector<5x1x4x3xi32>
 
     // Example casting of 0-D vectors.
     %7 = vector.bitcast %6 : vector<f32> to vector<i32>
     ```
   }];
   let extraClassDeclaration = [{
     VectorType getSourceVectorType() {
-      return source().getType().cast<VectorType>();
+      return getSource().getType().cast<VectorType>();
     }
     VectorType getResultVectorType() {
       return getResult().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
   let hasFolder = 1;
   let hasVerifier = 1;
def Vector_TypeCastOp :
   }];
 
   /// Build the canonical memRefType with a single vector.
   /// E.g. memref<4 x 5 x vector<6 x f32>> -> memref<vector<4 x 5 x 6 x f32>>.
   let builders = [OpBuilder<(ins "Value":$source)>];
 
   let extraClassDeclaration = [{
     MemRefType getMemRefType() {
-      return memref().getType().cast<MemRefType>();
+      return getMemref().getType().cast<MemRefType>();
     }
     MemRefType getResultMemRefType() {
       return getResult().getType().cast<MemRefType>();
     }
     // Implement ViewLikeOpInterface.
-    Value getViewSource() { return memref(); }
+    Value getViewSource() { return getMemref(); }
   }];
 
   let assemblyFormat = [{
     $memref attr-dict `:` type($memref) `to` type($result)
   }];
   let hasVerifier = 1;
 }
 
[ [a, b, c],       [ [a, d],
                           [c, f] ]
     ```
   }];
   let builders = [
     OpBuilder<(ins "Value":$vector, "ArrayRef<int64_t>":$transp)>
   ];
   let extraClassDeclaration = [{
     VectorType getVectorType() {
-      return vector().getType().cast<VectorType>();
+      return getVector().getType().cast<VectorType>();
     }
     VectorType getResultType() {
-      return result().getType().cast<VectorType>();
+      return getResult().getType().cast<VectorType>();
     }
     void getTransp(SmallVectorImpl<int64_t> &results);
     static StringRef getTranspAttrStrName() { return "transp"; }
   }];
   let assemblyFormat = [{
     $vector `,` $transp attr-dict `:` type($vector) `to` type($result)
   }];
   let hasCanonicalizer = 1;
let description = [{
     on stdout when linked with a small runtime support library,
     which only needs to provide a few printing methods (single
     value for all data types, opening/closing bracket, comma,
     newline).
     ```
   }];
   let extraClassDeclaration = [{
     Type getPrintType() {
-      return source().getType();
+      return getSource().getType();
     }
   }];
   let assemblyFormat = "$source attr-dict `:` type($source)";
 }
 
 //===----------------------------------------------------------------------===//
 // Ops used for supporting progressive lowering and conversion type changes.
 // The Ops are typically not used directly by higher level dialects, but are
OpBuilder<(ins "Value":$source, "Value":$initial_value,
                    "CombiningKind":$kind,
                    CArg<"int64_t", "0">:$reduction_dim,
                    CArg<"bool", "true">:$inclusive)>
   ];
   let extraClassDeclaration = [{
     static StringRef getKindAttrStrName() { return "kind"; }
     static StringRef getReductionDimAttrStrName() { return "reduction_dim"; }
     VectorType getSourceType() {
-      return source().getType().cast<VectorType>();
+      return getSource().getType().cast<VectorType>();
     }
     VectorType getDestType() {
-      return dest().getType().cast<VectorType>();
+      return getDest().getType().cast<VectorType>();
     }
     VectorType getAccumulatorType() {
-      return accumulated_value().getType().cast<VectorType>();
+      return getAccumulatedValue().getType().cast<VectorType>();
     }
     VectorType getInitialValueType() {
-      return initial_value().getType().cast<VectorType>();
+      return getInitialValue().getType().cast<VectorType>();
     }
   }];
   let assemblyFormat =
     "$kind `,` $source `,` $initial_value attr-dict `:` "
     "type($source) `,` type($initial_value) ";
   let hasVerifier = 1;
 }
 
 #endif // VECTOR_OPS

mlir/include/mlir/Interfaces/VectorInterfaces.td

InterfaceMethod<
       /*desc=*/[{ Return `true` if dimension `dim` is in-bounds. Return `false`
                  otherwise. }],
       /*retTy=*/"bool",
       /*methodName=*/"isDimInBounds",
       /*args=*/(ins "unsigned":$dim),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.isBroadcastDim(dim)
-            || ($_op.in_bounds()
-                && $_op.in_bounds()->template cast<::mlir::ArrayAttr>()[dim]
+            || ($_op.getInBounds()
+                && $_op.getInBounds()->template cast<::mlir::ArrayAttr>()[dim]
                                     .template cast<::mlir::BoolAttr>().getValue());
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the memref or ranked tensor operand.",
       /*retTy=*/"::mlir::Value",
       /*methodName=*/"source",
       /*args=*/(ins),
-      /*methodBody=*/"return $_op.source();"
+      /*methodBody=*/"return $_op.getSource();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the vector operand or result.",
       /*retTy=*/"::mlir::Value",
       /*methodName=*/"vector",
       /*args=*/(ins),
-      /*methodBody=*/"return $_op.vector();"
+      /*methodBody=*/"return $_op.getVector();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the indices operands.",
       /*retTy=*/"::mlir::ValueRange",
       /*methodName=*/"indices",
       /*args=*/(ins),
-      /*methodBody=*/"return $_op.indices();"
+      /*methodBody=*/"return $_op.getIndices();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the permutation map.",
       /*retTy=*/"::mlir::AffineMap",
       /*methodName=*/"permutation_map",
       /*args=*/(ins),
-      /*methodBody=*/"return $_op.permutation_map();"
+      /*methodBody=*/"return $_op.getPermutationMap();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/[{ Returns true if the specified dimension is a broadcast. }],
       /*retTy=*/"bool",
       /*methodName=*/"isBroadcastDim",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        auto expr = $_op.permutation_map().getResult(idx);
+        auto expr = $_op.getPermutationMap().getResult(idx);
         return expr.template isa<::mlir::AffineConstantExpr>() &&
                expr.template dyn_cast<::mlir::AffineConstantExpr>().getValue() == 0;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Returns true if at least one of the dimensions in the
                   permutation map is a broadcast.}],
       /*retTy=*/"bool",
       /*methodName=*/"hasBroadcastDim",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         for (unsigned i = 0, rank = getTransferRank(); i < rank; ++i) {
           if ($_op.isBroadcastDim(i))
             return true;
         }
         return false;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the `in_bounds` boolean ArrayAttr.",
       /*retTy=*/"::mlir::Optional<::mlir::ArrayAttr>",
       /*methodName=*/"in_bounds",
       /*args=*/(ins),
-      /*methodBody=*/"return $_op.in_bounds();"
+      /*methodBody=*/"return $_op.getInBounds();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the ShapedType.",
       /*retTy=*/"::mlir::ShapedType",
       /*methodName=*/"getShapedType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/
-        "return $_op.source().getType().template cast<::mlir::ShapedType>();"
+        "return $_op.getSource().getType().template cast<::mlir::ShapedType>();"
     >,
     InterfaceMethod<
       /*desc=*/"Return the VectorType.",
       /*retTy=*/"::mlir::VectorType",
       /*methodName=*/"getVectorType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return $_op.vector().getType().template dyn_cast<::mlir::VectorType>();
+        return $_op.getVector().getType().template dyn_cast<::mlir::VectorType>();
         }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the mask type if the op has a mask.",
       /*retTy=*/"::mlir::VectorType",
       /*methodName=*/"getMaskType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return $_op.mask()
+        return $_op.getMask()
             ? ::mlir::vector::detail::transferMaskType(
-                $_op.getVectorType(), $_op.permutation_map())
+                $_op.getVectorType(), $_op.getPermutationMap())
             : ::mlir::VectorType();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Return the number of dimensions that participate in the
                   permutation map.}],
       /*retTy=*/"unsigned",
       /*methodName=*/"getTransferRank",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/
-        "return $_op.permutation_map().getNumResults();"
+        "return $_op.getPermutationMap().getNumResults();"
     >,
     InterfaceMethod<
       /*desc=*/[{ Return the number of leading shaped dimensions that do not
                   participate in the permutation map.}],
       /*retTy=*/"unsigned",
       /*methodName=*/"getLeadingShapedRank",
       /*args=*/(ins),
       /*methodBody=*/"",

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 #include "mlir/Transforms/Passes.h"
 
 using namespace mlir;
 
 // Return true if the contract op can be convert to MMA matmul.
 static bool contractSupportsMMAMatrixType(vector::ContractionOp contract) {
-  if (llvm::size(contract.masks()) != 0)
+  if (llvm::size(contract.getMasks()) != 0)
     return false;
 
   using MapList = ArrayRef<ArrayRef<AffineExpr>>;
   auto infer = [](MapList m) { return AffineMap::inferFromExprList(m); };
   AffineExpr m, n, k;
   bindDims(contract.getContext(), m, n, k);
-  auto iteratorTypes = contract.iterator_types().getValue();
+  auto iteratorTypes = contract.getIteratorTypes().getValue();
   if (!(isParallelIterator(iteratorTypes[0]) &&
         isParallelIterator(iteratorTypes[1]) &&
         isReductionIterator(iteratorTypes[2])))
     return false;
 
   // The contract needs to represent a matmul to be able to convert to
   // MMAMatrix matmul.
   if (contract.getIndexingMaps() != infer({{m, k}, {k, n}, {m, n}}))
getMemrefConstantHorizontalStride(ShapedType type) {
   int64_t stride = strides[strides.size() - 2];
   if (stride == ShapedType::kDynamicStrideOrOffset)
     return llvm::None;
   return stride;
 }
 
 // Return true if the transfer op can be converted to a MMA matrix load.
 static bool transferReadSupportsMMAMatrixType(vector::TransferReadOp readOp) {
-  if (readOp.mask() || readOp.hasOutOfBoundsDim() ||
+  if (readOp.getMask() || readOp.hasOutOfBoundsDim() ||
       readOp.getVectorType().getRank() != 2)
     return false;
   if (!getMemrefConstantHorizontalStride(readOp.getShapedType()))
     return false;
-  AffineMap map = readOp.permutation_map();
+  AffineMap map = readOp.getPermutationMap();
   OpBuilder b(readOp.getContext());
   AffineExpr innerDim = b.getAffineDimExpr(map.getNumDims() - 1);
   AffineExpr zero = b.getAffineConstantExpr(0);
   auto broadcastInnerDim = AffineMap::get(map.getNumDims(), 0, {zero, innerDim},
                                           readOp.getContext());
   // TODO: Support transpose once it is added to GPU dialect ops.
   // For now we only support (d0, d1) -> (d0, d1) and (d0, d1) -> (0, d1).
   return !(!map.isMinorIdentity() && map != broadcastInnerDim);
 }
 
 // Return true if the transfer op can be converted to a MMA matrix store.
 static bool
 transferWriteSupportsMMAMatrixType(vector::TransferWriteOp writeOp) {
   // TODO: support 0-d corner case.
   if (writeOp.getTransferRank() == 0)
     return false;
 
-  if (writeOp.mask() || writeOp.hasOutOfBoundsDim() ||
+  if (writeOp.getMask() || writeOp.hasOutOfBoundsDim() ||
       writeOp.getVectorType().getRank() != 2)
     return false;
   if (!getMemrefConstantHorizontalStride(writeOp.getShapedType()))
     return false;
   // TODO: Support transpose once it is added to GPU dialect ops.
-  if (!writeOp.permutation_map().isMinorIdentity())
+  if (!writeOp.getPermutationMap().isMinorIdentity())
     return false;
   return true;
 }
 
 /// 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.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>();
+         broadcastOp.getSource().getType().isa<FloatType>();
 }
 
 /// Return the MMA elementwise enum associated with `op` if it is supported.
 /// Return `llvm::None` otherwise.
 static llvm::Optional<gpu::MMAElementwiseOp>
 convertElementwiseOpToMMA(Operation *op) {
   if (isa<arith::AddFOp>(op))
     return gpu::MMAElementwiseOp::ADDF;

 // to MMA matmul.
 struct PrepareContractToGPUMMA
     : public OpRewritePattern<vector::ContractionOp> {
   using OpRewritePattern<vector::ContractionOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ContractionOp op,
                                 PatternRewriter &rewriter) const override {
     Location loc = op.getLoc();
-    Value lhs = op.lhs(), rhs = op.rhs(), res = op.acc();
+    Value lhs = op.getLhs(), rhs = op.getRhs(), res = op.getAcc();
 
     // Set up the parallel/reduction structure in right form.
     using MapList = ArrayRef<ArrayRef<AffineExpr>>;
     auto infer = [](MapList m) { return AffineMap::inferFromExprList(m); };
     AffineExpr m, n, k;
     bindDims(rewriter.getContext(), m, n, k);
     static constexpr std::array<int64_t, 2> perm = {1, 0};
-    auto iteratorTypes = op.iterator_types().getValue();
+    auto iteratorTypes = op.getIteratorTypes().getValue();
     SmallVector<AffineMap, 4> maps = op.getIndexingMaps();
     if (!(isParallelIterator(iteratorTypes[0]) &&
           isParallelIterator(iteratorTypes[1]) &&
           isReductionIterator(iteratorTypes[2])))
       return failure();
     //
     // Two outer parallel, one inner reduction (matmat flavor).
     //
LogicalResult matchAndRewrite(vector::ContractionOp op,
     } else if (maps == infer({{k, m}, {n, k}, {n, m}})) {
       std::swap(lhs, rhs);
     } else {
       return failure();
     }
     rewriter.replaceOpWithNewOp<vector::ContractionOp>(
         op, lhs, rhs, res,
         rewriter.getAffineMapArrayAttr(infer({{m, k}, {k, n}, {m, n}})),
-        op.iterator_types());
+        op.getIteratorTypes());
     return success();
   }
 };
 
 // Merge transpose op into the transfer read op. Transpose are not supported on
 // MMA types but MMA load can transpose the matrix when loading.
 struct CombineTransferReadOpTranspose final
     : public OpRewritePattern<vector::TransposeOp> {
   using OpRewritePattern<vector::TransposeOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransposeOp op,
                                 PatternRewriter &rewriter) const override {
-    auto transferReadOp = op.vector().getDefiningOp<vector::TransferReadOp>();
+    auto transferReadOp =
+        op.getVector().getDefiningOp<vector::TransferReadOp>();
     if (!transferReadOp)
       return failure();
 
     // TODO: support 0-d corner case.
     if (transferReadOp.getTransferRank() == 0)
       return failure();
 
-    if (transferReadOp.mask() || transferReadOp.hasOutOfBoundsDim())
+    if (transferReadOp.getMask() || transferReadOp.hasOutOfBoundsDim())
       return failure();
     SmallVector<int64_t, 2> perm;
     op.getTransp(perm);
     SmallVector<unsigned, 2> permU;
     for (int64_t o : perm)
       permU.push_back(unsigned(o));
     AffineMap permutationMap =
         AffineMap::getPermutationMap(permU, op.getContext());
-    AffineMap newMap = permutationMap.compose(transferReadOp.permutation_map());
+    AffineMap newMap =
+        permutationMap.compose(transferReadOp.getPermutationMap());
     rewriter.replaceOpWithNewOp<vector::TransferReadOp>(
-        op, op.getType(), transferReadOp.source(), transferReadOp.indices(),
-        AffineMapAttr::get(newMap), transferReadOp.padding(),
-        transferReadOp.mask(), transferReadOp.in_boundsAttr());
+        op, op.getType(), transferReadOp.getSource(),
+        transferReadOp.getIndices(), AffineMapAttr::get(newMap),
+        transferReadOp.getPadding(), transferReadOp.getMask(),
+        transferReadOp.getInBoundsAttr());
     return success();
   }
 };
 
 } // namespace
 
 // MMA types have different layout based on how they are used in matmul ops.
 // Figure the right layout to use by looking at op uses.
 // TODO: Change the GPU dialect to abstract the layout at the this level and
 // only care about it during lowering to NVVM.
 template <typename OpTy>
 static const char *inferFragType(OpTy op) {
   for (Operation *users : op->getUsers()) {
     auto contract = dyn_cast<vector::ContractionOp>(users);
     if (!contract)
       continue;
-    if (contract.lhs() == op.getResult())
+    if (contract.getLhs() == op.getResult())
       return "AOp";
-    if (contract.rhs() == op.getResult())
+    if (contract.getRhs() == op.getResult())
       return "BOp";
   }
   return "COp";
 }
 
 static void convertTransferReadOp(vector::TransferReadOp op,
                                   llvm::DenseMap<Value, Value> &valueMapping) {
   assert(op.getTransferRank() > 0 && "unexpected 0-d transfer");
   assert(transferReadSupportsMMAMatrixType(op));
   Optional<int64_t> stride =
       getMemrefConstantHorizontalStride(op.getShapedType());
-  AffineMap map = op.permutation_map();
+  AffineMap map = op.getPermutationMap();
   // Handle broadcast by setting the stride to 0.
   if (map.getResult(0).isa<AffineConstantExpr>()) {
     assert(map.getResult(0).cast<AffineConstantExpr>().getValue() == 0);
     stride = 0;
   }
   assert(stride);
   const char *fragType = inferFragType(op);
   gpu::MMAMatrixType type =
       gpu::MMAMatrixType::get(op.getVectorType().getShape(),
                               op.getVectorType().getElementType(), fragType);
   OpBuilder b(op);
   Value load = b.create<gpu::SubgroupMmaLoadMatrixOp>(
-      op.getLoc(), type, op.source(), op.indices(), b.getIndexAttr(*stride));
+      op.getLoc(), type, op.getSource(), op.getIndices(),
+      b.getIndexAttr(*stride));
   valueMapping[op.getResult()] = load;
 }
 
 static void convertTransferWriteOp(vector::TransferWriteOp op,
                                    llvm::DenseMap<Value, Value> &valueMapping) {
   assert(transferWriteSupportsMMAMatrixType(op));
   Optional<int64_t> stride =
       getMemrefConstantHorizontalStride(op.getShapedType());
   assert(stride);
   OpBuilder b(op);
-  Value matrix = valueMapping.find(op.vector())->second;
-  b.create<gpu::SubgroupMmaStoreMatrixOp>(
-      op.getLoc(), matrix, op.source(), op.indices(), b.getIndexAttr(*stride));
+  Value matrix = valueMapping.find(op.getVector())->second;
+  b.create<gpu::SubgroupMmaStoreMatrixOp>(op.getLoc(), matrix, op.getSource(),
+                                          op.getIndices(),
+                                          b.getIndexAttr(*stride));
   op.erase();
 }
 
 static void convertContractOp(vector::ContractionOp op,
                               llvm::DenseMap<Value, Value> &valueMapping) {
   OpBuilder b(op);
-  Value opA = valueMapping.find(op.lhs())->second;
-  Value opB = valueMapping.find(op.rhs())->second;
-  Value opC = valueMapping.find(op.acc())->second;
+  Value opA = valueMapping.find(op.getLhs())->second;
+  Value opB = valueMapping.find(op.getRhs())->second;
+  Value opC = valueMapping.find(op.getAcc())->second;
   Value matmul = b.create<gpu::SubgroupMmaComputeOp>(op.getLoc(), opC.getType(),
                                                      opA, opB, opC);
   valueMapping[op.getResult()] = matmul;
 }
 
 /// Convert a 2D splat ConstantOp to a SubgroupMmaConstantMatrix op.
 static void convertConstantOp(arith::ConstantOp op,
                               llvm::DenseMap<Value, Value> &valueMapping) {
static void convertBroadcastOp(vector::BroadcastOp op,
                                llvm::DenseMap<Value, Value> &valueMapping) {
   assert(broadcastSupportsMMAMatrixType(op));
   OpBuilder b(op);
   const char *fragType = inferFragType(op);
   auto vecType = op.getVectorType();
   gpu::MMAMatrixType type = gpu::MMAMatrixType::get(
       vecType.getShape(), vecType.getElementType(), llvm::StringRef(fragType));
   auto matrix = b.create<gpu::SubgroupMmaConstantMatrixOp>(op.getLoc(), type,
-                                                           op.source());
+                                                           op.getSource());
   valueMapping[op.getResult()] = matrix;
 }
 
 // Replace ForOp with a new ForOp with extra operands. The YieldOp is not
 // updated and needs to be updated separatly for the loop to be correct.
 static scf::ForOp replaceForOpWithNewSignature(OpBuilder &b, scf::ForOp loop,
                                                ValueRange newIterOperands) {
   // Create a new loop before the existing one, with the extra operands.

mlir/lib/Conversion/VectorToLLVM/ConvertVectorToLLVM.cpp

class VectorMatmulOpConversion
     : public ConvertOpToLLVMPattern<vector::MatmulOp> {
 public:
   using ConvertOpToLLVMPattern<vector::MatmulOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::MatmulOp matmulOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::MatrixMultiplyOp>(
-        matmulOp, typeConverter->convertType(matmulOp.res().getType()),
-        adaptor.lhs(), adaptor.rhs(), matmulOp.lhs_rows(),
-        matmulOp.lhs_columns(), matmulOp.rhs_columns());
+        matmulOp, typeConverter->convertType(matmulOp.getRes().getType()),
+        adaptor.getLhs(), adaptor.getRhs(), matmulOp.getLhsRows(),
+        matmulOp.getLhsColumns(), matmulOp.getRhsColumns());
     return success();
   }
 };
 
 /// Conversion pattern for a vector.flat_transpose.
 /// This is lowered directly to the proper llvm.intr.matrix.transpose.
 class VectorFlatTransposeOpConversion
     : public ConvertOpToLLVMPattern<vector::FlatTransposeOp> {
 public:
   using ConvertOpToLLVMPattern<vector::FlatTransposeOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::FlatTransposeOp transOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::MatrixTransposeOp>(
-        transOp, typeConverter->convertType(transOp.res().getType()),
-        adaptor.matrix(), transOp.rows(), transOp.columns());
+        transOp, typeConverter->convertType(transOp.getRes().getType()),
+        adaptor.getMatrix(), transOp.getRows(), transOp.getColumns());
     return success();
   }
 };
 
 /// Overloaded utility that replaces a vector.load, vector.store,
 /// vector.maskedload and vector.maskedstore with their respective LLVM
 /// couterparts.
 static void replaceLoadOrStoreOp(vector::LoadOp loadOp,
                                  vector::LoadOpAdaptor adaptor,
                                  VectorType vectorTy, Value ptr, unsigned align,
                                  ConversionPatternRewriter &rewriter) {
   rewriter.replaceOpWithNewOp<LLVM::LoadOp>(loadOp, ptr, align);
 }
 
 static void replaceLoadOrStoreOp(vector::MaskedLoadOp loadOp,
                                  vector::MaskedLoadOpAdaptor adaptor,
                                  VectorType vectorTy, Value ptr, unsigned align,
                                  ConversionPatternRewriter &rewriter) {
   rewriter.replaceOpWithNewOp<LLVM::MaskedLoadOp>(
-      loadOp, vectorTy, ptr, adaptor.mask(), adaptor.pass_thru(), align);
+      loadOp, vectorTy, ptr, adaptor.getMask(), adaptor.getPassThru(), align);
 }
 
 static void replaceLoadOrStoreOp(vector::StoreOp storeOp,
                                  vector::StoreOpAdaptor adaptor,
                                  VectorType vectorTy, Value ptr, unsigned align,
                                  ConversionPatternRewriter &rewriter) {
-  rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, adaptor.valueToStore(),
+  rewriter.replaceOpWithNewOp<LLVM::StoreOp>(storeOp, adaptor.getValueToStore(),
                                              ptr, align);
 }
 
 static void replaceLoadOrStoreOp(vector::MaskedStoreOp storeOp,
                                  vector::MaskedStoreOpAdaptor adaptor,
                                  VectorType vectorTy, Value ptr, unsigned align,
                                  ConversionPatternRewriter &rewriter) {
   rewriter.replaceOpWithNewOp<LLVM::MaskedStoreOp>(
-      storeOp, adaptor.valueToStore(), ptr, adaptor.mask(), align);
+      storeOp, adaptor.getValueToStore(), ptr, adaptor.getMask(), align);
 }
 
 /// Conversion pattern for a vector.load, vector.store, vector.maskedload, and
 /// vector.maskedstore.
 template <class LoadOrStoreOp, class LoadOrStoreOpAdaptor>
 class VectorLoadStoreConversion : public ConvertOpToLLVMPattern<LoadOrStoreOp> {
 public:
   using ConvertOpToLLVMPattern<LoadOrStoreOp>::ConvertOpToLLVMPattern;
matchAndRewrite(LoadOrStoreOp loadOrStoreOp,
     // Resolve alignment.
     unsigned align;
     if (failed(getMemRefAlignment(*this->getTypeConverter(), memRefTy, align)))
       return failure();
 
     // Resolve address.
     auto vtype = this->typeConverter->convertType(loadOrStoreOp.getVectorType())
                      .template cast<VectorType>();
-    Value dataPtr = this->getStridedElementPtr(loc, memRefTy, adaptor.base(),
-                                               adaptor.indices(), rewriter);
+    Value dataPtr = this->getStridedElementPtr(loc, memRefTy, adaptor.getBase(),
+                                               adaptor.getIndices(), rewriter);
     Value ptr = castDataPtr(rewriter, loc, dataPtr, memRefTy, vtype);
 
     replaceLoadOrStoreOp(loadOrStoreOp, adaptor, vtype, ptr, align, rewriter);
     return success();
   }
 };
 
 /// Conversion pattern for a vector.gather.
matchAndRewrite(vector::GatherOp gather, OpAdaptor adaptor,
     // Resolve alignment.
     unsigned align;
     if (failed(getMemRefAlignment(*getTypeConverter(), memRefType, align)))
       return failure();
 
     // Resolve address.
     Value ptrs;
     VectorType vType = gather.getVectorType();
-    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.base(),
-                                     adaptor.indices(), rewriter);
-    if (failed(getIndexedPtrs(rewriter, loc, adaptor.base(), ptr,
-                              adaptor.index_vec(), memRefType, vType, ptrs)))
+    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.getBase(),
+                                     adaptor.getIndices(), rewriter);
+    if (failed(getIndexedPtrs(rewriter, loc, adaptor.getBase(), ptr,
+                              adaptor.getIndexVec(), memRefType, vType, ptrs)))
       return failure();
 
     // Replace with the gather intrinsic.
     rewriter.replaceOpWithNewOp<LLVM::masked_gather>(
-        gather, typeConverter->convertType(vType), ptrs, adaptor.mask(),
-        adaptor.pass_thru(), rewriter.getI32IntegerAttr(align));
+        gather, typeConverter->convertType(vType), ptrs, adaptor.getMask(),
+        adaptor.getPassThru(), rewriter.getI32IntegerAttr(align));
     return success();
   }
 };
 
 /// Conversion pattern for a vector.scatter.
 class VectorScatterOpConversion
     : public ConvertOpToLLVMPattern<vector::ScatterOp> {
 public:
   using ConvertOpToLLVMPattern<vector::ScatterOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::ScatterOp scatter, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = scatter->getLoc();
     MemRefType memRefType = scatter.getMemRefType();
 
     // Resolve alignment.
     unsigned align;
     if (failed(getMemRefAlignment(*getTypeConverter(), memRefType, align)))
       return failure();
 
     // Resolve address.
     Value ptrs;
     VectorType vType = scatter.getVectorType();
-    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.base(),
-                                     adaptor.indices(), rewriter);
-    if (failed(getIndexedPtrs(rewriter, loc, adaptor.base(), ptr,
-                              adaptor.index_vec(), memRefType, vType, ptrs)))
+    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.getBase(),
+                                     adaptor.getIndices(), rewriter);
+    if (failed(getIndexedPtrs(rewriter, loc, adaptor.getBase(), ptr,
+                              adaptor.getIndexVec(), memRefType, vType, ptrs)))
       return failure();
 
     // Replace with the scatter intrinsic.
     rewriter.replaceOpWithNewOp<LLVM::masked_scatter>(
-        scatter, adaptor.valueToStore(), ptrs, adaptor.mask(),
+        scatter, adaptor.getValueToStore(), ptrs, adaptor.getMask(),
         rewriter.getI32IntegerAttr(align));
     return success();
   }
 };
 
 /// Conversion pattern for a vector.expandload.
 class VectorExpandLoadOpConversion
     : public ConvertOpToLLVMPattern<vector::ExpandLoadOp> {
 public:
   using ConvertOpToLLVMPattern<vector::ExpandLoadOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::ExpandLoadOp expand, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = expand->getLoc();
     MemRefType memRefType = expand.getMemRefType();
 
     // Resolve address.
     auto vtype = typeConverter->convertType(expand.getVectorType());
-    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.base(),
-                                     adaptor.indices(), rewriter);
+    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.getBase(),
+                                     adaptor.getIndices(), rewriter);
 
     rewriter.replaceOpWithNewOp<LLVM::masked_expandload>(
-        expand, vtype, ptr, adaptor.mask(), adaptor.pass_thru());
+        expand, vtype, ptr, adaptor.getMask(), adaptor.getPassThru());
     return success();
   }
 };
 
 /// Conversion pattern for a vector.compressstore.
 class VectorCompressStoreOpConversion
     : public ConvertOpToLLVMPattern<vector::CompressStoreOp> {
 public:
   using ConvertOpToLLVMPattern<vector::CompressStoreOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::CompressStoreOp compress, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = compress->getLoc();
     MemRefType memRefType = compress.getMemRefType();
 
     // Resolve address.
-    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.base(),
-                                     adaptor.indices(), rewriter);
+    Value ptr = getStridedElementPtr(loc, memRefType, adaptor.getBase(),
+                                     adaptor.getIndices(), rewriter);
 
     rewriter.replaceOpWithNewOp<LLVM::masked_compressstore>(
-        compress, adaptor.valueToStore(), ptr, adaptor.mask());
+        compress, adaptor.getValueToStore(), ptr, adaptor.getMask());
     return success();
   }
 };
 
 /// Conversion pattern for all vector reductions.
 class VectorReductionOpConversion
     : public ConvertOpToLLVMPattern<vector::ReductionOp> {
 public:
   explicit VectorReductionOpConversion(LLVMTypeConverter &typeConv,
                                        bool reassociateFPRed)
       : ConvertOpToLLVMPattern<vector::ReductionOp>(typeConv),
         reassociateFPReductions(reassociateFPRed) {}
 
   LogicalResult
   matchAndRewrite(vector::ReductionOp reductionOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    auto kind = reductionOp.kind();
-    Type eltType = reductionOp.dest().getType();
+    auto kind = reductionOp.getKind();
+    Type eltType = reductionOp.getDest().getType();
     Type llvmType = typeConverter->convertType(eltType);
     Value operand = adaptor.getOperands()[0];
     if (eltType.isIntOrIndex()) {
       // Integer reductions: add/mul/min/max/and/or/xor.
       if (kind == vector::CombiningKind::ADD)
         rewriter.replaceOpWithNewOp<LLVM::vector_reduce_add>(reductionOp,
                                                              llvmType, operand);
       else if (kind == vector::CombiningKind::MUL)
public:
   LogicalResult
   matchAndRewrite(vector::ShuffleOp shuffleOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = shuffleOp->getLoc();
     auto v1Type = shuffleOp.getV1VectorType();
     auto v2Type = shuffleOp.getV2VectorType();
     auto vectorType = shuffleOp.getVectorType();
     Type llvmType = typeConverter->convertType(vectorType);
-    auto maskArrayAttr = shuffleOp.mask();
+    auto maskArrayAttr = shuffleOp.getMask();
 
     // Bail if result type cannot be lowered.
     if (!llvmType)
       return failure();
 
     // Get rank and dimension sizes.
     int64_t rank = vectorType.getRank();
     assert(v1Type.getRank() == rank);
     assert(v2Type.getRank() == rank);
     int64_t v1Dim = v1Type.getDimSize(0);
 
     // For rank 1, where both operands have *exactly* the same vector type,
     // there is direct shuffle support in LLVM. Use it!
     if (rank == 1 && v1Type == v2Type) {
       Value llvmShuffleOp = rewriter.create<LLVM::ShuffleVectorOp>(
-          loc, adaptor.v1(), adaptor.v2(), maskArrayAttr);
+          loc, adaptor.getV1(), adaptor.getV2(), maskArrayAttr);
       rewriter.replaceOp(shuffleOp, llvmShuffleOp);
       return success();
     }
 
     // For all other cases, insert the individual values individually.
     Type eltType;
     if (auto arrayType = llvmType.dyn_cast<LLVM::LLVMArrayType>())
       eltType = arrayType.getElementType();
     else
       eltType = llvmType.cast<VectorType>().getElementType();
     Value insert = rewriter.create<LLVM::UndefOp>(loc, llvmType);
     int64_t insPos = 0;
     for (const auto &en : llvm::enumerate(maskArrayAttr)) {
       int64_t extPos = en.value().cast<IntegerAttr>().getInt();
-      Value value = adaptor.v1();
+      Value value = adaptor.getV1();
       if (extPos >= v1Dim) {
         extPos -= v1Dim;
-        value = adaptor.v2();
+        value = adaptor.getV2();
       }
       Value extract = extractOne(rewriter, *getTypeConverter(), loc, value,
                                  eltType, rank, extPos);
       insert = insertOne(rewriter, *getTypeConverter(), loc, insert, extract,
                          llvmType, rank, insPos++);
     }
     rewriter.replaceOp(shuffleOp, insert);
     return success();
matchAndRewrite(vector::ExtractElementOp extractEltOp, OpAdaptor adaptor,
 
     if (vectorType.getRank() == 0) {
       Location loc = extractEltOp.getLoc();
       auto idxType = rewriter.getIndexType();
       auto zero = rewriter.create<LLVM::ConstantOp>(
           loc, typeConverter->convertType(idxType),
           rewriter.getIntegerAttr(idxType, 0));
       rewriter.replaceOpWithNewOp<LLVM::ExtractElementOp>(
-          extractEltOp, llvmType, adaptor.vector(), zero);
+          extractEltOp, llvmType, adaptor.getVector(), zero);
       return success();
     }
 
     rewriter.replaceOpWithNewOp<LLVM::ExtractElementOp>(
-        extractEltOp, llvmType, adaptor.vector(), adaptor.position());
+        extractEltOp, llvmType, adaptor.getVector(), adaptor.getPosition());
     return success();
   }
 };
 
 class VectorExtractOpConversion
     : public ConvertOpToLLVMPattern<vector::ExtractOp> {
 public:
   using ConvertOpToLLVMPattern<vector::ExtractOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::ExtractOp extractOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = extractOp->getLoc();
     auto vectorType = extractOp.getVectorType();
     auto resultType = extractOp.getResult().getType();
     auto llvmResultType = typeConverter->convertType(resultType);
-    auto positionArrayAttr = extractOp.position();
+    auto positionArrayAttr = extractOp.getPosition();
 
     // Bail if result type cannot be lowered.
     if (!llvmResultType)
       return failure();
 
     // Extract entire vector. Should be handled by folder, but just to be safe.
     if (positionArrayAttr.empty()) {
-      rewriter.replaceOp(extractOp, adaptor.vector());
+      rewriter.replaceOp(extractOp, adaptor.getVector());
       return success();
     }
 
     // One-shot extraction of vector from array (only requires extractvalue).
     if (resultType.isa<VectorType>()) {
       Value extracted = rewriter.create<LLVM::ExtractValueOp>(
-          loc, llvmResultType, adaptor.vector(), positionArrayAttr);
+          loc, llvmResultType, adaptor.getVector(), positionArrayAttr);
       rewriter.replaceOp(extractOp, extracted);
       return success();
     }
 
     // Potential extraction of 1-D vector from array.
     auto *context = extractOp->getContext();
-    Value extracted = adaptor.vector();
+    Value extracted = adaptor.getVector();
     auto positionAttrs = positionArrayAttr.getValue();
     if (positionAttrs.size() > 1) {
       auto oneDVectorType = reducedVectorTypeBack(vectorType);
       auto nMinusOnePositionAttrs =
           ArrayAttr::get(context, positionAttrs.drop_back());
       extracted = rewriter.create<LLVM::ExtractValueOp>(
           loc, typeConverter->convertType(oneDVectorType), extracted,
           nMinusOnePositionAttrs);
public:
   using ConvertOpToLLVMPattern<vector::FMAOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::FMAOp fmaOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     VectorType vType = fmaOp.getVectorType();
     if (vType.getRank() != 1)
       return failure();
-    rewriter.replaceOpWithNewOp<LLVM::FMulAddOp>(fmaOp, adaptor.lhs(),
-                                                 adaptor.rhs(), adaptor.acc());
+    rewriter.replaceOpWithNewOp<LLVM::FMulAddOp>(
+        fmaOp, adaptor.getLhs(), adaptor.getRhs(), adaptor.getAcc());
     return success();
   }
 };
 
 class VectorInsertElementOpConversion
     : public ConvertOpToLLVMPattern<vector::InsertElementOp> {
 public:
   using ConvertOpToLLVMPattern<vector::InsertElementOp>::ConvertOpToLLVMPattern;
matchAndRewrite(vector::InsertElementOp insertEltOp, OpAdaptor adaptor,
 
     if (vectorType.getRank() == 0) {
       Location loc = insertEltOp.getLoc();
       auto idxType = rewriter.getIndexType();
       auto zero = rewriter.create<LLVM::ConstantOp>(
           loc, typeConverter->convertType(idxType),
           rewriter.getIntegerAttr(idxType, 0));
       rewriter.replaceOpWithNewOp<LLVM::InsertElementOp>(
-          insertEltOp, llvmType, adaptor.dest(), adaptor.source(), zero);
+          insertEltOp, llvmType, adaptor.getDest(), adaptor.getSource(), zero);
       return success();
     }
 
     rewriter.replaceOpWithNewOp<LLVM::InsertElementOp>(
-        insertEltOp, llvmType, adaptor.dest(), adaptor.source(),
-        adaptor.position());
+        insertEltOp, llvmType, adaptor.getDest(), adaptor.getSource(),
+        adaptor.getPosition());
     return success();
   }
 };
 
 class VectorInsertOpConversion
     : public ConvertOpToLLVMPattern<vector::InsertOp> {
 public:
   using ConvertOpToLLVMPattern<vector::InsertOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(vector::InsertOp insertOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto loc = insertOp->getLoc();
     auto sourceType = insertOp.getSourceType();
     auto destVectorType = insertOp.getDestVectorType();
     auto llvmResultType = typeConverter->convertType(destVectorType);
-    auto positionArrayAttr = insertOp.position();
+    auto positionArrayAttr = insertOp.getPosition();
 
     // Bail if result type cannot be lowered.
     if (!llvmResultType)
       return failure();
 
     // Overwrite entire vector with value. Should be handled by folder, but
     // just to be safe.
     if (positionArrayAttr.empty()) {
-      rewriter.replaceOp(insertOp, adaptor.source());
+      rewriter.replaceOp(insertOp, adaptor.getSource());
       return success();
     }
 
     // One-shot insertion of a vector into an array (only requires insertvalue).
     if (sourceType.isa<VectorType>()) {
       Value inserted = rewriter.create<LLVM::InsertValueOp>(
-          loc, llvmResultType, adaptor.dest(), adaptor.source(),
+          loc, llvmResultType, adaptor.getDest(), adaptor.getSource(),
           positionArrayAttr);
       rewriter.replaceOp(insertOp, inserted);
       return success();
     }
 
     // Potential extraction of 1-D vector from array.
     auto *context = insertOp->getContext();
-    Value extracted = adaptor.dest();
+    Value extracted = adaptor.getDest();
     auto positionAttrs = positionArrayAttr.getValue();
     auto position = positionAttrs.back().cast<IntegerAttr>();
     auto oneDVectorType = destVectorType;
     if (positionAttrs.size() > 1) {
       oneDVectorType = reducedVectorTypeBack(destVectorType);
       auto nMinusOnePositionAttrs =
           ArrayAttr::get(context, positionAttrs.drop_back());
       extracted = rewriter.create<LLVM::ExtractValueOp>(
           loc, typeConverter->convertType(oneDVectorType), extracted,
           nMinusOnePositionAttrs);
     }
 
     // Insertion of an element into a 1-D LLVM vector.
     auto i64Type = IntegerType::get(rewriter.getContext(), 64);
     auto constant = rewriter.create<LLVM::ConstantOp>(loc, i64Type, position);
     Value inserted = rewriter.create<LLVM::InsertElementOp>(
         loc, typeConverter->convertType(oneDVectorType), extracted,
-        adaptor.source(), constant);
+        adaptor.getSource(), constant);
 
     // Potential insertion of resulting 1-D vector into array.
     if (positionAttrs.size() > 1) {
       auto nMinusOnePositionAttrs =
           ArrayAttr::get(context, positionAttrs.drop_back());
-      inserted = rewriter.create<LLVM::InsertValueOp>(loc, llvmResultType,
-                                                      adaptor.dest(), inserted,
-                                                      nMinusOnePositionAttrs);
+      inserted = rewriter.create<LLVM::InsertValueOp>(
+          loc, llvmResultType, adaptor.getDest(), inserted,
     }
 
     rewriter.replaceOp(insertOp, inserted);
     return success();
   }
 };
 
 /// Rank reducing rewrite for n-D FMA into (n-1)-D FMA where n > 1.
if (vType.getRank() < 2)
       return failure();
 
     auto loc = op.getLoc();
     auto elemType = vType.getElementType();
     Value zero = rewriter.create<arith::ConstantOp>(
         loc, elemType, rewriter.getZeroAttr(elemType));
     Value desc = rewriter.create<vector::SplatOp>(loc, vType, zero);
     for (int64_t i = 0, e = vType.getShape().front(); i != e; ++i) {
-      Value extrLHS = rewriter.create<ExtractOp>(loc, op.lhs(), i);
-      Value extrRHS = rewriter.create<ExtractOp>(loc, op.rhs(), i);
-      Value extrACC = rewriter.create<ExtractOp>(loc, op.acc(), i);
+      Value extrLHS = rewriter.create<ExtractOp>(loc, op.getLhs(), i);
+      Value extrRHS = rewriter.create<ExtractOp>(loc, op.getRhs(), i);
+      Value extrACC = rewriter.create<ExtractOp>(loc, op.getAcc(), i);
       Value fma = rewriter.create<FMAOp>(loc, extrLHS, extrRHS, extrACC);
       desc = rewriter.create<InsertOp>(loc, fma, desc, i);
     }
     rewriter.replaceOp(op, desc);
     return success();
   }
 };
 
if (eltType.isF32()) {
       }
     } else {
       return failure();
     }
 
     // Unroll vector into elementary print calls.
     int64_t rank = vectorType ? vectorType.getRank() : 0;
     Type type = vectorType ? vectorType : eltType;
-    emitRanks(rewriter, printOp, adaptor.source(), type, printer, rank,
+    emitRanks(rewriter, printOp, adaptor.getSource(), type, printer, rank,
               conversion);
     emitCall(rewriter, printOp->getLoc(),
              LLVM::lookupOrCreatePrintNewlineFn(
                  printOp->getParentOfType<ModuleOp>()));
     rewriter.eraseOp(printOp);
     return success();
   }
 
matchAndRewrite(vector::SplatOp splatOp, OpAdaptor adaptor,
     auto zero = rewriter.create<LLVM::ConstantOp>(
         splatOp.getLoc(),
         typeConverter->convertType(rewriter.getIntegerType(32)),
         rewriter.getZeroAttr(rewriter.getIntegerType(32)));
 
     // For 0-d vector, we simply do `insertelement`.
     if (resultType.getRank() == 0) {
       rewriter.replaceOpWithNewOp<LLVM::InsertElementOp>(
-          splatOp, vectorType, undef, adaptor.input(), zero);
+          splatOp, vectorType, undef, adaptor.getInput(), zero);
       return success();
     }
 
     // For 1-d vector, we additionally do a `vectorshuffle`.
     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

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

 }
 
 static LogicalResult replaceTransferOpWithMubuf(
     ConversionPatternRewriter &rewriter, ValueRange operands,
     LLVMTypeConverter &typeConverter, Location loc, TransferWriteOp xferOp,
     Type &vecTy, Value &dwordConfig, Value &vindex, Value &offsetSizeInBytes,
     Value &glc, Value &slc) {
   auto adaptor = TransferWriteOpAdaptor(operands, xferOp->getAttrDictionary());
-  rewriter.replaceOpWithNewOp<ROCDL::MubufStoreOp>(xferOp, adaptor.vector(),
+  rewriter.replaceOpWithNewOp<ROCDL::MubufStoreOp>(xferOp, adaptor.getVector(),
                                                    dwordConfig, vindex,
                                                    offsetSizeInBytes, glc, slc);
   return success();
 }
 
 namespace {
 /// Conversion pattern that converts a 1-D vector transfer read/write.
 /// Note that this conversion pass only converts vector x2 or x4 f32
 /// types. For unsupported cases, they will fall back to the vector to
 /// llvm conversion pattern.
 template <typename ConcreteOp>
 class VectorTransferConversion : public ConvertOpToLLVMPattern<ConcreteOp> {
 public:
   using ConvertOpToLLVMPattern<ConcreteOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(ConcreteOp xferOp, typename ConcreteOp::Adaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (xferOp.getTransferRank() == 0)
       return failure();
 
     if (xferOp.getVectorType().getRank() > 1 ||
-        llvm::size(xferOp.indices()) == 0)
+        llvm::size(xferOp.getIndices()) == 0)
       return failure();
 
-    if (!xferOp.permutation_map().isMinorIdentity())
+    if (!xferOp.getPermutationMap().isMinorIdentity())
       return failure();
 
     // Have it handled in vector->llvm conversion pass.
     if (xferOp.isDimInBounds(0))
       return failure();
 
     auto toLLVMTy = [&](Type t) {
       return this->getTypeConverter()->convertType(t);
matchAndRewrite(ConcreteOp xferOp, typename ConcreteOp::Adaptor adaptor,
     if ((memRefType.getMemorySpaceAsInt() != 0) &&
         (memRefType.getMemorySpaceAsInt() != 1))
       return failure();
 
     // Note that the dataPtr starts at the offset address specified by
     // indices, so no need to calculate offset size in bytes again in
     // the MUBUF instruction.
     Value dataPtr = this->getStridedElementPtr(
-        loc, memRefType, adaptor.source(), adaptor.indices(), rewriter);
+        loc, memRefType, adaptor.getSource(), adaptor.getIndices(), rewriter);
 
     // 1. Create and fill a <4 x i32> dwordConfig with:
     //    1st two elements holding the address of dataPtr.
     //    3rd element: -1.
     //    4th element: 0x27000.
     SmallVector<int32_t, 4> constConfigAttr{0, 0, -1, 0x27000};
     Type i32Ty = rewriter.getIntegerType(32);
     VectorType i32Vecx4 = VectorType::get(4, i32Ty);

mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp

 
 /// Given a vector transfer op, calculate which dimension of the `source`
 /// memref should be unpacked in the next application of TransferOpConversion.
 /// A return value of None indicates a broadcast.
 template <typename OpTy>
 static Optional<int64_t> unpackedDim(OpTy xferOp) {
   // TODO: support 0-d corner case.
   assert(xferOp.getTransferRank() > 0 && "unexpected 0-d transfer");
-  auto map = xferOp.permutation_map();
+  auto map = xferOp.getPermutationMap();
   if (auto expr = map.getResult(0).template dyn_cast<AffineDimExpr>()) {
     return expr.getPosition();
   }
   assert(xferOp.isBroadcastDim(0) &&
          "Expected AffineDimExpr or AffineConstantExpr");
   return None;
 }
 
 /// Compute the permutation map for the new (N-1)-D vector transfer op. This
 /// map is identical to the current permutation map, but the first result is
 /// omitted.
 template <typename OpTy>
 static AffineMap unpackedPermutationMap(OpBuilder &b, OpTy xferOp) {
   // TODO: support 0-d corner case.
   assert(xferOp.getTransferRank() > 0 && "unexpected 0-d transfer");
-  auto map = xferOp.permutation_map();
+  auto map = xferOp.getPermutationMap();
   return AffineMap::get(map.getNumDims(), 0, map.getResults().drop_front(),
                         b.getContext());
 }
 
 /// Calculate the indices for the new vector transfer op.
 ///
 /// E.g.: transfer_read %A[%a, %b, %c, %d] ... : vector<5x4x3xf32> ...
 ///       --> transfer_read %A[%a, %b + iv, %c, %d] ... vector<4x3f32>
 ///                                 ^^^^^^
 ///              `iv` is the iteration variable of the (new) surrounding loop.
 template <typename OpTy>
 static void getXferIndices(OpBuilder &b, OpTy xferOp, Value iv,
                            SmallVector<Value, 8> &indices) {
   typename OpTy::Adaptor adaptor(xferOp);
   // Corresponding memref dim of the vector dim that is unpacked.
   auto dim = unpackedDim(xferOp);
-  auto prevIndices = adaptor.indices();
+  auto prevIndices = adaptor.getIndices();
   indices.append(prevIndices.begin(), prevIndices.end());
 
   Location loc = xferOp.getLoc();
   bool isBroadcast = !dim.hasValue();
   if (!isBroadcast) {
     AffineExpr d0, d1;
     bindDims(xferOp.getContext(), d0, d1);
-    Value offset = adaptor.indices()[dim.getValue()];
+    Value offset = adaptor.getIndices()[dim.getValue()];
     indices[dim.getValue()] =
         makeComposedAffineApply(b, loc, d0 + d1, {offset, iv});
   }
 }
 
 static void maybeYieldValue(OpBuilder &b, Location loc, bool hasRetVal,
                             Value value) {
   if (hasRetVal) {
     assert(value && "Expected non-empty value");
     b.create<scf::YieldOp>(loc, value);
   } else {
     b.create<scf::YieldOp>(loc);
   }
 }
 
 /// Generates a boolean Value that is true if the iv-th bit in xferOp's mask
 /// is set to true. No such check is generated under following circumstances:
 /// * xferOp does not have a mask.
 /// * xferOp's mask is not 1D. (In case of (N>1)-D, a subvector of the mask is
 ///   computed and attached to the new transfer op in the pattern.)
 /// * The to-be-unpacked dim of xferOp is a broadcast.
 template <typename OpTy>
 static Value generateMaskCheck(OpBuilder &b, OpTy xferOp, Value iv) {
-  if (!xferOp.mask())
+  if (!xferOp.getMask())
     return Value();
   if (xferOp.getMaskType().getRank() != 1)
     return Value();
   if (xferOp.isBroadcastDim(0))
     return Value();
 
   Location loc = xferOp.getLoc();
-  return b.create<vector::ExtractElementOp>(loc, xferOp.mask(), iv);
+  return b.create<vector::ExtractElementOp>(loc, xferOp.getMask(), iv);
 }
 
 /// Helper function TransferOpConversion and TransferOp1dConversion.
 /// Generate an in-bounds check if the transfer op may go out-of-bounds on the
 /// specified dimension `dim` with the loop iteration variable `iv`.
 /// E.g., when unpacking dimension 0 from:
 /// ```
 /// %vec = vector.transfer_read %A[%a, %b] %cst
static Value generateInBoundsCheck(
   bool hasRetVal = !resultTypes.empty();
   Value cond; // Condition to be built...
 
   // Condition check 1: Access in-bounds?
   bool isBroadcast = !dim.hasValue(); // No in-bounds check for broadcasts.
   Location loc = xferOp.getLoc();
   ImplicitLocOpBuilder lb(xferOp.getLoc(), b);
   if (!xferOp.isDimInBounds(0) && !isBroadcast) {
-    Value memrefDim = vector::createOrFoldDimOp(b, loc, xferOp.source(), *dim);
+    Value memrefDim =
+        vector::createOrFoldDimOp(b, loc, xferOp.getSource(), *dim);
     AffineExpr d0, d1;
     bindDims(xferOp.getContext(), d0, d1);
-    Value base = xferOp.indices()[dim.getValue()];
+    Value base = xferOp.getIndices()[dim.getValue()];
     Value memrefIdx = makeComposedAffineApply(b, loc, d0 + d1, {base, iv});
     cond = lb.create<arith::CmpIOp>(arith::CmpIPredicate::sgt, memrefDim,
                                     memrefIdx);
   }
 
   // Condition check 2: Masked in?
   if (auto maskCond = generateMaskCheck(b, xferOp, iv)) {
     if (cond)
static BufferAllocs allocBuffers(OpBuilder &b, OpTy xferOp) {
   assert(scope->getNumRegions() == 1 &&
          "AutomaticAllocationScope with >1 regions");
   b.setInsertionPointToStart(&scope->getRegion(0).front());
 
   BufferAllocs result;
   auto bufferType = MemRefType::get({}, xferOp.getVectorType());
   result.dataBuffer = b.create<memref::AllocaOp>(loc, bufferType);
 
-  if (xferOp.mask()) {
-    auto maskType = MemRefType::get({}, xferOp.mask().getType());
+  if (xferOp.getMask()) {
+    auto maskType = MemRefType::get({}, xferOp.getMask().getType());
     auto maskBuffer = b.create<memref::AllocaOp>(loc, maskType);
     b.setInsertionPoint(xferOp);
-    b.create<memref::StoreOp>(loc, xferOp.mask(), maskBuffer);
+    b.create<memref::StoreOp>(loc, xferOp.getMask(), maskBuffer);
     result.maskBuffer = b.create<memref::LoadOp>(loc, maskBuffer);
   }
 
   return result;
 }
 
 /// Given a MemRefType with VectorType element type, unpack one dimension from
 /// the VectorType into the MemRefType.
return MemRefType::get(newMemrefShape,
                          VectorType::get(vectorType.getShape().drop_front(),
                                          vectorType.getElementType()));
 }
 
 /// Given a transfer op, find the memref from which the mask is loaded. This
 /// is similar to Strategy<TransferWriteOp>::getBuffer.
 template <typename OpTy>
 static Value getMaskBuffer(OpTy xferOp) {
-  assert(xferOp.mask() && "Expected that transfer op has mask");
-  auto loadOp = xferOp.mask().template getDefiningOp<memref::LoadOp>();
+  assert(xferOp.getMask() && "Expected that transfer op has mask");
+  auto loadOp = xferOp.getMask().template getDefiningOp<memref::LoadOp>();
   assert(loadOp && "Expected transfer op mask produced by LoadOp");
   return loadOp.getMemRef();
 }
 
 /// Codegen strategy, depending on the operation.
 template <typename OpTy>
 struct Strategy;
 
static TransferReadOp rewriteOp(OpBuilder &b,
     storeIndices.push_back(iv);
 
     SmallVector<Value, 8> xferIndices;
     getXferIndices(b, xferOp, iv, xferIndices);
 
     Location loc = xferOp.getLoc();
     auto bufferType = buffer.getType().dyn_cast<ShapedType>();
     auto vecType = bufferType.getElementType().dyn_cast<VectorType>();
-    auto inBoundsAttr = dropFirstElem(b, xferOp.in_boundsAttr());
+    auto inBoundsAttr = dropFirstElem(b, xferOp.getInBoundsAttr());
     auto newXferOp = b.create<vector::TransferReadOp>(
-        loc, vecType, xferOp.source(), xferIndices,
-        AffineMapAttr::get(unpackedPermutationMap(b, xferOp)), xferOp.padding(),
-        Value(), inBoundsAttr);
+        loc, vecType, xferOp.getSource(), xferIndices,
+        AffineMapAttr::get(unpackedPermutationMap(b, xferOp)),
+        xferOp.getPadding(), Value(), inBoundsAttr);
 
     maybeApplyPassLabel(b, newXferOp, options.targetRank);
 
-    b.create<memref::StoreOp>(loc, newXferOp.vector(), buffer, storeIndices);
+    b.create<memref::StoreOp>(loc, newXferOp.getVector(), buffer, storeIndices);
     return newXferOp;
   }
 
   /// Handle out-of-bounds accesses on the to-be-unpacked dimension: Write
   /// padding value to the temporary buffer.
   static Value handleOutOfBoundsDim(OpBuilder &b, TransferReadOp xferOp,
                                     Value buffer, Value iv,
                                     ValueRange /*loopState*/) {
     SmallVector<Value, 8> storeIndices;
     getBufferIndices(xferOp, storeIndices);
     storeIndices.push_back(iv);
 
     Location loc = xferOp.getLoc();
     auto bufferType = buffer.getType().dyn_cast<ShapedType>();
     auto vecType = bufferType.getElementType().dyn_cast<VectorType>();
-    auto vec = b.create<vector::SplatOp>(loc, vecType, xferOp.padding());
+    auto vec = b.create<vector::SplatOp>(loc, vecType, xferOp.getPadding());
     b.create<memref::StoreOp>(loc, vec, buffer, storeIndices);
 
     return Value();
   }
 
   /// Cleanup after rewriting the op.
   static void cleanup(PatternRewriter &rewriter, TransferReadOp xferOp,
                       scf::ForOp /*forOp*/) {
struct Strategy<TransferWriteOp> {
   /// Find the temporary buffer allocation. All labeled TransferWriteOps are
   /// used like this, where %buf is either the buffer allocation or a type cast
   /// of the buffer allocation:
   /// ```
   /// %vec = memref.load %buf[...] ...
   /// vector.transfer_write %vec ... { __vector_to_scf_lowering__ } ...
   /// ```
   static Value getBuffer(TransferWriteOp xferOp) {
-    auto loadOp = xferOp.vector().getDefiningOp<memref::LoadOp>();
+    auto loadOp = xferOp.getVector().getDefiningOp<memref::LoadOp>();
     assert(loadOp && "Expected transfer op vector produced by LoadOp");
     return loadOp.getMemRef();
   }
 
   /// Retrieve the indices of the current LoadOp that loads from the buffer.
   static void getBufferIndices(TransferWriteOp xferOp,
                                SmallVector<Value, 8> &indices) {
-    auto loadOp = xferOp.vector().getDefiningOp<memref::LoadOp>();
+    auto loadOp = xferOp.getVector().getDefiningOp<memref::LoadOp>();
     auto prevIndices = memref::LoadOpAdaptor(loadOp).indices();
     indices.append(prevIndices.begin(), prevIndices.end());
   }
 
   /// Rewrite the TransferWriteOp, assuming that there are no out-of-bounds
   /// accesses on the to-be-unpacked dimension.
   ///
   /// 1. Load an (N-1)-d vector from the (already `vector.type_cast`ed) buffer,
static TransferWriteOp rewriteOp(OpBuilder &b,
     getBufferIndices(xferOp, loadIndices);
     loadIndices.push_back(iv);
 
     SmallVector<Value, 8> xferIndices;
     getXferIndices(b, xferOp, iv, xferIndices);
 
     Location loc = xferOp.getLoc();
     auto vec = b.create<memref::LoadOp>(loc, buffer, loadIndices);
-    auto inBoundsAttr = dropFirstElem(b, xferOp.in_boundsAttr());
-    auto source = loopState.empty() ? xferOp.source() : loopState[0];
+    auto inBoundsAttr = dropFirstElem(b, xferOp.getInBoundsAttr());
+    auto source = loopState.empty() ? xferOp.getSource() : loopState[0];
     Type type = isTensorOp(xferOp) ? xferOp.getShapedType() : Type();
     auto newXferOp = b.create<vector::TransferWriteOp>(
         loc, type, vec, source, xferIndices,
         AffineMapAttr::get(unpackedPermutationMap(b, xferOp)), Value(),
         inBoundsAttr);
 
     maybeApplyPassLabel(b, newXferOp, options.targetRank);
 
if (isTensorOp(xferOp)) {
       rewriter.replaceOp(xferOp, forOp->getResult(0));
     } else {
       rewriter.eraseOp(xferOp);
     }
   }
 
   /// Return the initial loop state for the generated scf.for loop.
   static Value initialLoopState(TransferWriteOp xferOp) {
-    return isTensorOp(xferOp) ? xferOp.source() : Value();
+    return isTensorOp(xferOp) ? xferOp.getSource() : Value();
   }
 };
 
 template <typename OpTy>
 LogicalResult checkPrepareXferOp(OpTy xferOp,
                                  VectorTransferToSCFOptions options) {
   if (xferOp->hasAttr(kPassLabel))
     return failure();
struct PrepareTransferReadConversion
   LogicalResult matchAndRewrite(TransferReadOp xferOp,
                                 PatternRewriter &rewriter) const override {
     if (checkPrepareXferOp(xferOp, options).failed())
       return failure();
 
     auto buffers = allocBuffers(rewriter, xferOp);
     auto *newXfer = rewriter.clone(*xferOp.getOperation());
     newXfer->setAttr(kPassLabel, rewriter.getUnitAttr());
-    if (xferOp.mask()) {
-      dyn_cast<TransferReadOp>(newXfer).maskMutable().assign(
+    if (xferOp.getMask()) {
+      dyn_cast<TransferReadOp>(newXfer).getMaskMutable().assign(
           buffers.maskBuffer);
     }
 
     Location loc = xferOp.getLoc();
     rewriter.create<memref::StoreOp>(loc, newXfer->getResult(0),
                                      buffers.dataBuffer);
     rewriter.replaceOpWithNewOp<memref::LoadOp>(xferOp, buffers.dataBuffer);
 
struct PrepareTransferWriteConversion
 
   LogicalResult matchAndRewrite(TransferWriteOp xferOp,
                                 PatternRewriter &rewriter) const override {
     if (checkPrepareXferOp(xferOp, options).failed())
       return failure();
 
     Location loc = xferOp.getLoc();
     auto buffers = allocBuffers(rewriter, xferOp);
-    rewriter.create<memref::StoreOp>(loc, xferOp.vector(), buffers.dataBuffer);
+    rewriter.create<memref::StoreOp>(loc, xferOp.getVector(),
+                                     buffers.dataBuffer);
     auto loadedVec = rewriter.create<memref::LoadOp>(loc, buffers.dataBuffer);
     rewriter.updateRootInPlace(xferOp, [&]() {
-      xferOp.vectorMutable().assign(loadedVec);
+      xferOp.getVectorMutable().assign(loadedVec);
       xferOp->setAttr(kPassLabel, rewriter.getUnitAttr());
     });
 
-    if (xferOp.mask()) {
-      rewriter.updateRootInPlace(
-          xferOp, [&]() { xferOp.maskMutable().assign(buffers.maskBuffer); });
+    if (xferOp.getMask()) {
+      rewriter.updateRootInPlace(xferOp, [&]() {
+        xferOp.getMaskMutable().assign(buffers.maskBuffer);
+      });
     }
 
     return success();
   }
 };
 
 /// Progressive lowering of vector transfer ops: Unpack one dimension.
 ///
LogicalResult matchAndRewrite(OpTy xferOp,
     auto dataBuffer = Strategy<OpTy>::getBuffer(xferOp);
     auto dataBufferType = dataBuffer.getType().template dyn_cast<MemRefType>();
     auto castedDataType = unpackOneDim(dataBufferType);
     auto castedDataBuffer =
         locB.create<vector::TypeCastOp>(castedDataType, dataBuffer);
 
     // If the xferOp has a mask: Find and cast mask buffer.
     Value castedMaskBuffer;
-    if (xferOp.mask()) {
+    if (xferOp.getMask()) {
       auto maskBuffer = getMaskBuffer(xferOp);
       auto maskBufferType =
           maskBuffer.getType().template dyn_cast<MemRefType>();
       if (xferOp.isBroadcastDim(0) || xferOp.getMaskType().getRank() == 1) {
         // Do not unpack a dimension of the mask, if:
         // * To-be-unpacked transfer op dimension is a broadcast.
         // * Mask is 1D, i.e., the mask cannot be further unpacked.
         //   (That means that all remaining dimensions of the transfer op must
auto result = locB.create<scf::ForOp>(
                 OpTy newXfer = Strategy<OpTy>::rewriteOp(
                     b, this->options, xferOp, castedDataBuffer, iv, loopState);
 
                 // If old transfer op has a mask: Set mask on new transfer op.
                 // Special case: If the mask of the old transfer op is 1D and
                 // the
                 //               unpacked dim is not a broadcast, no mask is
                 //               needed on the new transfer op.
-                if (xferOp.mask() && (xferOp.isBroadcastDim(0) ||
+                if (xferOp.getMask() && (xferOp.isBroadcastDim(0) ||
                                          xferOp.getMaskType().getRank() > 1)) {
                   OpBuilder::InsertionGuard guard(b);
                   b.setInsertionPoint(newXfer); // Insert load before newXfer.
 
                   SmallVector<Value, 8> loadIndices;
                   Strategy<OpTy>::getBufferIndices(xferOp, loadIndices);
                   // In case of broadcast: Use same indices to load from memref
                   // as before.
                   if (!xferOp.isBroadcastDim(0))
                     loadIndices.push_back(iv);
 
                   auto mask = b.create<memref::LoadOp>(loc, castedMaskBuffer,
                                                        loadIndices);
-                  rewriter.updateRootInPlace(
-                      newXfer, [&]() { newXfer.maskMutable().assign(mask); });
+                  rewriter.updateRootInPlace(newXfer, [&]() {
+                    newXfer.getMaskMutable().assign(mask);
+                  });
                 }
 
                 return loopState.empty() ? Value() : newXfer->getResult(0);
               },
               /*outOfBoundsCase=*/
               [&](OpBuilder &b, Location /*loc*/) {
                 return Strategy<OpTy>::handleOutOfBoundsDim(
                     b, xferOp, castedDataBuffer, iv, loopState);

 
 namespace lowering_n_d_unrolled {
 
 /// If the original transfer op has a mask, compute the mask of the new transfer
 /// op (for the current iteration `i`) and assign it.
 template <typename OpTy>
 static void maybeAssignMask(OpBuilder &b, OpTy xferOp, OpTy newXferOp,
                             int64_t i) {
-  if (!xferOp.mask())
+  if (!xferOp.getMask())
     return;
 
   if (xferOp.isBroadcastDim(0)) {
     // To-be-unpacked dimension is a broadcast, which does not have a
     // corresponding mask dimension. Mask attribute remains unchanged.
-    newXferOp.maskMutable().assign(xferOp.mask());
+    newXferOp.getMaskMutable().assign(xferOp.getMask());
     return;
   }
 
   if (xferOp.getMaskType().getRank() > 1) {
     // Unpack one dimension of the mask.
     OpBuilder::InsertionGuard guard(b);
     b.setInsertionPoint(newXferOp); // Insert load before newXfer.
 
     llvm::SmallVector<int64_t, 1> indices({i});
     Location loc = xferOp.getLoc();
-    auto newMask = b.create<vector::ExtractOp>(loc, xferOp.mask(), indices);
-    newXferOp.maskMutable().assign(newMask);
+    auto newMask = b.create<vector::ExtractOp>(loc, xferOp.getMask(), indices);
+    newXferOp.getMaskMutable().assign(newMask);
   }
 
   // If we end up here: The mask of the old transfer op is 1D and the unpacked
   // dim is not a broadcast, so no mask is needed on the new transfer op.
   // `generateInBoundsCheck` will have evaluated the mask already.
 }
 
 /// Progressive lowering of vector TransferReadOp with unrolling: Unpack one
void initialize() {
     setHasBoundedRewriteRecursion();
   }
 
   /// Return the vector into which the newly created TransferReadOp results
   /// are inserted.
   Value getResultVector(TransferReadOp xferOp,
                         PatternRewriter &rewriter) const {
     if (auto insertOp = getInsertOp(xferOp))
-      return insertOp.dest();
+      return insertOp.getDest();
     Location loc = xferOp.getLoc();
     return rewriter.create<vector::SplatOp>(loc, xferOp.getVectorType(),
-                                            xferOp.padding());
+                                            xferOp.getPadding());
   }
 
   /// If the result of the TransferReadOp has exactly one user, which is a
   /// vector::InsertOp, return that operation.
   vector::InsertOp getInsertOp(TransferReadOp xferOp) const {
     if (xferOp->hasOneUse()) {
       Operation *xferOpUser = *xferOp->getUsers().begin();
       if (auto insertOp = dyn_cast<vector::InsertOp>(xferOpUser))
         return insertOp;
     }
 
     return vector::InsertOp();
   }
 
   /// If the result of the TransferReadOp has exactly one user, which is a
   /// vector::InsertOp, return that operation's indices.
   void getInsertionIndices(TransferReadOp xferOp,
                            SmallVector<int64_t, 8> &indices) const {
     if (auto insertOp = getInsertOp(xferOp)) {
-      llvm::for_each(insertOp.position(), [&](Attribute attr) {
+      llvm::for_each(insertOp.getPosition(), [&](Attribute attr) {
         indices.push_back(attr.dyn_cast<IntegerAttr>().getInt());
       });
     }
   }
 
   /// Rewrite the op: Unpack one dimension. Can handle masks, out-of-bounds
   /// accesses, and broadcasts and transposes in permutation maps.
   LogicalResult matchAndRewrite(TransferReadOp xferOp,
for (int64_t i = 0; i < dimSize; ++i) {
             SmallVector<Value, 8> xferIndices;
             getXferIndices(b, xferOp, iv, xferIndices);
 
             // Indices for the new vector.insert op.
             SmallVector<int64_t, 8> insertionIndices;
             getInsertionIndices(xferOp, insertionIndices);
             insertionIndices.push_back(i);
 
-            auto inBoundsAttr = dropFirstElem(b, xferOp.in_boundsAttr());
+            auto inBoundsAttr = dropFirstElem(b, xferOp.getInBoundsAttr());
             auto newXferOp = b.create<vector::TransferReadOp>(
-                loc, newXferVecType, xferOp.source(), xferIndices,
+                loc, newXferVecType, xferOp.getSource(), xferIndices,
                 AffineMapAttr::get(unpackedPermutationMap(b, xferOp)),
-                xferOp.padding(), Value(), inBoundsAttr);
+                xferOp.getPadding(), Value(), inBoundsAttr);
             maybeAssignMask(b, xferOp, newXferOp, i);
             return b.create<vector::InsertOp>(loc, newXferOp, vec,
                                               insertionIndices);
           },
           /*outOfBoundsCase=*/
           [&](OpBuilder &b, Location loc) {
             // Loop through original (unmodified) vector.
             return vec;
void initialize() {
     // This pattern recursively unpacks one dimension at a time. The recursion
     // bounded as the rank is strictly decreasing.
     setHasBoundedRewriteRecursion();
   }
 
   /// Return the vector from which newly generated ExtracOps will extract.
   Value getDataVector(TransferWriteOp xferOp) const {
     if (auto extractOp = getExtractOp(xferOp))
-      return extractOp.vector();
-    return xferOp.vector();
+      return extractOp.getVector();
+    return xferOp.getVector();
   }
 
   /// If the input of the given TransferWriteOp is an ExtractOp, return it.
   vector::ExtractOp getExtractOp(TransferWriteOp xferOp) const {
-    if (auto *op = xferOp.vector().getDefiningOp())
+    if (auto *op = xferOp.getVector().getDefiningOp())
       return dyn_cast<vector::ExtractOp>(op);
     return vector::ExtractOp();
   }
 
   /// If the input of the given TransferWriteOp is an ExtractOp, return its
   /// indices.
   void getExtractionIndices(TransferWriteOp xferOp,
                             SmallVector<int64_t, 8> &indices) const {
     if (auto extractOp = getExtractOp(xferOp)) {
-      llvm::for_each(extractOp.position(), [&](Attribute attr) {
+      llvm::for_each(extractOp.getPosition(), [&](Attribute attr) {
         indices.push_back(attr.dyn_cast<IntegerAttr>().getInt());
       });
     }
   }
 
   /// Rewrite the op: Unpack one dimension. Can handle masks, out-of-bounds
   /// accesses, and broadcasts and transposes in permutation maps.
   LogicalResult matchAndRewrite(TransferWriteOp xferOp,
                                 PatternRewriter &rewriter) const override {
     if (xferOp.getVectorType().getRank() <= options.targetRank)
       return failure();
     if (isTensorOp(xferOp) && !options.lowerTensors)
       return failure();
     // Transfer ops that modify the element type are not supported atm.
     if (xferOp.getVectorType().getElementType() !=
         xferOp.getShapedType().getElementType())
       return failure();
 
     auto vec = getDataVector(xferOp);
     auto xferVecType = xferOp.getVectorType();
     int64_t dimSize = xferVecType.getShape()[0];
-    auto source = xferOp.source(); // memref or tensor to be written to.
+    auto source = xferOp.getSource(); // memref or tensor to be written to.
     auto sourceType = isTensorOp(xferOp) ? xferOp.getShapedType() : Type();
 
     // Generate fully unrolled loop of transfer ops.
     Location loc = xferOp.getLoc();
     for (int64_t i = 0; i < dimSize; ++i) {
       Value iv = rewriter.create<arith::ConstantIndexOp>(loc, i);
 
       auto updatedSource = generateInBoundsCheck(
           rewriter, xferOp, iv, unpackedDim(xferOp),
           isTensorOp(xferOp) ? TypeRange(sourceType) : TypeRange(),
           /*inBoundsCase=*/
           [&](OpBuilder &b, Location loc) {
             // Indices for the new transfer op.
             SmallVector<Value, 8> xferIndices;
             getXferIndices(b, xferOp, iv, xferIndices);
 
             // Indices for the new vector.extract op.
             SmallVector<int64_t, 8> extractionIndices;
             getExtractionIndices(xferOp, extractionIndices);
             extractionIndices.push_back(i);
 
             auto extracted =
                 b.create<vector::ExtractOp>(loc, vec, extractionIndices);
-            auto inBoundsAttr = dropFirstElem(b, xferOp.in_boundsAttr());
+            auto inBoundsAttr = dropFirstElem(b, xferOp.getInBoundsAttr());
             auto newXferOp = b.create<vector::TransferWriteOp>(
                 loc, sourceType, extracted, source, xferIndices,
                 AffineMapAttr::get(unpackedPermutationMap(b, xferOp)), Value(),
                 inBoundsAttr);
 
             maybeAssignMask(b, xferOp, newXferOp, i);
 
             return isTensorOp(xferOp) ? newXferOp->getResult(0) : Value();

 
 /// Compute the indices into the memref for the LoadOp/StoreOp generated as
 /// part of TransferOp1dConversion. Return the memref dimension on which
 /// the transfer is operating. A return value of None indicates a broadcast.
 template <typename OpTy>
 static Optional<int64_t>
 get1dMemrefIndices(OpBuilder &b, OpTy xferOp, Value iv,
                    SmallVector<Value, 8> &memrefIndices) {
-  auto indices = xferOp.indices();
-  auto map = xferOp.permutation_map();
+  auto indices = xferOp.getIndices();
+  auto map = xferOp.getPermutationMap();
   assert(xferOp.getTransferRank() > 0 && "unexpected 0-d transfer");
 
   memrefIndices.append(indices.begin(), indices.end());
   assert(map.getNumResults() == 1 &&
          "Expected 1 permutation map result for 1D transfer");
   if (auto expr = map.getResult(0).template dyn_cast<AffineDimExpr>()) {
     Location loc = xferOp.getLoc();
     auto dim = expr.getPosition();
static void generateForLoopBody(OpBuilder &b, Location loc,
     auto vec = loopState[0];
 
     // In case of out-of-bounds access, leave `vec` as is (was initialized with
     // padding value).
     auto nextVec = generateInBoundsCheck(
         b, xferOp, iv, dim, TypeRange(xferOp.getVectorType()),
         /*inBoundsCase=*/
         [&](OpBuilder &b, Location loc) {
-          Value val = b.create<memref::LoadOp>(loc, xferOp.source(), indices);
+          Value val =
+              b.create<memref::LoadOp>(loc, xferOp.getSource(), indices);
           return b.create<vector::InsertElementOp>(loc, val, vec, iv);
         },
         /*outOfBoundsCase=*/
         [&](OpBuilder & /*b*/, Location loc) { return vec; });
     b.create<scf::YieldOp>(loc, nextVec);
   }
 
   static Value initialLoopState(OpBuilder &b, TransferReadOp xferOp) {
     // Inititalize vector with padding value.
     Location loc = xferOp.getLoc();
     return b.create<vector::SplatOp>(loc, xferOp.getVectorType(),
-                                     xferOp.padding());
+                                     xferOp.getPadding());
   }
 };
 
 /// Codegen strategy for TransferWriteOp.
 template <>
 struct Strategy1d<TransferWriteOp> {
   static void generateForLoopBody(OpBuilder &b, Location loc,
                                   TransferWriteOp xferOp, Value iv,
                                   ValueRange /*loopState*/) {
     SmallVector<Value, 8> indices;
     auto dim = get1dMemrefIndices(b, xferOp, iv, indices);
 
     // Nothing to do in case of out-of-bounds access.
     generateInBoundsCheck(
         b, xferOp, iv, dim,
         /*inBoundsCase=*/[&](OpBuilder &b, Location loc) {
           auto val =
-              b.create<vector::ExtractElementOp>(loc, xferOp.vector(), iv);
-          b.create<memref::StoreOp>(loc, val, xferOp.source(), indices);
+              b.create<vector::ExtractElementOp>(loc, xferOp.getVector(), iv);
+          b.create<memref::StoreOp>(loc, val, xferOp.getSource(), indices);
         });
     b.create<scf::YieldOp>(loc);
   }
 
   static Value initialLoopState(OpBuilder &b, TransferWriteOp xferOp) {
     return Value();
   }
 };

 struct TransferOp1dConversion : public VectorToSCFPattern<OpTy> {
   using VectorToSCFPattern<OpTy>::VectorToSCFPattern;
 
   LogicalResult matchAndRewrite(OpTy xferOp,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (xferOp.getTransferRank() == 0)
       return failure();
-    auto map = xferOp.permutation_map();
+    auto map = xferOp.getPermutationMap();
     auto memRefType = xferOp.getShapedType().template dyn_cast<MemRefType>();
 
     if (!memRefType)
       return failure();
     if (xferOp.getVectorType().getRank() != 1)
       return failure();
     if (map.isMinorIdentity() && isLastMemrefDimUnitStride(memRefType))
       return failure(); // Handled by ConvertVectorToLLVM

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRV.cpp

struct VectorBitcastConvert final
 
   LogicalResult
   matchAndRewrite(vector::BitCastOp bitcastOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = getTypeConverter()->convertType(bitcastOp.getType());
     if (!dstType)
       return failure();
 
-    if (dstType == adaptor.source().getType())
-      rewriter.replaceOp(bitcastOp, adaptor.source());
+    if (dstType == adaptor.getSource().getType())
+      rewriter.replaceOp(bitcastOp, adaptor.getSource());
     else
       rewriter.replaceOpWithNewOp<spirv::BitcastOp>(bitcastOp, dstType,
-                                                    adaptor.source());
+                                                    adaptor.getSource());
 
     return success();
   }
 };
 
 struct VectorBroadcastConvert final
     : public OpConversionPattern<vector::BroadcastOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::BroadcastOp broadcastOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
-    if (broadcastOp.source().getType().isa<VectorType>() ||
+    if (broadcastOp.getSource().getType().isa<VectorType>() ||
         !spirv::CompositeType::isValid(broadcastOp.getVectorType()))
       return failure();
     SmallVector<Value, 4> source(broadcastOp.getVectorType().getNumElements(),
-                                 adaptor.source());
+                                 adaptor.getSource());
     rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
         broadcastOp, broadcastOp.getVectorType(), source);
     return success();
   }
 };
 
 struct VectorExtractOpConvert final
     : public OpConversionPattern<vector::ExtractOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::ExtractOp extractOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Only support extracting a scalar value now.
     VectorType resultVectorType = extractOp.getType().dyn_cast<VectorType>();
     if (resultVectorType && resultVectorType.getNumElements() > 1)
       return failure();
 
     auto dstType = getTypeConverter()->convertType(extractOp.getType());
     if (!dstType)
       return failure();
 
-    if (adaptor.vector().getType().isa<spirv::ScalarType>()) {
-      rewriter.replaceOp(extractOp, adaptor.vector());
+    if (adaptor.getVector().getType().isa<spirv::ScalarType>()) {
+      rewriter.replaceOp(extractOp, adaptor.getVector());
       return success();
     }
 
-    int32_t id = getFirstIntValue(extractOp.position());
+    int32_t id = getFirstIntValue(extractOp.getPosition());
     rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(
-        extractOp, adaptor.vector(), id);
+        extractOp, adaptor.getVector(), id);
     return success();
   }
 };
 
 struct VectorExtractStridedSliceOpConvert final
     : public OpConversionPattern<vector::ExtractStridedSliceOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::ExtractStridedSliceOp extractOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto dstType = getTypeConverter()->convertType(extractOp.getType());
     if (!dstType)
       return failure();
 
-
-    uint64_t offset = getFirstIntValue(extractOp.offsets());
-    uint64_t size = getFirstIntValue(extractOp.sizes());
-    uint64_t stride = getFirstIntValue(extractOp.strides());
+    uint64_t offset = getFirstIntValue(extractOp.getOffsets());
+    uint64_t size = getFirstIntValue(extractOp.getSizes());
+    uint64_t stride = getFirstIntValue(extractOp.getStrides());
     if (stride != 1)
       return failure();
 
     Value srcVector = adaptor.getOperands().front();
 
     // Extract vector<1xT> case.
     if (dstType.isa<spirv::ScalarType>()) {
       rewriter.replaceOpWithNewOp<spirv::CompositeExtractOp>(extractOp,
struct VectorFmaOpConvert final : public OpConversionPattern<vector::FMAOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::FMAOp fmaOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (!spirv::CompositeType::isValid(fmaOp.getVectorType()))
       return failure();
     rewriter.replaceOpWithNewOp<spirv::GLSLFmaOp>(
-        fmaOp, fmaOp.getType(), adaptor.lhs(), adaptor.rhs(), adaptor.acc());
+        fmaOp, fmaOp.getType(), adaptor.getLhs(), adaptor.getRhs(),
+        adaptor.getAcc());
     return success();
   }
 };
 
 struct VectorInsertOpConvert final
     : public OpConversionPattern<vector::InsertOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::InsertOp insertOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     // Special case for inserting scalar values into size-1 vectors.
     if (insertOp.getSourceType().isIntOrFloat() &&
         insertOp.getDestVectorType().getNumElements() == 1) {
-      rewriter.replaceOp(insertOp, adaptor.source());
+      rewriter.replaceOp(insertOp, adaptor.getSource());
       return success();
     }
 
     if (insertOp.getSourceType().isa<VectorType>() ||
         !spirv::CompositeType::isValid(insertOp.getDestVectorType()))
       return failure();
-    int32_t id = getFirstIntValue(insertOp.position());
+    int32_t id = getFirstIntValue(insertOp.getPosition());
     rewriter.replaceOpWithNewOp<spirv::CompositeInsertOp>(
-        insertOp, adaptor.source(), adaptor.dest(), id);
+        insertOp, adaptor.getSource(), adaptor.getDest(), id);
     return success();
   }
 };
 
 struct VectorExtractElementOpConvert final
     : public OpConversionPattern<vector::ExtractElementOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::ExtractElementOp extractElementOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (!spirv::CompositeType::isValid(extractElementOp.getVectorType()))
       return failure();
     rewriter.replaceOpWithNewOp<spirv::VectorExtractDynamicOp>(
-        extractElementOp, extractElementOp.getType(), adaptor.vector(),
-        extractElementOp.position());
+        extractElementOp, extractElementOp.getType(), adaptor.getVector(),
+        extractElementOp.getPosition());
     return success();
   }
 };
 
 struct VectorInsertElementOpConvert final
     : public OpConversionPattern<vector::InsertElementOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::InsertElementOp insertElementOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     if (!spirv::CompositeType::isValid(insertElementOp.getDestVectorType()))
       return failure();
     rewriter.replaceOpWithNewOp<spirv::VectorInsertDynamicOp>(
-        insertElementOp, insertElementOp.getType(), insertElementOp.dest(),
-        adaptor.source(), insertElementOp.position());
+        insertElementOp, insertElementOp.getType(), insertElementOp.getDest(),
+        adaptor.getSource(), insertElementOp.getPosition());
     return success();
   }
 };
 
 struct VectorInsertStridedSliceOpConvert final
     : public OpConversionPattern<vector::InsertStridedSliceOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::InsertStridedSliceOp insertOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     Value srcVector = adaptor.getOperands().front();
     Value dstVector = adaptor.getOperands().back();
 
-    uint64_t stride = getFirstIntValue(insertOp.strides());
+    uint64_t stride = getFirstIntValue(insertOp.getStrides());
     if (stride != 1)
       return failure();
-    uint64_t offset = getFirstIntValue(insertOp.offsets());
+    uint64_t offset = getFirstIntValue(insertOp.getOffsets());
 
     if (srcVector.getType().isa<spirv::ScalarType>()) {
       assert(!dstVector.getType().isa<spirv::ScalarType>());
       rewriter.replaceOpWithNewOp<spirv::CompositeInsertOp>(
           insertOp, dstVector.getType(), srcVector, dstVector,
           rewriter.getI32ArrayAttr(offset));
       return success();
     }
public:
   using OpConversionPattern<vector::SplatOp>::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::SplatOp op, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     VectorType dstVecType = op.getType();
     if (!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();
   }
 };
 
 struct VectorShuffleOpConvert final
     : public OpConversionPattern<vector::ShuffleOp> {
   using OpConversionPattern::OpConversionPattern;
 
   LogicalResult
   matchAndRewrite(vector::ShuffleOp shuffleOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
     auto oldResultType = shuffleOp.getVectorType();
     if (!spirv::CompositeType::isValid(oldResultType))
       return failure();
     auto newResultType = getTypeConverter()->convertType(oldResultType);
 
     auto oldSourceType = shuffleOp.getV1VectorType();
     if (oldSourceType.getNumElements() > 1) {
       SmallVector<int32_t, 4> components = llvm::to_vector<4>(
-          llvm::map_range(shuffleOp.mask(), [](Attribute attr) -> int32_t {
+          llvm::map_range(shuffleOp.getMask(), [](Attribute attr) -> int32_t {
             return attr.cast<IntegerAttr>().getValue().getZExtValue();
           }));
       rewriter.replaceOpWithNewOp<spirv::VectorShuffleOp>(
-          shuffleOp, newResultType, adaptor.v1(), adaptor.v2(),
+          shuffleOp, newResultType, adaptor.getV1(), adaptor.getV2(),
           rewriter.getI32ArrayAttr(components));
       return success();
     }
 
-    SmallVector<Value, 2> oldOperands = {adaptor.v1(), adaptor.v2()};
+    SmallVector<Value, 2> oldOperands = {adaptor.getV1(), adaptor.getV2()};
     SmallVector<Value, 4> newOperands;
     newOperands.reserve(oldResultType.getNumElements());
-    for (const APInt &i : shuffleOp.mask().getAsValueRange<IntegerAttr>()) {
+    for (const APInt &i : shuffleOp.getMask().getAsValueRange<IntegerAttr>()) {
       newOperands.push_back(oldOperands[i.getZExtValue()]);
     }
     rewriter.replaceOpWithNewOp<spirv::CompositeConstructOp>(
         shuffleOp, newResultType, newOperands);
 
     return success();
   }
 };

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

if (write.insertSliceOp) {
       if (skip || !otherUser)
         continue;
       maybeTransferReadUser = otherUser;
     }
 
     LLVM_DEBUG(DBGS() << "maybeTransferReadUser: " << *maybeTransferReadUser
                       << "\n");
     auto read = dyn_cast<vector::TransferReadOp>(maybeTransferReadUser);
-    if (read && read.indices() == write.transferWriteOp.indices() &&
+    if (read && read.getIndices() == write.transferWriteOp.getIndices() &&
         read.getVectorType() == write.transferWriteOp.getVectorType())
       return HoistableRead{read, sliceOp};
   }
   return HoistableRead();
 }
 
 /// Check if the chunk of data inserted by the HoistableWrite are read by any
 /// other op than the HoistableRead candidate.

 /// vector.transfer_write + optional insert_slice or if any of the indexings
 /// is `forOp`-dependent.
 static HoistableWrite
 getLoopInvariantTransferWriteOpDefining(scf::ForOp forOp,
                                         OpOperand &yieldOperand) {
   Value v = yieldOperand.get();
   if (auto write = v.getDefiningOp<vector::TransferWriteOp>()) {
     // Indexing must not depend on `forOp`.
-    for (Value operand : write.indices())
+    for (Value operand : write.getIndices())
       if (!forOp.isDefinedOutsideOfLoop(operand))
         return HoistableWrite();
 
     return HoistableWrite{write, nullptr};
   }
 
   if (auto insertSliceOp = v.getDefiningOp<tensor::InsertSliceOp>()) {
     // Inserted slice must come from vector.transfer_write.
static void hoistReadWrite(HoistableRead read, HoistableWrite write,
   assert(tensorBBArg.getArgNumber() >= /*numIvs=*/1);
   unsigned initArgNumber = tensorBBArg.getArgNumber() - /*numIvs=*/1;
 
   // Update the source tensor.
   if (read.extractSliceOp)
     read.extractSliceOp.sourceMutable().assign(
         forOp.getInitArgs()[initArgNumber]);
   else
-    read.transferReadOp.sourceMutable().assign(
+    read.transferReadOp.getSourceMutable().assign(
         forOp.getInitArgs()[initArgNumber]);
 
   // Hoist write after.
   if (write.insertSliceOp)
     write.insertSliceOp->moveAfter(forOp);
   write.transferWriteOp->moveAfter(forOp);
 
   // Update the yield.
   auto yieldOp = cast<scf::YieldOp>(forOp.getRegion().front().getTerminator());
   if (write.insertSliceOp)
     yieldOp->setOperand(initArgNumber, write.insertSliceOp.dest());
   else
-    yieldOp->setOperand(initArgNumber, write.transferWriteOp.source());
+    yieldOp->setOperand(initArgNumber, write.transferWriteOp.getSource());
 
   // Rewrite `loop` with additional new yields.
   OpBuilder b(read.transferReadOp);
-  auto newForOp = cloneWithNewYields(b, forOp, read.transferReadOp.vector(),
-                                     write.transferWriteOp.vector());
+  auto newForOp = cloneWithNewYields(b, forOp, read.transferReadOp.getVector(),
+                                     write.transferWriteOp.getVector());
   // Transfer write has been hoisted, need to update the vector and tensor
   // source. Replace the result of the loop to use the new tensor created
   // outside the loop.
   // Depending on whether a insert_slice is present or not, it carries the
   // update on the tensor operands.
   if (write.insertSliceOp) {
     newForOp.getResult(initArgNumber)
         .replaceAllUsesWith(write.insertSliceOp.getResult());
-    write.transferWriteOp.sourceMutable().assign(read.extractSliceOp.result());
+    write.transferWriteOp.getSourceMutable().assign(
+        read.extractSliceOp.result());
     write.insertSliceOp.destMutable().assign(read.extractSliceOp.source());
   } else {
     newForOp.getResult(initArgNumber)
         .replaceAllUsesWith(write.transferWriteOp.getResult());
-    write.transferWriteOp.sourceMutable().assign(
+    write.transferWriteOp.getSourceMutable().assign(
         newForOp.getResult(initArgNumber));
   }
 
   // Always update with the newly yield tensor and vector.
-  write.transferWriteOp.vectorMutable().assign(newForOp.getResults().back());
+  write.transferWriteOp.getVectorMutable().assign(newForOp.getResults().back());
 }
 
 // To hoist transfer op on tensor the logic can be significantly simplified
 // compared to the case on buffer. The transformation follows this logic:
 // 1. Look for transfer_write with a single use from ForOp yield
 // 2. Check the uses of the matching block argument and look for a transfer_read
 // with the same indices.
 // 3. Check that all the other uses of the tensor argument are either disjoint
func.walk([&](scf::ForOp forOp) {
         if (!write.transferWriteOp || !write.transferWriteOp->hasOneUse())
           continue;
         LLVM_DEBUG(dbgs() << "\n";
                    DBGS() << "Candidate write for hoisting: "
                           << *write.transferWriteOp.getOperation() << "\n");
         if (write.insertSliceOp)
           LLVM_DEBUG(DBGS() << "Candidate insert_slice for hoisting: "
                             << *write.insertSliceOp.getOperation() << "\n");
-        if (llvm::any_of(write.transferWriteOp.indices(),
+        if (llvm::any_of(write.transferWriteOp.getIndices(),
                          [&forOp](Value index) {
                            return !forOp.isDefinedOutsideOfLoop(index);
                          }))
           continue;
         // Find a read with the same type and indices.
         HoistableRead matchingRead =
             findMatchingTransferRead(write, it.value());
         // Make sure none of the other uses read the part of the tensor modified
func.walk([&](vector::TransferReadOp transferRead) {
       SetVector<Operation *> forwardSlice;
       getForwardSlice(transferRead.getOperation(), &forwardSlice);
 
       // Look for the last TransferWriteOp in the forwardSlice of
       // `transferRead` that operates on the same memref.
       vector::TransferWriteOp transferWrite;
       for (auto *sliceOp : llvm::reverse(forwardSlice)) {
         auto candidateWrite = dyn_cast<vector::TransferWriteOp>(sliceOp);
-        if (!candidateWrite || candidateWrite.source() != transferRead.source())
+        if (!candidateWrite ||
+            candidateWrite.getSource() != transferRead.getSource())
           continue;
         transferWrite = candidateWrite;
       }
 
       // All operands of the TransferRead must be defined outside of the loop.
       for (auto operand : transferRead.getOperands())
         if (!loop.isDefinedOutsideOfLoop(operand))
           return WalkResult::advance();
 
       // Only hoist transfer_read / transfer_write pairs for now.
       if (!transferWrite)
         return WalkResult::advance();
 
       LLVM_DEBUG(DBGS() << "Candidate: " << *transferWrite.getOperation()
                         << "\n");
 
       // Approximate aliasing by checking that:
       //   1. indices are the same,
       //   2. no other operations in the loop access the same memref except
       //      for transfer_read/transfer_write accessing statically disjoint
       //      slices.
-      if (transferRead.indices() != transferWrite.indices() &&
+      if (transferRead.getIndices() != transferWrite.getIndices() &&
           transferRead.getVectorType() == transferWrite.getVectorType())
         return WalkResult::advance();
 
       // TODO: may want to memoize this information for performance but it
       // likely gets invalidated often.
       DominanceInfo dom(loop);
       if (!dom.properlyDominates(transferRead.getOperation(), transferWrite))
         return WalkResult::advance();
-      for (auto &use : transferRead.source().getUses()) {
+      for (auto &use : transferRead.getSource().getUses()) {
         if (!loop->isAncestor(use.getOwner()))
           continue;
         if (use.getOwner() == transferRead.getOperation() ||
             use.getOwner() == transferWrite.getOperation())
           continue;
         if (auto transferWriteUse =
                 dyn_cast<vector::TransferWriteOp>(use.getOwner())) {
           if (!vector::isDisjointTransferSet(
func.walk([&](vector::TransferReadOp transferRead) {
       // Hoist read before.
       loop.moveOutOfLoop(transferRead);
 
       // Hoist write after.
       transferWrite->moveAfter(loop);
 
       // Rewrite `loop` with new yields by cloning and erase the original loop.
       OpBuilder b(transferRead);
-      auto newForOp = cloneWithNewYields(b, loop, transferRead.vector(),
-                                         transferWrite.vector());
+      auto newForOp = cloneWithNewYields(b, loop, transferRead.getVector(),
+                                         transferWrite.getVector());
 
       // Transfer write has been hoisted, need to update the written value to
       // the value yielded by the newForOp.
-      transferWrite.vector().replaceAllUsesWith(
+      transferWrite.getVector().replaceAllUsesWith(
           newForOp.getResults().take_back()[0]);
 
       changed = true;
       loop.erase();
       // Need to interrupt and restart because erasing the loop messes up the
       // walk.
       return WalkResult::interrupt();
     });
   }
 }

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

LogicalResult rewriteUser(PatternRewriter &rewriter, tensor::PadOp padOp,
     // Low padding must be static 0.
     if (!padOp.hasZeroLowPad())
       return failure();
     // Pad value must be a constant.
     auto padValue = padOp.getConstantPaddingValue();
     if (!padValue)
       return failure();
     // Padding value of existing `xferOp` is unused.
-    if (xferOp.hasOutOfBoundsDim() || xferOp.mask())
+    if (xferOp.hasOutOfBoundsDim() || xferOp.getMask())
       return failure();
 
     rewriter.updateRootInPlace(xferOp, [&]() {
       SmallVector<bool> inBounds(xferOp.getVectorType().getRank(), false);
       xferOp->setAttr(xferOp.getInBoundsAttrName(),
                       rewriter.getBoolArrayAttr(inBounds));
-      xferOp.sourceMutable().assign(padOp.source());
-      xferOp.paddingMutable().assign(padValue);
+      xferOp.getSourceMutable().assign(padOp.source());
+      xferOp.getPaddingMutable().assign(padValue);
     });
 
     return success();
   }
 };
 
 /// Rewrite use of tensor::PadOp result in TransferWriteOp.
 /// This pattern rewrites TransferWriteOps that write to a padded tensor
LogicalResult rewriteUser(PatternRewriter &rewriter, tensor::PadOp padOp,
     if (!hasSameTensorSize(padOp.source(), trimPadding))
       return failure();
 
     // Insert the new TransferWriteOp at position of the old TransferWriteOp.
     rewriter.setInsertionPoint(xferOp);
 
     SmallVector<bool> inBounds(xferOp.getVectorType().getRank(), false);
     auto newXferOp = rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(
-        xferOp, padOp.source().getType(), xferOp.vector(), padOp.source(),
-        xferOp.indices(), xferOp.permutation_mapAttr(), xferOp.mask(),
+        xferOp, padOp.source().getType(), xferOp.getVector(), padOp.source(),
+        xferOp.getIndices(), xferOp.getPermutationMapAttr(), xferOp.getMask(),
         rewriter.getBoolArrayAttr(inBounds));
     rewriter.replaceOp(trimPadding, newXferOp->getResult(0));
 
     return success();
   }
 
   /// Check if `beforePadding` and `afterTrimming` have the same tensor size,
   /// i.e., same dimensions.

 }
 
 /// TODO: use interfaces, side-effects and aliasing analysis as appropriate,
 /// when available.
 LogicalResult LinalgCopyVTRForwardingPattern::matchAndRewrite(
     vector::TransferReadOp xferOp, PatternRewriter &rewriter) const {
 
   // TODO: support mask.
-  if (xferOp.mask())
+  if (xferOp.getMask())
     return failure();
 
   // Transfer into `view`.
-  Value viewOrAlloc = xferOp.source();
+  Value viewOrAlloc = xferOp.getSource();
   if (!viewOrAlloc.getDefiningOp<memref::ViewOp>() &&
       !viewOrAlloc.getDefiningOp<memref::AllocOp>())
     return failure();
 
   LDBG(viewOrAlloc);
 
   // Ensure there is exactly one subview of `viewOrAlloc` defining `subView`.
   memref::SubViewOp subViewOp = getSubViewUseIfUnique(viewOrAlloc);
if (auto newFillOp = dyn_cast<FillOp>(u.getOwner())) {
       LDBG("fill candidate " << *newFillOp);
       if (mayExistInterleavedUses(newFillOp, copyOp, {viewOrAlloc, subView}))
         continue;
       maybeFillOp = newFillOp;
       break;
     }
   }
   // Ensure padding matches.
-  if (maybeFillOp && xferOp.padding() != maybeFillOp.value())
+  if (maybeFillOp && xferOp.getPadding() != maybeFillOp.value())
     return failure();
   if (maybeFillOp)
     LDBG("with maybeFillOp " << *maybeFillOp);
 
   // `in` is the subview that memref.copy reads. Replace it.
   Value in = copyOp.source();
 
   // memref.copy + linalg.fill can be used to create a padded local buffer.
   // The `masked` attribute is only valid on this padded buffer.
   // When forwarding to vector.transfer_read, the attribute must be reset
   // conservatively.
   Value res = rewriter.create<vector::TransferReadOp>(
-      xferOp.getLoc(), xferOp.getVectorType(), in, xferOp.indices(),
-      xferOp.permutation_mapAttr(), xferOp.padding(), xferOp.mask(),
+      xferOp.getLoc(), xferOp.getVectorType(), in, xferOp.getIndices(),
+      xferOp.getPermutationMapAttr(), xferOp.getPadding(), xferOp.getMask(),
       // in_bounds is explicitly reset
       /*inBoundsAttr=*/ArrayAttr());
 
   if (maybeFillOp)
     rewriter.eraseOp(maybeFillOp);
   rewriter.eraseOp(copyOp);
   rewriter.replaceOp(xferOp, res);
 
   return success();
 }
 
 /// TODO: use interfaces, side-effects and aliasing analysis as appropriate,
 /// when available.
 LogicalResult LinalgCopyVTWForwardingPattern::matchAndRewrite(
     vector::TransferWriteOp xferOp, PatternRewriter &rewriter) const {
   // TODO: support mask.
-  if (xferOp.mask())
+  if (xferOp.getMask())
     return failure();
 
   // Transfer into `viewOrAlloc`.
-  Value viewOrAlloc = xferOp.source();
+  Value viewOrAlloc = xferOp.getSource();
   if (!viewOrAlloc.getDefiningOp<memref::ViewOp>() &&
       !viewOrAlloc.getDefiningOp<memref::AllocOp>())
     return failure();
 
   // Ensure there is exactly one subview of `viewOrAlloc` defining `subView`.
   memref::SubViewOp subViewOp = getSubViewUseIfUnique(viewOrAlloc);
   if (!subViewOp)
     return failure();
LogicalResult LinalgCopyVTWForwardingPattern::matchAndRewrite(
   Value out = copyOp.target();
 
   // Forward vector.transfer into copy.
   // memref.copy + linalg.fill can be used to create a padded local buffer.
   // The `masked` attribute is only valid on this padded buffer.
   // When forwarding to vector.transfer_write, the attribute must be reset
   // conservatively.
   rewriter.create<vector::TransferWriteOp>(
-      xferOp.getLoc(), xferOp.vector(), out, xferOp.indices(),
-      xferOp.permutation_mapAttr(), xferOp.mask(),
+      xferOp.getLoc(), xferOp.getVector(), out, xferOp.getIndices(),
+      xferOp.getPermutationMapAttr(), xferOp.getMask(),
       // in_bounds is explicitly reset
       /*inBoundsAttr=*/ArrayAttr());
 
   rewriter.eraseOp(copyOp);
   rewriter.eraseOp(xferOp);
 
   return success();
 }

mlir/lib/Dialect/MemRef/Transforms/FoldSubViewOps.cpp

 }
 
 /// Helpers to access the memref operand for each op.
 template <typename LoadOrStoreOpTy>
 static Value getMemRefOperand(LoadOrStoreOpTy op) {
   return op.memref();
 }
 
-static Value getMemRefOperand(vector::TransferReadOp op) { return op.source(); }
+static Value getMemRefOperand(vector::TransferReadOp op) {
+  return op.getSource();
+}
 
 static Value getMemRefOperand(vector::TransferWriteOp op) {
-  return op.source();
+  return op.getSource();
 }
 
 /// Given the permutation map of the original
 /// `vector.transfer_read`/`vector.transfer_write` operations compute the
 /// permutation map to use after the subview is folded with it.
 static AffineMapAttr getPermutationMapAttr(MLIRContext *context,
                                            memref::SubViewOp subViewOp,
                                            AffineMap currPermutationMap) {
void LoadOpOfSubViewFolder<vector::TransferReadOp>::replaceOp(
     ArrayRef<Value> sourceIndices, PatternRewriter &rewriter) const {
   // TODO: support 0-d corner case.
   if (transferReadOp.getTransferRank() == 0)
     return;
   rewriter.replaceOpWithNewOp<vector::TransferReadOp>(
       transferReadOp, transferReadOp.getVectorType(), subViewOp.source(),
       sourceIndices,
       getPermutationMapAttr(rewriter.getContext(), subViewOp,
-                            transferReadOp.permutation_map()),
-      transferReadOp.padding(),
-      /*mask=*/Value(), transferReadOp.in_boundsAttr());
+                            transferReadOp.getPermutationMap()),
+      transferReadOp.getPadding(),
+      /*mask=*/Value(), transferReadOp.getInBoundsAttr());
 }
 
 template <typename StoreOpTy>
 void StoreOpOfSubViewFolder<StoreOpTy>::replaceOp(
     StoreOpTy storeOp, memref::SubViewOp subViewOp,
     ArrayRef<Value> sourceIndices, PatternRewriter &rewriter) const {
   rewriter.replaceOpWithNewOp<StoreOpTy>(storeOp, storeOp.value(),
                                          subViewOp.source(), sourceIndices);
 }
 
 template <>
 void StoreOpOfSubViewFolder<vector::TransferWriteOp>::replaceOp(
     vector::TransferWriteOp transferWriteOp, memref::SubViewOp subViewOp,
     ArrayRef<Value> sourceIndices, PatternRewriter &rewriter) const {
   // TODO: support 0-d corner case.
   if (transferWriteOp.getTransferRank() == 0)
     return;
   rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(
-      transferWriteOp, transferWriteOp.vector(), subViewOp.source(),
+      transferWriteOp, transferWriteOp.getVector(), subViewOp.source(),
       sourceIndices,
       getPermutationMapAttr(rewriter.getContext(), subViewOp,
-                            transferWriteOp.permutation_map()),
-      transferWriteOp.in_boundsAttr());
+                            transferWriteOp.getPermutationMap()),
+      transferWriteOp.getInBoundsAttr());
 }
 } // namespace
 
 template <typename OpTy>
 LogicalResult
 LoadOpOfSubViewFolder<OpTy>::matchAndRewrite(OpTy loadOp,
                                              PatternRewriter &rewriter) const {
   auto subViewOp =
       getMemRefOperand(loadOp).template getDefiningOp<memref::SubViewOp>();
   if (!subViewOp)
     return failure();
 
   SmallVector<Value, 4> sourceIndices;
   if (failed(resolveSourceIndices(loadOp.getLoc(), rewriter, subViewOp,
-                                  loadOp.indices(), sourceIndices)))
+                                  loadOp.getIndices(), sourceIndices)))
     return failure();
 
   replaceOp(loadOp, subViewOp, sourceIndices, rewriter);
   return success();
 }
 
 template <typename OpTy>
 LogicalResult
 StoreOpOfSubViewFolder<OpTy>::matchAndRewrite(OpTy storeOp,
                                               PatternRewriter &rewriter) const {
   auto subViewOp =
       getMemRefOperand(storeOp).template getDefiningOp<memref::SubViewOp>();
   if (!subViewOp)
     return failure();
 
   SmallVector<Value, 4> sourceIndices;
   if (failed(resolveSourceIndices(storeOp.getLoc(), rewriter, subViewOp,
-                                  storeOp.indices(), sourceIndices)))
+                                  storeOp.getIndices(), sourceIndices)))
     return failure();
 
   replaceOp(storeOp, subViewOp, sourceIndices, rewriter);
   return success();
 }
 
 void memref::populateFoldSubViewOpPatterns(RewritePatternSet &patterns) {
   patterns.add<LoadOpOfSubViewFolder<AffineLoadOp>,

mlir/lib/Dialect/Vector/IR/VectorOps.cpp

if (auto denseElts = c.getValue().dyn_cast<DenseIntElementsAttr>()) {
         return MaskFormat::AllTrue;
       if (val < 0)
         return MaskFormat::AllFalse;
     }
   } else if (auto m = mask.getDefiningOp<ConstantMaskOp>()) {
     // Inspect constant mask index. If the index exceeds the
     // dimension size, all bits are set. If the index is zero
     // or less, no bits are set.
-    ArrayAttr masks = m.mask_dim_sizes();
+    ArrayAttr masks = m.getMaskDimSizes();
     assert(masks.size() == 1);
     int64_t i = masks[0].cast<IntegerAttr>().getInt();
     int64_t u = m.getType().getDimSize(0);
     if (i >= u)
       return MaskFormat::AllTrue;
     if (i <= 0)
       return MaskFormat::AllFalse;
   }
return AffineMap::get(
         getAffineConstantExpr(0, shapedType.getContext()));
   return AffineMap::getMinorIdentityMap(
       shapedType.getRank(), vectorType.getRank() - elementVectorRank,
       shapedType.getContext());
 }
 
 bool mlir::vector::checkSameValueRAW(vector::TransferWriteOp defWrite,
                                      vector::TransferReadOp read) {
-  return !defWrite.hasOutOfBoundsDim() && !defWrite.mask() && !read.mask() &&
-         defWrite.indices() == read.indices() &&
+  return !defWrite.hasOutOfBoundsDim() && !defWrite.getMask() &&
+         !read.getMask() && defWrite.getIndices() == read.getIndices() &&
          defWrite.getVectorType() == read.getVectorType() &&
-         defWrite.permutation_map() == read.permutation_map();
+         defWrite.getPermutationMap() == read.getPermutationMap();
 }
 
 bool mlir::vector::checkSameValueWAW(vector::TransferWriteOp write,
                                      vector::TransferWriteOp priorWrite) {
-  return priorWrite.indices() == write.indices() &&
-         priorWrite.mask() == write.mask() &&
+  return priorWrite.getIndices() == write.getIndices() &&
+         priorWrite.getMask() == write.getMask() &&
          priorWrite.getVectorType() == write.getVectorType() &&
-         priorWrite.permutation_map() == write.permutation_map();
+         priorWrite.getPermutationMap() == write.getPermutationMap();
 }
 
 bool mlir::vector::isDisjointTransferIndices(
     VectorTransferOpInterface transferA, VectorTransferOpInterface transferB) {
   // For simplicity only look at transfer of same type.
   if (transferA.getVectorType() != transferB.getVectorType())
     return false;
   unsigned rankOffset = transferA.getLeadingShapedRank();
void vector::MultiDimReductionOp::build(OpBuilder &builder,
   build(builder, result, kind, source, builder.getI64ArrayAttr(reductionDims));
 }
 
 LogicalResult MultiDimReductionOp::inferReturnTypes(
     MLIRContext *, Optional<Location>, ValueRange operands,
     DictionaryAttr attributes, RegionRange,
     SmallVectorImpl<Type> &inferredReturnTypes) {
   MultiDimReductionOp::Adaptor op(operands, attributes);
-  auto vectorType = op.source().getType().cast<VectorType>();
+  auto vectorType = op.getSource().getType().cast<VectorType>();
   SmallVector<int64_t> targetShape;
   for (auto it : llvm::enumerate(vectorType.getShape()))
-    if (!llvm::any_of(op.reduction_dims().getValue(), [&](Attribute attr) {
+    if (!llvm::any_of(op.getReductionDims().getValue(), [&](Attribute attr) {
           return attr.cast<IntegerAttr>().getValue() == it.index();
         }))
       targetShape.push_back(it.value());
   // TODO: update to also allow 0-d vectors when available.
   if (targetShape.empty())
     inferredReturnTypes.push_back(vectorType.getElementType());
   else
     inferredReturnTypes.push_back(
         VectorType::get(targetShape, vectorType.getElementType()));
   return success();
 }
 
 OpFoldResult MultiDimReductionOp::fold(ArrayRef<Attribute> operands) {
   // Single parallel dim, this is a noop.
   if (getSourceVectorType().getRank() == 1 && !isReducedDim(0))
-    return source();
+    return getSource();
   return {};
 }
 
 Optional<SmallVector<int64_t, 4>> MultiDimReductionOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getSourceVectorType().getShape());
 }
 
 //===----------------------------------------------------------------------===//

 
 LogicalResult ReductionOp::verify() {
   // Verify for 1-D vector.
   int64_t rank = getVectorType().getRank();
   if (rank != 1)
     return emitOpError("unsupported reduction rank: ") << rank;
 
   // Verify supported reduction kind.
-  Type eltType = dest().getType();
-  if (!isSupportedCombiningKind(kind(), eltType))
+  Type eltType = getDest().getType();
+  if (!isSupportedCombiningKind(getKind(), eltType))
     return emitOpError("unsupported reduction type '")
-           << eltType << "' for kind '" << stringifyCombiningKind(kind())
+           << eltType << "' for kind '" << stringifyCombiningKind(getKind())
            << "'";
 
   // Verify optional accumulator.
-  if (acc()) {
-    if (kind() != CombiningKind::ADD && kind() != CombiningKind::MUL)
+  if (getAcc()) {
+    if (getKind() != CombiningKind::ADD && getKind() != CombiningKind::MUL)
       return emitOpError("no accumulator for reduction kind: ")
-             << stringifyCombiningKind(kind());
+             << stringifyCombiningKind(getKind());
     if (!eltType.isa<FloatType>())
       return emitOpError("no accumulator for type: ") << eltType;
   }
 
   return success();
 }
 
 ParseResult ReductionOp::parse(OpAsmParser &parser, OperationState &result) {
ParseResult ReductionOp::parse(OpAsmParser &parser, OperationState &result) {
   if (operandsInfo.empty() || operandsInfo.size() > 2)
     return parser.emitError(parser.getNameLoc(),
                             "unsupported number of operands");
   return success();
 }
 
 void ReductionOp::print(OpAsmPrinter &p) {
   p << " ";
-  kindAttr().print(p);
-  p << ", " << vector();
-  if (acc())
-    p << ", " << acc();
-  p << " : " << vector().getType() << " into " << dest().getType();
+  getKindAttr().print(p);
+  p << ", " << getVector();
+  if (getAcc())
+    p << ", " << getAcc();
+  p << " : " << getVector().getType() << " into " << getDest().getType();
 }
 
 Value mlir::vector::getVectorReductionOp(arith::AtomicRMWKind op,
                                          OpBuilder &builder, Location loc,
                                          Value vector) {
   switch (op) {
   case arith::AtomicRMWKind::addf:
   case arith::AtomicRMWKind::addi:
void ContractionOp::print(OpAsmPrinter &p) {
   llvm::StringSet<> traitAttrsSet;
   traitAttrsSet.insert(attrNames.begin(), attrNames.end());
   SmallVector<NamedAttribute, 8> attrs;
   for (auto attr : (*this)->getAttrs())
     if (traitAttrsSet.count(attr.getName().strref()) > 0)
       attrs.push_back(attr);
 
   auto dictAttr = DictionaryAttr::get(getContext(), attrs);
-  p << " " << dictAttr << " " << lhs() << ", ";
-  p << rhs() << ", " << acc();
-  if (masks().size() == 2)
-    p << ", " << masks();
+  p << " " << dictAttr << " " << getLhs() << ", ";
+  p << getRhs() << ", " << getAcc();
+  if (getMasks().size() == 2)
+    p << ", " << getMasks();
 
   p.printOptionalAttrDict((*this)->getAttrs(), attrNames);
-  p << " : " << lhs().getType() << ", " << rhs().getType() << " into "
+  p << " : " << getLhs().getType() << ", " << getRhs().getType() << " into "
     << getResultType();
 }
 
 static bool verifyDimMap(VectorType lhsType, VectorType rhsType,
                          const std::vector<std::pair<int64_t, int64_t>> &map) {
   for (auto &dimPair : map) {
     if (dimPair.first < 0 || dimPair.first >= lhsType.getRank() ||
         dimPair.second < 0 || dimPair.second >= rhsType.getRank() ||

 
 LogicalResult ContractionOp::verify() {
   auto lhsType = getLhsType();
   auto rhsType = getRhsType();
   auto accType = getAccType();
   auto resType = getResultType();
 
   // Verify that an indexing map was specified for each vector operand.
-  if (indexing_maps().size() != 3)
+  if (getIndexingMaps().size() != 3)
     return emitOpError("expected an indexing map for each vector operand");
 
   // Verify that each index map has 'numIterators' inputs, no symbols, and
   // that the number of map outputs equals the rank of its associated
   // vector operand.
-  unsigned numIterators = iterator_types().getValue().size();
-  for (const auto &it : llvm::enumerate(indexing_maps())) {
+  unsigned numIterators = getIteratorTypes().getValue().size();
+  for (const auto &it : llvm::enumerate(getIndexingMaps())) {
     auto index = it.index();
     auto map = it.value();
     if (map.getNumSymbols() != 0)
       return emitOpError("expected indexing map ")
              << index << " to have no symbols";
     auto vectorType = getOperand(index).getType().dyn_cast<VectorType>();
     unsigned rank = vectorType ? vectorType.getShape().size() : 0;
     // Verify that the map has the right number of inputs, outputs, and indices.
if (lhsMaskType && rhsMaskType) {
     if (lhsMaskType.getShape().size() != lhsType.getShape().size() ||
         rhsMaskType.getShape().size() != rhsType.getShape().size())
       return emitOpError("invalid vector mask rank");
   }
 
   // Verify supported combining kind.
   auto vectorType = resType.dyn_cast<VectorType>();
   auto elementType = vectorType ? vectorType.getElementType() : resType;
-  if (!isSupportedCombiningKind(kind(), elementType))
+  if (!isSupportedCombiningKind(getKind(), elementType))
     return emitOpError("unsupported contraction type");
 
   return success();
 }
 
 ArrayRef<StringRef> ContractionOp::getTraitAttrNames() {
   static constexpr StringRef names[3] = {::mlir::getIndexingMapsAttrName(),
                                          ::mlir::getIteratorTypesAttrName(),

 }
 
 void ContractionOp::getIterationBounds(
     SmallVectorImpl<int64_t> &iterationBounds) {
   auto lhsShape = getLhsType().getShape();
   auto resVectorType = getResultType().dyn_cast<VectorType>();
   SmallVector<AffineMap, 4> indexingMaps(getIndexingMaps());
   SmallVector<int64_t, 2> iterationShape;
-  for (const auto &it : llvm::enumerate(iterator_types())) {
+  for (const auto &it : llvm::enumerate(getIteratorTypes())) {
     // Search lhs/rhs map results for 'targetExpr'.
     auto targetExpr = getAffineDimExpr(it.index(), getContext());
     auto iteratorTypeName = it.value().cast<StringAttr>().getValue();
     if (iteratorTypeName == getReductionIteratorTypeName()) {
       // Get reduction dim size from lhs shape (same size in rhsShape).
       int64_t lhsDimIndex = getResultIndex(indexingMaps[0], targetExpr);
       assert(lhsDimIndex >= 0);
       iterationBounds.push_back(lhsShape[lhsDimIndex]);
       continue;
     }
     // Get parallel dimension size from result shape.
     int64_t resDimIndex = getResultIndex(indexingMaps[2], targetExpr);
     assert(resDimIndex >= 0);
     assert(resVectorType != nullptr);
     iterationBounds.push_back(resVectorType.getShape()[resDimIndex]);
   }
 }
 
 void ContractionOp::getIterationIndexMap(
     std::vector<DenseMap<int64_t, int64_t>> &iterationIndexMap) {
-  unsigned numMaps = indexing_maps().size();
+  unsigned numMaps = getIndexingMaps().size();
   iterationIndexMap.resize(numMaps);
-  for (const auto &it : llvm::enumerate(indexing_maps())) {
+  for (const auto &it : llvm::enumerate(getIndexingMaps())) {
     auto index = it.index();
     auto map = it.value();
     for (unsigned i = 0, e = map.getNumResults(); i < e; ++i) {
       auto dim = map.getResult(i).cast<AffineDimExpr>();
       iterationIndexMap[index][dim.getPosition()] = i;
     }
   }
 }
 
 std::vector<std::pair<int64_t, int64_t>> ContractionOp::getContractingDimMap() {
   SmallVector<AffineMap, 4> indexingMaps(getIndexingMaps());
-  return getDimMap(indexingMaps, iterator_types(),
+  return getDimMap(indexingMaps, getIteratorTypes(),
                    getReductionIteratorTypeName(), getContext());
 }
 
 std::vector<std::pair<int64_t, int64_t>> ContractionOp::getBatchDimMap() {
   SmallVector<AffineMap, 4> indexingMaps(getIndexingMaps());
-  return getDimMap(indexingMaps, iterator_types(),
+  return getDimMap(indexingMaps, getIteratorTypes(),
                    getParallelIteratorTypeName(), getContext());
 }
 
 Optional<SmallVector<int64_t, 4>> ContractionOp::getShapeForUnroll() {
   SmallVector<int64_t, 4> shape;
   getIterationBounds(shape);
   return shape;
 }
LogicalResult matchAndRewrite(AddOpType addOp,
     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())) {
+              contractionOp.getAcc().getDefiningOp())) {
         if (maybeZero.getValue() ==
-            rewriter.getZeroAttr(contractionOp.acc().getType())) {
+            rewriter.getZeroAttr(contractionOp.getAcc().getType())) {
           BlockAndValueMapping bvm;
-          bvm.map(contractionOp.acc(), otherOperand);
+          bvm.map(contractionOp.getAcc(), otherOperand);
           auto newContraction =
               cast<vector::ContractionOp>(rewriter.clone(*contractionOp, bvm));
           rewriter.replaceOp(addOp, newContraction.getResult());
           return newContraction;
         }
       }
       return vector::ContractionOp();
     };
void vector::ExtractElementOp::build(OpBuilder &builder, OperationState &result,
                                      Value source, Value position) {
   result.addOperands({source, position});
   result.addTypes(source.getType().cast<VectorType>().getElementType());
 }
 
 LogicalResult vector::ExtractElementOp::verify() {
   VectorType vectorType = getVectorType();
   if (vectorType.getRank() == 0) {
-    if (position())
+    if (getPosition())
       return emitOpError("expected position to be empty with 0-D vector");
     return success();
   }
   if (vectorType.getRank() != 1)
     return emitOpError("unexpected >1 vector rank");
-  if (!position())
+  if (!getPosition())
     return emitOpError("expected position for 1-D vector");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractOp
 //===----------------------------------------------------------------------===//
 

 }
 
 LogicalResult
 ExtractOp::inferReturnTypes(MLIRContext *, Optional<Location>,
                             ValueRange operands, DictionaryAttr attributes,
                             RegionRange,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
   ExtractOp::Adaptor op(operands, attributes);
-  auto vectorType = op.vector().getType().cast<VectorType>();
-  if (static_cast<int64_t>(op.position().size()) == vectorType.getRank()) {
+  auto vectorType = op.getVector().getType().cast<VectorType>();
+  if (static_cast<int64_t>(op.getPosition().size()) == vectorType.getRank()) {
     inferredReturnTypes.push_back(vectorType.getElementType());
   } else {
-    auto n = std::min<size_t>(op.position().size(), vectorType.getRank() - 1);
+    auto n =
+        std::min<size_t>(op.getPosition().size(), vectorType.getRank() - 1);
     inferredReturnTypes.push_back(VectorType::get(
         vectorType.getShape().drop_front(n), vectorType.getElementType()));
   }
   return success();
 }
 
 bool ExtractOp::isCompatibleReturnTypes(TypeRange l, TypeRange r) {
   // Allow extracting 1-element vectors instead of scalars.
   auto isCompatible = [](TypeRange l, TypeRange r) {
     auto vectorType = l.front().dyn_cast<VectorType>();
     return vectorType && vectorType.getShape().equals({1}) &&
            vectorType.getElementType() == r.front();
   };
   if (l.size() == 1 && r.size() == 1 &&
       (isCompatible(l, r) || isCompatible(r, l)))
     return true;
   return l == r;
 }
 
 LogicalResult vector::ExtractOp::verify() {
-  auto positionAttr = position().getValue();
+  auto positionAttr = getPosition().getValue();
   if (positionAttr.size() > static_cast<unsigned>(getVectorType().getRank()))
     return emitOpError(
         "expected position attribute of rank smaller than vector rank");
   for (const auto &en : llvm::enumerate(positionAttr)) {
     auto attr = en.value().dyn_cast<IntegerAttr>();
     if (!attr || attr.getInt() < 0 ||
         attr.getInt() >= getVectorType().getDimSize(en.index()))
       return emitOpError("expected position attribute #")
static SmallVector<IntType> extractVector(ArrayAttr arrayAttr) {
   return llvm::to_vector<4>(llvm::map_range(
       arrayAttr.getAsRange<IntegerAttr>(),
       [](IntegerAttr attr) { return static_cast<IntType>(attr.getInt()); }));
 }
 
 /// Fold the result of chains of ExtractOp in place by simply concatenating the
 /// positions.
 static LogicalResult foldExtractOpFromExtractChain(ExtractOp extractOp) {
-  if (!extractOp.vector().getDefiningOp<ExtractOp>())
+  if (!extractOp.getVector().getDefiningOp<ExtractOp>())
     return failure();
 
   SmallVector<int64_t, 4> globalPosition;
   ExtractOp currentOp = extractOp;
-  auto extrPos = extractVector<int64_t>(currentOp.position());
+  auto extrPos = extractVector<int64_t>(currentOp.getPosition());
   globalPosition.append(extrPos.rbegin(), extrPos.rend());
-  while (ExtractOp nextOp = currentOp.vector().getDefiningOp<ExtractOp>()) {
+  while (ExtractOp nextOp = currentOp.getVector().getDefiningOp<ExtractOp>()) {
     currentOp = nextOp;
-    auto extrPos = extractVector<int64_t>(currentOp.position());
+    auto extrPos = extractVector<int64_t>(currentOp.getPosition());
     globalPosition.append(extrPos.rbegin(), extrPos.rend());
   }
-  extractOp.setOperand(currentOp.vector());
+  extractOp.setOperand(currentOp.getVector());
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   std::reverse(globalPosition.begin(), globalPosition.end());
   extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                      b.getI64ArrayAttr(globalPosition));
   return success();
 }
 
private:
   SmallVector<int64_t> sentinels;
   SmallVector<int64_t> extractPosition;
 };
 } // namespace
 
 ExtractFromInsertTransposeChainState::ExtractFromInsertTransposeChainState(
     ExtractOp e)
     : extractOp(e), vectorRank(extractOp.getVectorType().getRank()),
-      extractedRank(extractOp.position().size()) {
+      extractedRank(extractOp.getPosition().size()) {
   assert(vectorRank >= extractedRank && "extracted pos overflow");
   sentinels.reserve(vectorRank - extractedRank);
   for (int64_t i = 0, e = vectorRank - extractedRank; i < e; ++i)
     sentinels.push_back(-(i + 1));
-  extractPosition = extractVector<int64_t>(extractOp.position());
+  extractPosition = extractVector<int64_t>(extractOp.getPosition());
   llvm::append_range(extractPosition, sentinels);
 }
 
 // Case 1. If we hit a transpose, just compose the map and iterate.
 // Invariant: insert + transpose do not change rank, we can always compose.
 LogicalResult ExtractFromInsertTransposeChainState::handleTransposeOp() {
   if (!nextTransposeOp)
     return failure();
-  auto permutation = extractVector<unsigned>(nextTransposeOp.transp());
+  auto permutation = extractVector<unsigned>(nextTransposeOp.getTransp());
   AffineMap m = inversePermutation(
       AffineMap::getPermutationMap(permutation, extractOp.getContext()));
   extractPosition = applyPermutationMap(m, makeArrayRef(extractPosition));
   return success();
 }
 
 // Case 2: the insert position matches extractPosition exactly, early return.
 LogicalResult
 ExtractFromInsertTransposeChainState::handleInsertOpWithMatchingPos(
     Value &res) {
-  auto insertedPos = extractVector<int64_t>(nextInsertOp.position());
+  auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition());
   if (makeArrayRef(insertedPos) !=
       llvm::makeArrayRef(extractPosition).take_front(extractedRank))
     return failure();
   // Case 2.a. early-exit fold.
-  res = nextInsertOp.source();
+  res = nextInsertOp.getSource();
   // Case 2.b. if internal transposition is present, canFold will be false.
   return success();
 }
 
 /// Case 3: if inserted position is a prefix of extractPosition,
 /// extract a portion of the source of the insertion.
 /// This method updates the internal state.
 LogicalResult
 ExtractFromInsertTransposeChainState::handleInsertOpWithPrefixPos(Value &res) {
-  auto insertedPos = extractVector<int64_t>(nextInsertOp.position());
+  auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition());
   if (!isContainedWithin(insertedPos, extractPosition))
     return failure();
   // Set leading dims to zero.
   std::fill_n(extractPosition.begin(), insertedPos.size(), 0);
   // Drop extra leading dims.
   extractPosition.erase(extractPosition.begin(),
                         extractPosition.begin() + insertedPos.size());
   extractedRank = extractPosition.size() - sentinels.size();
   // Case 3.a. early-exit fold (break and delegate to post-while path).
-  res = nextInsertOp.source();
+  res = nextInsertOp.getSource();
   // Case 3.b. if internal transposition is present, canFold will be false.
   return success();
 }
 
 /// Try to fold in place to extract(source, extractPosition) and return the
 /// folded result. Return null if folding is not possible (e.g. due to an
 /// internal tranposition in the result).
 Value ExtractFromInsertTransposeChainState::tryToFoldExtractOpInPlace(
     Value source) {
   // If we can't fold (either internal transposition, or nothing to fold), bail.
-  bool nothingToFold = (source == extractOp.vector());
+  bool nothingToFold = (source == extractOp.getVector());
   if (nothingToFold || !canFold())
     return Value();
   // Otherwise, fold by updating the op inplace and return its result.
   OpBuilder b(extractOp.getContext());
   extractOp->setAttr(
-      extractOp.positionAttrName(),
+      extractOp.getPositionAttrName(),
       b.getI64ArrayAttr(
           makeArrayRef(extractPosition).take_front(extractedRank)));
-  extractOp.vectorMutable().assign(source);
+  extractOp.getVectorMutable().assign(source);
   return extractOp.getResult();
 }
 
 /// Iterate over producing insert and transpose ops until we find a fold.
 Value ExtractFromInsertTransposeChainState::fold() {
-  Value valueToExtractFrom = extractOp.vector();
+  Value valueToExtractFrom = extractOp.getVector();
   updateStateForNextIteration(valueToExtractFrom);
   while (nextInsertOp || nextTransposeOp) {
     // Case 1. If we hit a transpose, just compose the map and iterate.
     // Invariant: insert + transpose do not change rank, we can always compose.
     if (succeeded(handleTransposeOp())) {
-      valueToExtractFrom = nextTransposeOp.vector();
+      valueToExtractFrom = nextTransposeOp.getVector();
       updateStateForNextIteration(valueToExtractFrom);
       continue;
     }
 
     Value result;
     // Case 2: the position match exactly.
     if (succeeded(handleInsertOpWithMatchingPos(result)))
       return result;
 
     // Case 3: if the inserted position is a prefix of extractPosition, we can
     // just extract a portion of the source of the insert.
     if (succeeded(handleInsertOpWithPrefixPos(result)))
       return tryToFoldExtractOpInPlace(result);
 
     // Case 4: extractPositionRef intersects insertedPosRef on non-sentinel
     // values. This is a more difficult case and we bail.
-    auto insertedPos = extractVector<int64_t>(nextInsertOp.position());
+    auto insertedPos = extractVector<int64_t>(nextInsertOp.getPosition());
     if (isContainedWithin(extractPosition, insertedPos) ||
         intersectsWhereNonNegative(extractPosition, insertedPos))
       return Value();
 
     // Case 5: No intersection, we forward the extract to insertOp.dest().
-    valueToExtractFrom = nextInsertOp.dest();
+    valueToExtractFrom = nextInsertOp.getDest();
     updateStateForNextIteration(valueToExtractFrom);
   }
   // If after all this we can fold, go for it.
   return tryToFoldExtractOpInPlace(valueToExtractFrom);
 }
 
 /// Fold extractOp with scalar result coming from BroadcastOp or SplatOp.
 static Value foldExtractFromBroadcast(ExtractOp extractOp) {
-  Operation *defOp = extractOp.vector().getDefiningOp();
+  Operation *defOp = extractOp.getVector().getDefiningOp();
   if (!defOp || !isa<vector::BroadcastOp, SplatOp>(defOp))
     return Value();
   Value source = defOp->getOperand(0);
   if (extractOp.getType() == source.getType())
     return source;
   auto getRank = [](Type type) {
     return type.isa<VectorType>() ? type.cast<VectorType>().getRank() : 0;
   };
   unsigned broadcastSrcRank = getRank(source.getType());
   unsigned extractResultRank = getRank(extractOp.getType());
   if (extractResultRank < broadcastSrcRank) {
-    auto extractPos = extractVector<int64_t>(extractOp.position());
+    auto extractPos = extractVector<int64_t>(extractOp.getPosition());
     unsigned rankDiff = broadcastSrcRank - extractResultRank;
     extractPos.erase(
         extractPos.begin(),
         std::next(extractPos.begin(), extractPos.size() - rankDiff));
     extractOp.setOperand(source);
     // OpBuilder is only used as a helper to build an I64ArrayAttr.
     OpBuilder b(extractOp.getContext());
     extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                        b.getI64ArrayAttr(extractPos));
     return extractOp.getResult();
   }
   return Value();
 }
 
 // Fold extractOp with source coming from ShapeCast op.
 static Value foldExtractFromShapeCast(ExtractOp extractOp) {
-  auto shapeCastOp = extractOp.vector().getDefiningOp<vector::ShapeCastOp>();
+  auto shapeCastOp = extractOp.getVector().getDefiningOp<vector::ShapeCastOp>();
   if (!shapeCastOp)
     return Value();
   // Get the nth dimension size starting from lowest dimension.
   auto getDimReverse = [](VectorType type, int64_t n) {
     return type.getShape().take_back(n + 1).front();
   };
   int64_t destinationRank =
       extractOp.getType().isa<VectorType>()
for (int64_t i = 0; i < destinationRank; i++) {
       // TODO: This case could be support in a canonicalization pattern.
       if (getDimReverse(shapeCastOp.getSourceVectorType(), i) !=
           getDimReverse(destinationType, i))
         return Value();
     }
   }
   // Extract the strides associated with the extract op vector source. Then use
   // this to calculate a linearized position for the extract.
-  auto extractedPos = extractVector<int64_t>(extractOp.position());
+  auto extractedPos = extractVector<int64_t>(extractOp.getPosition());
   std::reverse(extractedPos.begin(), extractedPos.end());
   SmallVector<int64_t, 4> strides;
   int64_t stride = 1;
   for (int64_t i = 0, e = extractedPos.size(); i < e; i++) {
     strides.push_back(stride);
     stride *= getDimReverse(extractOp.getVectorType(), i + destinationRank);
   }
 
stride *=
         getDimReverse(shapeCastOp.getSourceVectorType(), i + destinationRank);
   }
   std::reverse(newStrides.begin(), newStrides.end());
   SmallVector<int64_t, 4> newPosition = delinearize(newStrides, position);
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                      b.getI64ArrayAttr(newPosition));
-  extractOp.setOperand(shapeCastOp.source());
+  extractOp.setOperand(shapeCastOp.getSource());
   return extractOp.getResult();
 }
 
 /// Fold an ExtractOp from ExtractStridedSliceOp.
 static Value foldExtractFromExtractStrided(ExtractOp extractOp) {
   auto extractStridedSliceOp =
-      extractOp.vector().getDefiningOp<vector::ExtractStridedSliceOp>();
+      extractOp.getVector().getDefiningOp<vector::ExtractStridedSliceOp>();
   if (!extractStridedSliceOp)
     return Value();
   // Return if 'extractStridedSliceOp' has non-unit strides.
   if (extractStridedSliceOp.hasNonUnitStrides())
     return Value();
 
   // Trim offsets for dimensions fully extracted.
-  auto sliceOffsets = extractVector<int64_t>(extractStridedSliceOp.offsets());
+  auto sliceOffsets =
+      extractVector<int64_t>(extractStridedSliceOp.getOffsets());
   while (!sliceOffsets.empty()) {
     size_t lastOffset = sliceOffsets.size() - 1;
     if (sliceOffsets.back() != 0 ||
         extractStridedSliceOp.getType().getDimSize(lastOffset) !=
             extractStridedSliceOp.getVectorType().getDimSize(lastOffset))
       break;
     sliceOffsets.pop_back();
   }
   unsigned destinationRank = 0;
   if (auto vecType = extractOp.getType().dyn_cast<VectorType>())
     destinationRank = vecType.getRank();
   // The dimensions of the result need to be untouched by the
   // extractStridedSlice op.
   if (destinationRank >
       extractStridedSliceOp.getVectorType().getRank() - sliceOffsets.size())
     return Value();
-  auto extractedPos = extractVector<int64_t>(extractOp.position());
+  auto extractedPos = extractVector<int64_t>(extractOp.getPosition());
   assert(extractedPos.size() >= sliceOffsets.size());
   for (size_t i = 0, e = sliceOffsets.size(); i < e; i++)
     extractedPos[i] = extractedPos[i] + sliceOffsets[i];
-  extractOp.vectorMutable().assign(extractStridedSliceOp.vector());
+  extractOp.getVectorMutable().assign(extractStridedSliceOp.getVector());
   // OpBuilder is only used as a helper to build an I64ArrayAttr.
   OpBuilder b(extractOp.getContext());
   extractOp->setAttr(ExtractOp::getPositionAttrStrName(),
                      b.getI64ArrayAttr(extractedPos));
   return extractOp.getResult();
 }
 
 /// Fold extract_op fed from a chain of insertStridedSlice ops.
 static Value foldExtractStridedOpFromInsertChain(ExtractOp op) {
   int64_t destinationRank = op.getType().isa<VectorType>()
                                 ? op.getType().cast<VectorType>().getRank()
                                 : 0;
-  auto insertOp = op.vector().getDefiningOp<InsertStridedSliceOp>();
+  auto insertOp = op.getVector().getDefiningOp<InsertStridedSliceOp>();
   while (insertOp) {
     int64_t insertRankDiff = insertOp.getDestVectorType().getRank() -
                              insertOp.getSourceVectorType().getRank();
     if (destinationRank > insertOp.getSourceVectorType().getRank())
       return Value();
-    auto insertOffsets = extractVector<int64_t>(insertOp.offsets());
-    auto extractOffsets = extractVector<int64_t>(op.position());
+    auto insertOffsets = extractVector<int64_t>(insertOp.getOffsets());
+    auto extractOffsets = extractVector<int64_t>(op.getPosition());
 
-    if (llvm::any_of(insertOp.strides(), [](Attribute attr) {
+    if (llvm::any_of(insertOp.getStrides(), [](Attribute attr) {
           return attr.cast<IntegerAttr>().getInt() != 1;
         }))
       return Value();
     bool disjoint = false;
     SmallVector<int64_t, 4> offsetDiffs;
     for (unsigned dim = 0, e = extractOffsets.size(); dim < e; ++dim) {
       int64_t start = insertOffsets[dim];
       int64_t size =
if (!disjoint) {
       int64_t srcRankDiff =
           insertOp.getSourceVectorType().getRank() - destinationRank;
       for (int64_t i = 0; i < destinationRank; i++) {
         if (insertOp.getSourceVectorType().getDimSize(i + srcRankDiff) !=
             insertOp.getDestVectorType().getDimSize(i + srcRankDiff +
                                                     insertRankDiff))
           return Value();
       }
-      op.vectorMutable().assign(insertOp.source());
+      op.getVectorMutable().assign(insertOp.getSource());
       // OpBuilder is only used as a helper to build an I64ArrayAttr.
       OpBuilder b(op.getContext());
       op->setAttr(ExtractOp::getPositionAttrStrName(),
                   b.getI64ArrayAttr(offsetDiffs));
       return op.getResult();
     }
     // If the chunk extracted is disjoint from the chunk inserted, keep
     // looking in the insert chain.
-    insertOp = insertOp.dest().getDefiningOp<InsertStridedSliceOp>();
+    insertOp = insertOp.getDest().getDefiningOp<InsertStridedSliceOp>();
   }
   return Value();
 }
 
 OpFoldResult ExtractOp::fold(ArrayRef<Attribute>) {
-  if (position().empty())
-    return vector();
+  if (getPosition().empty())
+    return getVector();
   if (succeeded(foldExtractOpFromExtractChain(*this)))
     return getResult();
   if (auto res = ExtractFromInsertTransposeChainState(*this).fold())
     return res;
   if (auto res = foldExtractFromBroadcast(*this))
     return res;
   if (auto res = foldExtractFromShapeCast(*this))
     return res;
   if (auto val = foldExtractFromExtractStrided(*this))
     return val;
   if (auto val = foldExtractStridedOpFromInsertChain(*this))
     return val;
   return OpFoldResult();
 }
 
 namespace {
 
 // Pattern to rewrite a ExtractOp(Broadcast) -> Broadcast.
 class ExtractOpFromBroadcast final : public OpRewritePattern<ExtractOp> {
 public:
   using OpRewritePattern<ExtractOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractOp extractOp,
                                 PatternRewriter &rewriter) const override {
-    Operation *defOp = extractOp.vector().getDefiningOp();
+    Operation *defOp = extractOp.getVector().getDefiningOp();
     if (!defOp || !isa<vector::BroadcastOp, SplatOp>(defOp))
       return failure();
     Value source = defOp->getOperand(0);
     if (extractOp.getType() == source.getType())
       return failure();
     auto getRank = [](Type type) {
       return type.isa<VectorType>() ? type.cast<VectorType>().getRank() : 0;
     };

 class ExtractOpConstantFolder final : public OpRewritePattern<ExtractOp> {
 public:
   using OpRewritePattern<ExtractOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractOp extractOp,
                                 PatternRewriter &rewriter) const override {
     // Return if 'extractStridedSliceOp' operand is not defined by a
     // ConstantOp.
-    auto constantOp = extractOp.vector().getDefiningOp<arith::ConstantOp>();
+    auto constantOp = extractOp.getVector().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
     auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
     Attribute newAttr = dense.getSplatValue<Attribute>();
     if (auto vecDstType = extractOp.getType().dyn_cast<VectorType>())
       newAttr = DenseElementsAttr::get(vecDstType, newAttr);
LogicalResult ExtractMapOp::verify() {
   for (unsigned i = 0, e = getSourceVectorType().getRank(); i < e; ++i) {
     if (getSourceVectorType().getDimSize(i) % getResultType().getDimSize(i) !=
         0)
       return emitOpError("source vector dimensions must be a multiple of "
                          "destination vector dimensions");
     if (getSourceVectorType().getDimSize(i) != getResultType().getDimSize(i))
       numId++;
   }
-  if (numId != ids().size())
+  if (numId != getIds().size())
     return emitOpError("expected number of ids must match the number of "
                        "dimensions distributed");
   return success();
 }
 
 OpFoldResult ExtractMapOp::fold(ArrayRef<Attribute> operands) {
-  auto insert = vector().getDefiningOp<vector::InsertMapOp>();
-  if (insert == nullptr || getType() != insert.vector().getType() ||
-      ids() != insert.ids())
+  auto insert = getVector().getDefiningOp<vector::InsertMapOp>();
+  if (insert == nullptr || getType() != insert.getVector().getType() ||
+      getIds() != insert.getIds())
     return {};
-  return insert.vector();
+  return insert.getVector();
 }
 
 void ExtractMapOp::getMultiplicity(SmallVectorImpl<int64_t> &multiplicity) {
   assert(multiplicity.empty());
   for (unsigned i = 0, e = getSourceVectorType().getRank(); i < e; i++) {
     if (getSourceVectorType().getDimSize(i) != getResultType().getDimSize(i))
       multiplicity.push_back(getSourceVectorType().getDimSize(i) /
                              getResultType().getDimSize(i));
return emitOpError("dimension mismatch (")
            << mismatchingDims.first << " vs. " << mismatchingDims.second << ")";
   if (res == BroadcastableToResult::SourceTypeNotAVector)
     return emitOpError("source type is not a vector");
   llvm_unreachable("unexpected vector.broadcast op error");
 }
 
 OpFoldResult BroadcastOp::fold(ArrayRef<Attribute> operands) {
   if (getSourceType() == getVectorType())
-    return source();
+    return getSource();
   if (!operands[0])
     return {};
   auto vectorType = getVectorType();
   if (operands[0].getType().isIntOrIndexOrFloat())
     return DenseElementsAttr::get(vectorType, operands[0]);
   if (auto attr = operands[0].dyn_cast<SplatElementsAttr>())
     return DenseElementsAttr::get(vectorType, attr.getSplatValue<Attribute>());
   return {};
 }
 
 namespace {
 
 // Fold broadcast1(broadcast2(x)) into broadcast1(x).
 struct BroadcastFolder : public OpRewritePattern<BroadcastOp> {
   using OpRewritePattern<BroadcastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(BroadcastOp broadcastOp,
                                 PatternRewriter &rewriter) const override {
-    auto srcBroadcast = broadcastOp.source().getDefiningOp<BroadcastOp>();
+    auto srcBroadcast = broadcastOp.getSource().getDefiningOp<BroadcastOp>();
     if (!srcBroadcast)
       return failure();
     rewriter.replaceOpWithNewOp<BroadcastOp>(
-        broadcastOp, broadcastOp.getVectorType(), srcBroadcast.source());
+        broadcastOp, broadcastOp.getVectorType(), srcBroadcast.getSource());
     return success();
   }
 };
 } // namespace
 
 void BroadcastOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                               MLIRContext *context) {
   // BroadcastToShapeCast is not a default canonicalization, it is opt-in by
LogicalResult ShuffleOp::verify() {
   for (int64_t r = 1; r < v1Rank; ++r) {
     int64_t resDim = resultType.getDimSize(r);
     int64_t v1Dim = v1Type.getDimSize(r);
     int64_t v2Dim = v2Type.getDimSize(r);
     if (resDim != v1Dim || v1Dim != v2Dim)
       return emitOpError("dimension mismatch");
   }
   // Verify mask length.
-  auto maskAttr = mask().getValue();
+  auto maskAttr = getMask().getValue();
   int64_t maskLength = maskAttr.size();
   if (maskLength <= 0)
     return emitOpError("invalid mask length");
   if (maskLength != resultType.getDimSize(0))
     return emitOpError("mask length mismatch");
   // Verify all indices.
   int64_t indexSize = v1Type.getDimSize(0) + v2Type.getDimSize(0);
   for (const auto &en : llvm::enumerate(maskAttr)) {
     auto attr = en.value().dyn_cast<IntegerAttr>();
     if (!attr || attr.getInt() < 0 || attr.getInt() >= indexSize)
       return emitOpError("mask index #") << (en.index() + 1) << " out of range";
   }
   return success();
 }
 
 LogicalResult
 ShuffleOp::inferReturnTypes(MLIRContext *, Optional<Location>,
                             ValueRange operands, DictionaryAttr attributes,
                             RegionRange,
                             SmallVectorImpl<Type> &inferredReturnTypes) {
   ShuffleOp::Adaptor op(operands, attributes);
-  auto v1Type = op.v1().getType().cast<VectorType>();
+  auto v1Type = op.getV1().getType().cast<VectorType>();
   // Construct resulting type: leading dimension matches mask length,
   // all trailing dimensions match the operands.
   SmallVector<int64_t, 4> shape;
   shape.reserve(v1Type.getRank());
-  shape.push_back(std::max<size_t>(1, op.mask().size()));
+  shape.push_back(std::max<size_t>(1, op.getMask().size()));
   llvm::append_range(shape, v1Type.getShape().drop_front());
   inferredReturnTypes.push_back(
       VectorType::get(shape, v1Type.getElementType()));
   return success();
 }
 
 OpFoldResult vector::ShuffleOp::fold(ArrayRef<Attribute> operands) {
   Attribute lhs = operands.front(), rhs = operands.back();
   if (!lhs || !rhs)
     return {};
 
   auto lhsType = lhs.getType().cast<VectorType>();
   // Only support 1-D for now to avoid complicated n-D DenseElementsAttr
   // manipulation.
   if (lhsType.getRank() != 1)
     return {};
   int64_t lhsSize = lhsType.getDimSize(0);
 
   SmallVector<Attribute> results;
   auto lhsElements = lhs.cast<DenseElementsAttr>().getValues<Attribute>();
   auto rhsElements = rhs.cast<DenseElementsAttr>().getValues<Attribute>();
-  for (const auto &index : this->mask().getAsValueRange<IntegerAttr>()) {
+  for (const auto &index : this->getMask().getAsValueRange<IntegerAttr>()) {
     int64_t i = index.getZExtValue();
     if (i >= lhsSize) {
       results.push_back(rhsElements[i - lhsSize]);
     } else {
       results.push_back(lhsElements[i]);
     }
   }
 
   return DenseElementsAttr::get(getVectorType(), results);
 }
 
 //===----------------------------------------------------------------------===//
 // InsertElementOp
 //===----------------------------------------------------------------------===//
 
 void InsertElementOp::build(OpBuilder &builder, OperationState &result,
                             Value source, Value dest) {
   build(builder, result, source, dest, {});
 }
 
 LogicalResult InsertElementOp::verify() {
   auto dstVectorType = getDestVectorType();
   if (dstVectorType.getRank() == 0) {
-    if (position())
+    if (getPosition())
       return emitOpError("expected position to be empty with 0-D vector");
     return success();
   }
   if (dstVectorType.getRank() != 1)
     return emitOpError("unexpected >1 vector rank");
-  if (!position())
+  if (!getPosition())
     return emitOpError("expected position for 1-D vector");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // InsertOp
 //===----------------------------------------------------------------------===//
 
void InsertOp::build(OpBuilder &builder, OperationState &result, Value source,
   SmallVector<int64_t, 4> positionConstants =
       llvm::to_vector<4>(llvm::map_range(position, [](Value pos) {
         return pos.getDefiningOp<arith::ConstantIndexOp>().value();
       }));
   build(builder, result, source, dest, positionConstants);
 }
 
 LogicalResult InsertOp::verify() {
-  auto positionAttr = position().getValue();
+  auto positionAttr = getPosition().getValue();
   auto destVectorType = getDestVectorType();
   if (positionAttr.size() > static_cast<unsigned>(destVectorType.getRank()))
     return emitOpError(
         "expected position attribute of rank smaller than dest vector rank");
   auto srcVectorType = getSourceType().dyn_cast<VectorType>();
   if (srcVectorType &&
       (static_cast<unsigned>(srcVectorType.getRank()) + positionAttr.size() !=
        static_cast<unsigned>(destVectorType.getRank())))
public:
 
   LogicalResult matchAndRewrite(InsertOp insertOp,
                                 PatternRewriter &rewriter) const override {
     auto srcVecType = insertOp.getSourceType().dyn_cast<VectorType>();
     if (!srcVecType || insertOp.getDestVectorType().getNumElements() !=
                            srcVecType.getNumElements())
       return failure();
     rewriter.replaceOpWithNewOp<BroadcastOp>(
-        insertOp, insertOp.getDestVectorType(), insertOp.source());
+        insertOp, insertOp.getDestVectorType(), insertOp.getSource());
     return success();
   }
 };
 
 } // namespace
 
 void InsertOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                            MLIRContext *context) {
   results.add<InsertToBroadcast, BroadcastFolder>(context);
 }
 
 // Eliminates insert operations that produce values identical to their source
 // value. This happens when the source and destination vectors have identical
 // sizes.
 OpFoldResult vector::InsertOp::fold(ArrayRef<Attribute> operands) {
-  if (position().empty())
-    return source();
+  if (getPosition().empty())
+    return getSource();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // InsertMapOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult InsertMapOp::verify() {
   if (getSourceVectorType().getRank() != getResultType().getRank())
     return emitOpError("expected source and destination vectors of same rank");
   unsigned numId = 0;
   for (unsigned i = 0, e = getResultType().getRank(); i < e; i++) {
     if (getResultType().getDimSize(i) % getSourceVectorType().getDimSize(i) !=
         0)
       return emitOpError(
           "destination vector size must be a multiple of source vector size");
     if (getResultType().getDimSize(i) != getSourceVectorType().getDimSize(i))
       numId++;
   }
-  if (numId != ids().size())
+  if (numId != getIds().size())
     return emitOpError("expected number of ids must match the number of "
                        "dimensions distributed");
   return success();
 }
 
 AffineMap InsertMapOp::map() { return calculateImplicitMap(*this); }
 
 //===----------------------------------------------------------------------===//
auto attrs = llvm::map_range(values, [context](int64_t v) -> Attribute {
     return IntegerAttr::get(IntegerType::get(context, 64), APInt(64, v));
   });
   return ArrayAttr::get(context, llvm::to_vector<8>(attrs));
 }
 
 LogicalResult InsertStridedSliceOp::verify() {
   auto sourceVectorType = getSourceVectorType();
   auto destVectorType = getDestVectorType();
-  auto offsets = offsetsAttr();
-  auto strides = stridesAttr();
+  auto offsets = getOffsetsAttr();
+  auto strides = getStridesAttr();
   if (offsets.size() != static_cast<unsigned>(destVectorType.getRank()))
     return emitOpError(
         "expected offsets of same size as destination vector rank");
   if (strides.size() != static_cast<unsigned>(sourceVectorType.getRank()))
     return emitOpError("expected strides of same size as source vector rank");
   if (sourceVectorType.getRank() > destVectorType.getRank())
     return emitOpError(
         "expected source rank to be smaller than destination rank");
if (failed(isIntegerArrayAttrConfinedToShape(*this, offsets, destShape,
           /*halfOpen=*/false, /*min=*/1)))
     return failure();
 
   return success();
 }
 
 OpFoldResult InsertStridedSliceOp::fold(ArrayRef<Attribute> operands) {
   if (getSourceVectorType() == getDestVectorType())
-    return source();
+    return getSource();
   return {};
 }
 
 //===----------------------------------------------------------------------===//
 // OuterProductOp
 //===----------------------------------------------------------------------===//
 
 /// Build an op without mask, use the type of `acc` as the return type.
 void OuterProductOp::build(OpBuilder &builder, OperationState &result,
                            Value lhs, Value rhs, Value acc) {
   result.addOperands({lhs, rhs, acc});
   result.addTypes(acc.getType());
 }
 
 void OuterProductOp::print(OpAsmPrinter &p) {
-  p << " " << lhs() << ", " << rhs();
-  if (!acc().empty()) {
-    p << ", " << acc();
+  p << " " << getLhs() << ", " << getRhs();
+  if (!getAcc().empty()) {
+    p << ", " << getAcc();
     p.printOptionalAttrDict((*this)->getAttrs());
   }
-  p << " : " << lhs().getType() << ", " << rhs().getType();
+  p << " : " << getLhs().getType() << ", " << getRhs().getType();
 }
 
 ParseResult OuterProductOp::parse(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::UnresolvedOperand, 3> operandsInfo;
   Type tLHS, tRHS;
   if (parser.parseOperandList(operandsInfo) ||
       parser.parseOptionalAttrDict(result.attributes) ||
       parser.parseColonType(tLHS) || parser.parseComma() ||
if (vRHS) {
     if (vLHS.getDimSize(0) != vRES.getDimSize(0))
       return emitOpError("expected #1 operand dim to match result dim #1");
   }
 
   if (vACC && vACC != vRES)
     return emitOpError("expected operand #3 of same type as result type");
 
   // Verify supported combining kind.
-  if (!isSupportedCombiningKind(kind(), vRES.getElementType()))
+  if (!isSupportedCombiningKind(getKind(), vRES.getElementType()))
     return emitOpError("unsupported outerproduct type");
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // ReshapeOp
 //===----------------------------------------------------------------------===//
if (fixedVectorSizes[i] != outputVectorType.getShape()[index])
              << i;
   }
 
   // If all shape operands are produced by constant ops, verify that product
   // of dimensions for input/output shape match.
   auto isDefByConstant = [](Value operand) {
     return isa_and_nonnull<arith::ConstantIndexOp>(operand.getDefiningOp());
   };
-  if (llvm::all_of(input_shape(), isDefByConstant) &&
-      llvm::all_of(output_shape(), isDefByConstant)) {
+  if (llvm::all_of(getInputShape(), isDefByConstant) &&
+      llvm::all_of(getOutputShape(), isDefByConstant)) {
     int64_t numInputElements = 1;
-    for (auto operand : input_shape())
+    for (auto operand : getInputShape())
       numInputElements *=
           cast<arith::ConstantIndexOp>(operand.getDefiningOp()).value();
     int64_t numOutputElements = 1;
-    for (auto operand : output_shape())
+    for (auto operand : getOutputShape())
       numOutputElements *=
           cast<arith::ConstantIndexOp>(operand.getDefiningOp()).value();
     if (numInputElements != numOutputElements)
       return emitError("product of input and output shape sizes must match");
   }
   return success();
 }
 
 void ReshapeOp::getFixedVectorSizes(SmallVectorImpl<int64_t> &results) {
-  populateFromInt64AttrArray(fixed_vector_sizes(), results);
+  populateFromInt64AttrArray(getFixedVectorSizes(), results);
 }
 
 //===----------------------------------------------------------------------===//
 // ExtractStridedSliceOp
 //===----------------------------------------------------------------------===//
 
 // Inference works as follows:
 //   1. Add 'sizes' from prefix of dims in 'offsets'.
result.addTypes(
                                     offsetsAttr, sizesAttr, stridesAttr));
   result.addAttribute(getOffsetsAttrStrName(), offsetsAttr);
   result.addAttribute(getSizesAttrStrName(), sizesAttr);
   result.addAttribute(getStridesAttrStrName(), stridesAttr);
 }
 
 LogicalResult ExtractStridedSliceOp::verify() {
   auto type = getVectorType();
-  auto offsets = offsetsAttr();
-  auto sizes = sizesAttr();
-  auto strides = stridesAttr();
+  auto offsets = getOffsetsAttr();
+  auto sizes = getSizesAttr();
+  auto strides = getStridesAttr();
   if (offsets.size() != sizes.size() || offsets.size() != strides.size())
     return emitOpError("expected offsets, sizes and strides attributes of same size");
 
   auto shape = type.getShape();
   auto offName = getOffsetsAttrName();
   auto sizesName = getSizesAttrName();
   auto stridesName = getStridesAttrName();
   if (failed(isIntegerArrayAttrSmallerThanShape(*this, offsets, shape, offName)) ||

 // to use the source of the InsertStrided ops if we can detect that the
 // extracted vector is a subset of one of the vector inserted.
 static LogicalResult
 foldExtractStridedOpFromInsertChain(ExtractStridedSliceOp op) {
   // Helper to extract integer out of ArrayAttr.
   auto getElement = [](ArrayAttr array, int idx) {
     return array[idx].cast<IntegerAttr>().getInt();
   };
-  ArrayAttr extractOffsets = op.offsets();
-  ArrayAttr extractStrides = op.strides();
-  ArrayAttr extractSizes = op.sizes();
-  auto insertOp = op.vector().getDefiningOp<InsertStridedSliceOp>();
+  ArrayAttr extractOffsets = op.getOffsets();
+  ArrayAttr extractStrides = op.getStrides();
+  ArrayAttr extractSizes = op.getSizes();
+  auto insertOp = op.getVector().getDefiningOp<InsertStridedSliceOp>();
   while (insertOp) {
     if (op.getVectorType().getRank() !=
         insertOp.getSourceVectorType().getRank())
       return failure();
-    ArrayAttr insertOffsets = insertOp.offsets();
-    ArrayAttr insertStrides = insertOp.strides();
+    ArrayAttr insertOffsets = insertOp.getOffsets();
+    ArrayAttr insertStrides = insertOp.getStrides();
     // If the rank of extract is greater than the rank of insert, we are likely
     // extracting a partial chunk of the vector inserted.
     if (extractOffsets.size() > insertOffsets.size())
       return failure();
     bool patialoverlap = false;
     bool disjoint = false;
     SmallVector<int64_t, 4> offsetDiffs;
     for (unsigned dim = 0, e = extractOffsets.size(); dim < e; ++dim) {
for (unsigned dim = 0, e = extractOffsets.size(); dim < e; ++dim) {
         offsetDiffs.push_back(offset - start);
         continue;
       }
       disjoint = true;
       break;
     }
     // The extract element chunk is a subset of the insert element.
     if (!disjoint && !patialoverlap) {
-      op.setOperand(insertOp.source());
+      op.setOperand(insertOp.getSource());
       // OpBuilder is only used as a helper to build an I64ArrayAttr.
       OpBuilder b(op.getContext());
       op->setAttr(ExtractStridedSliceOp::getOffsetsAttrStrName(),
                   b.getI64ArrayAttr(offsetDiffs));
       return success();
     }
     // If the chunk extracted is disjoint from the chunk inserted, keep looking
     // in the insert chain.
     if (disjoint)
-      insertOp = insertOp.dest().getDefiningOp<InsertStridedSliceOp>();
+      insertOp = insertOp.getDest().getDefiningOp<InsertStridedSliceOp>();
     else {
       // The extracted vector partially overlap the inserted vector, we cannot
       // fold.
       return failure();
     }
   }
   return failure();
 }
 
 OpFoldResult ExtractStridedSliceOp::fold(ArrayRef<Attribute> operands) {
   if (getVectorType() == getResult().getType())
-    return vector();
+    return getVector();
   if (succeeded(foldExtractStridedOpFromInsertChain(*this)))
     return getResult();
   return {};
 }
 
 void ExtractStridedSliceOp::getOffsets(SmallVectorImpl<int64_t> &results) {
-  populateFromInt64AttrArray(offsets(), results);
+  populateFromInt64AttrArray(getOffsets(), results);
 }
 
 namespace {
 
 // Pattern to rewrite an ExtractStridedSliceOp(ConstantMaskOp) to
 // ConstantMaskOp.
 class StridedSliceConstantMaskFolder final
     : public OpRewritePattern<ExtractStridedSliceOp> {
 public:
   using OpRewritePattern<ExtractStridedSliceOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractStridedSliceOp extractStridedSliceOp,
                                 PatternRewriter &rewriter) const override {
     // Return if 'extractStridedSliceOp' operand is not defined by a
     // ConstantMaskOp.
-    auto *defOp = extractStridedSliceOp.vector().getDefiningOp();
+    auto *defOp = extractStridedSliceOp.getVector().getDefiningOp();
     auto constantMaskOp = dyn_cast_or_null<ConstantMaskOp>(defOp);
     if (!constantMaskOp)
       return failure();
     // Return if 'extractStridedSliceOp' has non-unit strides.
     if (extractStridedSliceOp.hasNonUnitStrides())
       return failure();
     // Gather constant mask dimension sizes.
     SmallVector<int64_t, 4> maskDimSizes;
-    populateFromInt64AttrArray(constantMaskOp.mask_dim_sizes(), maskDimSizes);
+    populateFromInt64AttrArray(constantMaskOp.getMaskDimSizes(), maskDimSizes);
     // Gather strided slice offsets and sizes.
     SmallVector<int64_t, 4> sliceOffsets;
-    populateFromInt64AttrArray(extractStridedSliceOp.offsets(), sliceOffsets);
+    populateFromInt64AttrArray(extractStridedSliceOp.getOffsets(),
+                               sliceOffsets);
     SmallVector<int64_t, 4> sliceSizes;
-    populateFromInt64AttrArray(extractStridedSliceOp.sizes(), sliceSizes);
+    populateFromInt64AttrArray(extractStridedSliceOp.getSizes(), sliceSizes);
 
     // Compute slice of vector mask region.
     SmallVector<int64_t, 4> sliceMaskDimSizes;
     assert(sliceOffsets.size() == maskDimSizes.size());
     for (auto it : llvm::zip(maskDimSizes, sliceOffsets, sliceSizes)) {
       int64_t maskDimSize = std::get<0>(it);
       int64_t sliceOffset = std::get<1>(it);
       int64_t sliceSize = std::get<2>(it);

 public:
   using OpRewritePattern<ExtractStridedSliceOp>::OpRewritePattern;
 
   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>();
+        extractStridedSliceOp.getVector().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
     auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
     auto newAttr = DenseElementsAttr::get(extractStridedSliceOp.getType(),
                                           dense.getSplatValue<Attribute>());
     rewriter.replaceOpWithNewOp<arith::ConstantOp>(extractStridedSliceOp,
                                                    newAttr);
     return success();
   }
 };
 
 // Pattern to rewrite an ExtractStridedSliceOp(BroadcastOp) to
 // BroadcastOp(ExtractStrideSliceOp).
 class StridedSliceBroadcast final
     : public OpRewritePattern<ExtractStridedSliceOp> {
 public:
   using OpRewritePattern<ExtractStridedSliceOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
-    auto broadcast = op.vector().getDefiningOp<BroadcastOp>();
+    auto broadcast = op.getVector().getDefiningOp<BroadcastOp>();
     if (!broadcast)
       return failure();
-    auto srcVecType = broadcast.source().getType().dyn_cast<VectorType>();
+    auto srcVecType = broadcast.getSource().getType().dyn_cast<VectorType>();
     unsigned srcRrank = srcVecType ? srcVecType.getRank() : 0;
     auto dstVecType = op.getType().cast<VectorType>();
     unsigned dstRank = dstVecType.getRank();
     unsigned rankDiff = dstRank - srcRrank;
     // Check if the most inner dimensions of the source of the broadcast are the
     // same as the destination of the extract. If this is the case we can just
     // use a broadcast as the original dimensions are untouched.
     bool lowerDimMatch = true;
     for (unsigned i = 0; i < srcRrank; i++) {
       if (srcVecType.getDimSize(i) != dstVecType.getDimSize(i + rankDiff)) {
         lowerDimMatch = false;
         break;
       }
     }
-    Value source = broadcast.source();
+    Value source = broadcast.getSource();
     if (!lowerDimMatch) {
       // The inner dimensions don't match, it means we need to extract from the
       // source of the orignal broadcast and then broadcast the extracted value.
       source = rewriter.create<ExtractStridedSliceOp>(
           op->getLoc(), source,
-          getI64SubArray(op.offsets(), /* dropFront=*/rankDiff),
-          getI64SubArray(op.sizes(), /* dropFront=*/rankDiff),
-          getI64SubArray(op.strides(), /* dropFront=*/rankDiff));
+          getI64SubArray(op.getOffsets(), /* dropFront=*/rankDiff),
+          getI64SubArray(op.getSizes(), /* dropFront=*/rankDiff),
+          getI64SubArray(op.getStrides(), /* dropFront=*/rankDiff));
     }
     rewriter.replaceOpWithNewOp<BroadcastOp>(op, op.getType(), source);
     return success();
   }
 };
 
 /// Pattern to rewrite an ExtractStridedSliceOp(SplatOp) to SplatOp.
 class StridedSliceSplat final : public OpRewritePattern<ExtractStridedSliceOp> {
 public:
   using OpRewritePattern<ExtractStridedSliceOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
-    auto splat = op.vector().getDefiningOp<SplatOp>();
+    auto splat = op.getVector().getDefiningOp<SplatOp>();
     if (!splat)
       return failure();
-    rewriter.replaceOpWithNewOp<SplatOp>(op, op.getType(), splat.input());
+    rewriter.replaceOpWithNewOp<SplatOp>(op, op.getType(), splat.getInput());
     return success();
   }
 };
 
 } // namespace
 
 void ExtractStridedSliceOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
if (auto inBounds = op.in_bounds()) {
     }
   }
   if (elideInBounds)
     elidedAttrs.push_back(op.getInBoundsAttrStrName());
   p.printOptionalAttrDict(op->getAttrs(), elidedAttrs);
 }
 
 void TransferReadOp::print(OpAsmPrinter &p) {
-  p << " " << source() << "[" << indices() << "], " << padding();
-  if (mask())
-    p << ", " << mask();
+  p << " " << getSource() << "[" << getIndices() << "], " << getPadding();
+  if (getMask())
+    p << ", " << getMask();
   printTransferAttrs(p, *this);
   p << " : " << getShapedType() << ", " << getVectorType();
 }
 
 ParseResult TransferReadOp::parse(OpAsmParser &parser, OperationState &result) {
   auto &builder = parser.getBuilder();
   SMLoc typesLoc;
   OpAsmParser::UnresolvedOperand sourceInfo;
ParseResult TransferReadOp::parse(OpAsmParser &parser, OperationState &result) {
   return parser.addTypeToList(vectorType, result.types);
 }
 
 LogicalResult TransferReadOp::verify() {
   // Consistency of elemental types in source and vector.
   ShapedType shapedType = getShapedType();
   VectorType vectorType = getVectorType();
   VectorType maskType = getMaskType();
-  auto paddingType = padding().getType();
-  auto permutationMap = permutation_map();
+  auto paddingType = getPadding().getType();
+  auto permutationMap = getPermutationMap();
   auto sourceElementType = shapedType.getElementType();
 
-  if (static_cast<int64_t>(indices().size()) != shapedType.getRank())
+  if (static_cast<int64_t>(getIndices().size()) != shapedType.getRank())
     return emitOpError("requires ") << shapedType.getRank() << " indices";
 
   if (failed(verifyTransferOp(cast<VectorTransferOpInterface>(getOperation()),
                               shapedType, vectorType, maskType, permutationMap,
-                              in_bounds() ? *in_bounds() : ArrayAttr())))
+                              getInBounds() ? *getInBounds() : ArrayAttr())))
     return failure();
 
   if (auto sourceVectorElementType = sourceElementType.dyn_cast<VectorType>()) {
     // Source has vector element type.
     // Check that 'sourceVectorElementType' and 'paddingType' types match.
     if (sourceVectorElementType != paddingType)
       return emitOpError(
           "requires source element type and padding type to match.");

 }
 
 template <typename TransferOp>
 static bool isInBounds(TransferOp op, int64_t resultIdx, int64_t indicesIdx) {
   // TODO: support more aggressive createOrFold on:
   // `op.indices()[indicesIdx] + vectorType < dim(op.source(), indicesIdx)`
   if (op.getShapedType().isDynamicDim(indicesIdx))
     return false;
-  Value index = op.indices()[indicesIdx];
+  Value index = op.getIndices()[indicesIdx];
   auto cstOp = index.getDefiningOp<arith::ConstantIndexOp>();
   if (!cstOp)
     return false;
 
   int64_t sourceSize = op.getShapedType().getDimSize(indicesIdx);
   int64_t vectorSize = op.getVectorType().getDimSize(resultIdx);
 
   return cstOp.value() + vectorSize <= sourceSize;
 }
 
 template <typename TransferOp>
 static LogicalResult foldTransferInBoundsAttribute(TransferOp op) {
   // TODO: support 0-d corner case.
   // TODO: Be less conservative.
   if (op.getTransferRank() == 0)
     return failure();
-  AffineMap permutationMap = op.permutation_map();
+  AffineMap permutationMap = op.getPermutationMap();
   bool changed = false;
   SmallVector<bool, 4> newInBounds;
   newInBounds.reserve(op.getTransferRank());
   for (unsigned i = 0; i < op.getTransferRank(); ++i) {
     // Already marked as in-bounds, nothing to see here.
     if (op.isDimInBounds(i)) {
       newInBounds.push_back(true);
       continue;

 ///  ```
 ///  -> Folds into
 ///  ```
 ///  %v0
 ///  ```
 static Value foldRAW(TransferReadOp readOp) {
   if (!readOp.getShapedType().isa<RankedTensorType>())
     return {};
-  auto defWrite = readOp.source().getDefiningOp<vector::TransferWriteOp>();
+  auto defWrite = readOp.getSource().getDefiningOp<vector::TransferWriteOp>();
   while (defWrite) {
     if (checkSameValueRAW(defWrite, readOp))
-      return defWrite.vector();
+      return defWrite.getVector();
     if (!isDisjointTransferIndices(
             cast<VectorTransferOpInterface>(defWrite.getOperation()),
             cast<VectorTransferOpInterface>(readOp.getOperation())))
       break;
-    defWrite = defWrite.source().getDefiningOp<vector::TransferWriteOp>();
+    defWrite = defWrite.getSource().getDefiningOp<vector::TransferWriteOp>();
   }
   return {};
 }
 
 OpFoldResult TransferReadOp::fold(ArrayRef<Attribute>) {
   if (Value vec = foldRAW(*this))
     return vec;
   /// transfer_read(memrefcast) -> transfer_read

 Optional<SmallVector<int64_t, 4>> TransferReadOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getVectorType().getShape());
 }
 
 void TransferReadOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   if (getShapedType().isa<MemRefType>())
-    effects.emplace_back(MemoryEffects::Read::get(), source(),
+    effects.emplace_back(MemoryEffects::Read::get(), getSource(),
                          SideEffects::DefaultResource::get());
 }
 
 namespace {
 /// Fold transfer_reads of a tensor.extract_slice op. E.g.:
 ///
 /// ```
 /// %0 = tensor.extract_slice %t[%a, %b] [%c, %d] [1, 1]
public:
 
   LogicalResult matchAndRewrite(TransferReadOp xferOp,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (xferOp.getTransferRank() == 0)
       return failure();
     if (xferOp.hasOutOfBoundsDim())
       return failure();
-    if (!xferOp.permutation_map().isIdentity())
+    if (!xferOp.getPermutationMap().isIdentity())
       return failure();
-    if (xferOp.mask())
+    if (xferOp.getMask())
       return failure();
-    auto extractOp = xferOp.source().getDefiningOp<tensor::ExtractSliceOp>();
+    auto extractOp = xferOp.getSource().getDefiningOp<tensor::ExtractSliceOp>();
     if (!extractOp)
       return failure();
     if (!extractOp.hasUnitStride())
       return failure();
 
     // Bail on illegal rank-reduction: we need to check that the rank-reduced
     // dims are exactly the leading dims. I.e. the following is illegal:
     // ```
LogicalResult matchAndRewrite(TransferReadOp xferOp,
     SmallVector<Value> newIndices;
     // In case this is a rank-reducing ExtractSliceOp, copy rank-reduced
     // indices first.
     for (int64_t i = 0; i < rankReduced; ++i) {
       OpFoldResult offset = extractOp.getMixedOffsets()[i];
       newIndices.push_back(getValueOrCreateConstantIndexOp(
           rewriter, extractOp.getLoc(), offset));
     }
-    for (const auto &it : llvm::enumerate(xferOp.indices())) {
+    for (const auto &it : llvm::enumerate(xferOp.getIndices())) {
       OpFoldResult offset =
           extractOp.getMixedOffsets()[it.index() + rankReduced];
       newIndices.push_back(rewriter.create<arith::AddIOp>(
           xferOp->getLoc(), it.value(),
           getValueOrCreateConstantIndexOp(rewriter, extractOp.getLoc(),
                                           offset)));
     }
     SmallVector<bool> inBounds(xferOp.getTransferRank(), true);
     rewriter.replaceOpWithNewOp<TransferReadOp>(
         xferOp, xferOp.getVectorType(), extractOp.source(), newIndices,
-        xferOp.padding(), ArrayRef<bool>{inBounds});
+        xferOp.getPadding(), ArrayRef<bool>{inBounds});
 
     return success();
   }
 };
 } // namespace
 
 void TransferReadOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                  MLIRContext *context) {
result.addAttribute(
       TransferWriteOp::getOperandSegmentSizeAttr(),
       builder.getI32VectorAttr({1, 1, static_cast<int32_t>(indexInfo.size()),
                                 static_cast<int32_t>(hasMask.succeeded())}));
   return failure(shapedType.isa<RankedTensorType>() &&
                  parser.addTypeToList(shapedType, result.types));
 }
 
 void TransferWriteOp::print(OpAsmPrinter &p) {
-  p << " " << vector() << ", " << source() << "[" << indices() << "]";
-  if (mask())
-    p << ", " << mask();
+  p << " " << getVector() << ", " << getSource() << "[" << getIndices() << "]";
+  if (getMask())
+    p << ", " << getMask();
   printTransferAttrs(p, *this);
   p << " : " << getVectorType() << ", " << getShapedType();
 }
 
 LogicalResult TransferWriteOp::verify() {
   // Consistency of elemental types in shape and vector.
   ShapedType shapedType = getShapedType();
   VectorType vectorType = getVectorType();
   VectorType maskType = getMaskType();
-  auto permutationMap = permutation_map();
+  auto permutationMap = getPermutationMap();
 
-  if (llvm::size(indices()) != shapedType.getRank())
+  if (llvm::size(getIndices()) != shapedType.getRank())
     return emitOpError("requires ") << shapedType.getRank() << " indices";
 
   // We do not allow broadcast dimensions on TransferWriteOps for the moment,
   // as the semantics is unclear. This can be revisited later if necessary.
   if (hasBroadcastDim())
     return emitOpError("should not have broadcast dimensions");
 
   if (failed(verifyTransferOp(cast<VectorTransferOpInterface>(getOperation()),
                               shapedType, vectorType, maskType, permutationMap,
-                              in_bounds() ? *in_bounds() : ArrayAttr())))
+                              getInBounds() ? *getInBounds() : ArrayAttr())))
     return failure();
 
   return verifyPermutationMap(permutationMap,
                               [&](Twine t) { return emitOpError(t); });
 }
 
 /// Fold:
 /// ```

 /// The producer of t1 may or may not be DCE'd depending on whether it is a
 /// block argument or has side effects.
 static LogicalResult foldReadInitWrite(TransferWriteOp write,
                                        ArrayRef<Attribute>,
                                        SmallVectorImpl<OpFoldResult> &results) {
   // TODO: support 0-d corner case.
   if (write.getTransferRank() == 0)
     return failure();
-  auto rankedTensorType = write.source().getType().dyn_cast<RankedTensorType>();
+  auto rankedTensorType =
+      write.getSource().getType().dyn_cast<RankedTensorType>();
   // If not operating on tensors, bail.
   if (!rankedTensorType)
     return failure();
   // If no read, bail.
-  auto read = write.vector().getDefiningOp<vector::TransferReadOp>();
+  auto read = write.getVector().getDefiningOp<vector::TransferReadOp>();
   if (!read)
     return failure();
   // TODO: support 0-d corner case.
   if (read.getTransferRank() == 0)
     return failure();
   // For now, only accept minor identity. Future: composition is minor identity.
-  if (!read.permutation_map().isMinorIdentity() ||
-      !write.permutation_map().isMinorIdentity())
+  if (!read.getPermutationMap().isMinorIdentity() ||
+      !write.getPermutationMap().isMinorIdentity())
     return failure();
   // Bail on mismatching ranks.
   if (read.getTransferRank() != write.getTransferRank())
     return failure();
   // Bail on potential out-of-bounds accesses.
   if (read.hasOutOfBoundsDim() || write.hasOutOfBoundsDim())
     return failure();
   // Tensor types must be the same.
-  if (read.source().getType() != rankedTensorType)
+  if (read.getSource().getType() != rankedTensorType)
     return failure();
   // Vector types must be the same.
   if (read.getVectorType() != write.getVectorType())
     return failure();
   // Vector and Tensor shapes must match.
   if (read.getVectorType().getShape() != rankedTensorType.getShape())
     return failure();
   // If any index is nonzero.
   auto isNotConstantZero = [](Value v) {
     auto cstOp = v.getDefiningOp<arith::ConstantIndexOp>();
     return !cstOp || cstOp.value() != 0;
   };
-  if (llvm::any_of(read.indices(), isNotConstantZero) ||
-      llvm::any_of(write.indices(), isNotConstantZero))
+  if (llvm::any_of(read.getIndices(), isNotConstantZero) ||
+      llvm::any_of(write.getIndices(), isNotConstantZero))
     return failure();
   // Success.
-  results.push_back(read.source());
+  results.push_back(read.getSource());
   return success();
 }
 
 static bool checkSameValueWAR(vector::TransferReadOp read,
                               vector::TransferWriteOp write) {
-  return read.source() == write.source() && read.indices() == write.indices() &&
-         read.permutation_map() == write.permutation_map() &&
-         read.getVectorType() == write.getVectorType() && !read.mask() &&
-         !write.mask();
+  return read.getSource() == write.getSource() &&
+         read.getIndices() == write.getIndices() &&
+         read.getPermutationMap() == write.getPermutationMap() &&
+         read.getVectorType() == write.getVectorType() && !read.getMask() &&
+         !write.getMask();
 }
 /// Fold transfer_write write after read:
 /// ```
 ///    %t0 = ...
 ///    %v = vector.transfer_read %t0[%c0...] :
 ///      tensor<static_sizesxf32>, vector<static_sizesxf32>
 ///    %t1 = vector.transfer_write %v, %t0[%c0...] :
 ///      vector<static_sizesxf32>, tensor<static_sizesxf32>
 /// ```
 ///
 /// into:
 ///
 /// ```
 ///    %t0
 /// ```
 static LogicalResult foldWAR(TransferWriteOp write,
                              SmallVectorImpl<OpFoldResult> &results) {
-  if (!write.source().getType().isa<RankedTensorType>())
+  if (!write.getSource().getType().isa<RankedTensorType>())
     return failure();
-  auto read = write.vector().getDefiningOp<vector::TransferReadOp>();
+  auto read = write.getVector().getDefiningOp<vector::TransferReadOp>();
   if (!read)
     return failure();
 
   if (!checkSameValueWAR(read, write))
     return failure();
-  results.push_back(read.source());
+  results.push_back(read.getSource());
   return success();
 }
 
 LogicalResult TransferWriteOp::fold(ArrayRef<Attribute> operands,
                                     SmallVectorImpl<OpFoldResult> &results) {
   if (succeeded(foldReadInitWrite(*this, operands, results)))
     return success();
   if (succeeded(foldWAR(*this, results)))
     return success();
   if (succeeded(foldTransferInBoundsAttribute(*this)))
     return success();
   return foldMemRefCast(*this);
 }
 
 Optional<SmallVector<int64_t, 4>> TransferWriteOp::getShapeForUnroll() {
   return llvm::to_vector<4>(getVectorType().getShape());
 }
 
 void TransferWriteOp::getEffects(
     SmallVectorImpl<SideEffects::EffectInstance<MemoryEffects::Effect>>
         &effects) {
   if (getShapedType().isa<MemRefType>())
-    effects.emplace_back(MemoryEffects::Write::get(), source(),
+    effects.emplace_back(MemoryEffects::Write::get(), getSource(),
                          SideEffects::DefaultResource::get());
 }
 
 namespace {
 /// Remove dead transfer write from the SSA chain so that it an be eliminated by
 /// DCE
 /// ```
 ///  %w0 = vector.transfer_write %v0, %arg0[%c1, %c0] {in_bounds = [true, true]}

 public:
   using OpRewritePattern<TransferWriteOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(TransferWriteOp writeOp,
                                 PatternRewriter &rewriter) const override {
     if (!writeOp.getShapedType().isa<RankedTensorType>())
       return failure();
     vector::TransferWriteOp writeToModify = writeOp;
 
-    auto defWrite = writeOp.source().getDefiningOp<vector::TransferWriteOp>();
+    auto defWrite =
+        writeOp.getSource().getDefiningOp<vector::TransferWriteOp>();
     while (defWrite) {
       if (checkSameValueWAW(writeOp, defWrite)) {
-        writeToModify.sourceMutable().assign(defWrite.source());
+        writeToModify.getSourceMutable().assign(defWrite.getSource());
         return success();
       }
       if (!isDisjointTransferIndices(
               cast<VectorTransferOpInterface>(defWrite.getOperation()),
               cast<VectorTransferOpInterface>(writeOp.getOperation())))
         break;
       // If the previous write op doesn't have any other use we an safely look
       // at the previous store to see if it can be removed.
       if (!defWrite->hasOneUse())
         break;
       writeToModify = defWrite;
-      defWrite = defWrite.source().getDefiningOp<vector::TransferWriteOp>();
+      defWrite = defWrite.getSource().getDefiningOp<vector::TransferWriteOp>();
     }
     return failure();
   }
 };
 
 /// Fold tensor.insert_slice into vector.transfer_write if the transfer_write
 /// could directly write to the insert_slice's destination. E.g.:
 ///
LogicalResult matchAndRewrite(tensor::InsertSliceOp insertOp,
     // TODO: support 0-d corner case.
     if (xferOp.getTransferRank() == 0)
       return failure();
 
     if (xferOp.hasOutOfBoundsDim())
       return failure();
     if (xferOp.getVectorType().getRank() != xferOp.getShapedType().getRank())
       return failure();
-    if (xferOp.mask())
+    if (xferOp.getMask())
       return failure();
     // Fold only if the TransferWriteOp completely overwrites the `source` with
     // a vector. I.e., the result of the TransferWriteOp is a new tensor whose
     // content is the data of the vector.
     if (!llvm::equal(xferOp.getVectorType().getShape(),
                      xferOp.getShapedType().getShape()))
       return failure();
-    if (!xferOp.permutation_map().isIdentity())
+    if (!xferOp.getPermutationMap().isIdentity())
       return failure();
 
     // Bail on illegal rank-reduction: we need to check that the rank-reduced
     // dims are exactly the leading dims. I.e. the following is illegal:
     // ```
     //    %0 = vector.transfer_write %v, %t[0,0], %cst :
     //      vector<2x4xf32>, tensor<2x4xf32>
     //    %1 = tensor.insert_slice %0 into %tt[0,0,0][2,1,4][1,1,1] :
LogicalResult matchAndRewrite(tensor::InsertSliceOp insertOp,
     if (rankReduced > 0 &&
         actualSourceTensorShape.take_back(vectorRank) !=
             inferredSourceTensorType.getShape().take_back(vectorRank))
       return failure();
 
     SmallVector<Value> indices = getValueOrCreateConstantIndexOp(
         rewriter, insertOp.getLoc(), insertOp.getMixedOffsets());
     SmallVector<bool> inBounds(xferOp.getTransferRank(), true);
-    rewriter.replaceOpWithNewOp<TransferWriteOp>(insertOp, xferOp.vector(),
+    rewriter.replaceOpWithNewOp<TransferWriteOp>(insertOp, xferOp.getVector(),
                                                  insertOp.dest(), indices,
                                                  ArrayRef<bool>{inBounds});
     return success();
   }
 };
 } // namespace
 
 void TransferWriteOp::getCanonicalizationPatterns(RewritePatternSet &results,
LogicalResult vector::LoadOp::verify() {
   if (auto memVecTy = memElemTy.dyn_cast<VectorType>()) {
     if (memVecTy != resVecTy)
       return emitOpError("base memref and result vector types should match");
     memElemTy = memVecTy.getElementType();
   }
 
   if (resVecTy.getElementType() != memElemTy)
     return emitOpError("base and result element types should match");
-  if (llvm::size(indices()) != memRefTy.getRank())
+  if (llvm::size(getIndices()) != memRefTy.getRank())
     return emitOpError("requires ") << memRefTy.getRank() << " indices";
   return success();
 }
 
 OpFoldResult LoadOp::fold(ArrayRef<Attribute>) {
   if (succeeded(foldMemRefCast(*this)))
     return getResult();
   return OpFoldResult();
if (auto memVecTy = memElemTy.dyn_cast<VectorType>()) {
     if (memVecTy != valueVecTy)
       return emitOpError(
           "base memref and valueToStore vector types should match");
     memElemTy = memVecTy.getElementType();
   }
 
   if (valueVecTy.getElementType() != memElemTy)
     return emitOpError("base and valueToStore element type should match");
-  if (llvm::size(indices()) != memRefTy.getRank())
+  if (llvm::size(getIndices()) != memRefTy.getRank())
     return emitOpError("requires ") << memRefTy.getRank() << " indices";
   return success();
 }
 
 LogicalResult StoreOp::fold(ArrayRef<Attribute> operands,
                             SmallVectorImpl<OpFoldResult> &results) {
   return foldMemRefCast(*this);
 }
 
 //===----------------------------------------------------------------------===//
 // MaskedLoadOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult MaskedLoadOp::verify() {
   VectorType maskVType = getMaskVectorType();
   VectorType passVType = getPassThruVectorType();
   VectorType resVType = getVectorType();
   MemRefType memType = getMemRefType();
 
   if (resVType.getElementType() != memType.getElementType())
     return emitOpError("base and result element type should match");
-  if (llvm::size(indices()) != memType.getRank())
+  if (llvm::size(getIndices()) != memType.getRank())
     return emitOpError("requires ") << memType.getRank() << " indices";
   if (resVType.getDimSize(0) != maskVType.getDimSize(0))
     return emitOpError("expected result dim to match mask dim");
   if (resVType != passVType)
     return emitOpError("expected pass_thru of same type as result type");
   return success();
 }
 
 namespace {
 class MaskedLoadFolder final : public OpRewritePattern<MaskedLoadOp> {
 public:
   using OpRewritePattern<MaskedLoadOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(MaskedLoadOp load,
                                 PatternRewriter &rewriter) const override {
-    switch (get1DMaskFormat(load.mask())) {
+    switch (get1DMaskFormat(load.getMask())) {
     case MaskFormat::AllTrue:
-      rewriter.replaceOpWithNewOp<vector::LoadOp>(load, load.getType(),
-                                                  load.base(), load.indices());
+      rewriter.replaceOpWithNewOp<vector::LoadOp>(
+          load, load.getType(), load.getBase(), load.getIndices());
       return success();
     case MaskFormat::AllFalse:
-      rewriter.replaceOp(load, load.pass_thru());
+      rewriter.replaceOp(load, load.getPassThru());
       return success();
     case MaskFormat::Unknown:
       return failure();
     }
     llvm_unreachable("Unexpected 1DMaskFormat on MaskedLoad");
   }
 };
 } // namespace

 
 LogicalResult MaskedStoreOp::verify() {
   VectorType maskVType = getMaskVectorType();
   VectorType valueVType = getVectorType();
   MemRefType memType = getMemRefType();
 
   if (valueVType.getElementType() != memType.getElementType())
     return emitOpError("base and valueToStore element type should match");
-  if (llvm::size(indices()) != memType.getRank())
+  if (llvm::size(getIndices()) != memType.getRank())
     return emitOpError("requires ") << memType.getRank() << " indices";
   if (valueVType.getDimSize(0) != maskVType.getDimSize(0))
     return emitOpError("expected valueToStore dim to match mask dim");
   return success();
 }
 
 namespace {
 class MaskedStoreFolder final : public OpRewritePattern<MaskedStoreOp> {
 public:
   using OpRewritePattern<MaskedStoreOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(MaskedStoreOp store,
                                 PatternRewriter &rewriter) const override {
-    switch (get1DMaskFormat(store.mask())) {
+    switch (get1DMaskFormat(store.getMask())) {
     case MaskFormat::AllTrue:
       rewriter.replaceOpWithNewOp<vector::StoreOp>(
-          store, store.valueToStore(), store.base(), store.indices());
+          store, store.getValueToStore(), store.getBase(), store.getIndices());
       return success();
     case MaskFormat::AllFalse:
       rewriter.eraseOp(store);
       return success();
     case MaskFormat::Unknown:
       return failure();
     }
     llvm_unreachable("Unexpected 1DMaskFormat on MaskedStore");

 LogicalResult GatherOp::verify() {
   VectorType indVType = getIndexVectorType();
   VectorType maskVType = getMaskVectorType();
   VectorType resVType = getVectorType();
   MemRefType memType = getMemRefType();
 
   if (resVType.getElementType() != memType.getElementType())
     return emitOpError("base and result element type should match");
-  if (llvm::size(indices()) != memType.getRank())
+  if (llvm::size(getIndices()) != memType.getRank())
     return emitOpError("requires ") << memType.getRank() << " indices";
   if (resVType.getDimSize(0) != indVType.getDimSize(0))
     return emitOpError("expected result dim to match indices dim");
   if (resVType.getDimSize(0) != maskVType.getDimSize(0))
     return emitOpError("expected result dim to match mask dim");
   if (resVType != getPassThruVectorType())
     return emitOpError("expected pass_thru of same type as result type");
   return success();
 }
 
 namespace {
 class GatherFolder final : public OpRewritePattern<GatherOp> {
 public:
   using OpRewritePattern<GatherOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(GatherOp gather,
                                 PatternRewriter &rewriter) const override {
-    switch (get1DMaskFormat(gather.mask())) {
+    switch (get1DMaskFormat(gather.getMask())) {
     case MaskFormat::AllTrue:
       return failure(); // no unmasked equivalent
     case MaskFormat::AllFalse:
-      rewriter.replaceOp(gather, gather.pass_thru());
+      rewriter.replaceOp(gather, gather.getPassThru());
       return success();
     case MaskFormat::Unknown:
       return failure();
     }
     llvm_unreachable("Unexpected 1DMaskFormat on GatherFolder");
   }
 };
 } // namespace

 LogicalResult ScatterOp::verify() {
   VectorType indVType = getIndexVectorType();
   VectorType maskVType = getMaskVectorType();
   VectorType valueVType = getVectorType();
   MemRefType memType = getMemRefType();
 
   if (valueVType.getElementType() != memType.getElementType())
     return emitOpError("base and valueToStore element type should match");
-  if (llvm::size(indices()) != memType.getRank())
+  if (llvm::size(getIndices()) != memType.getRank())
     return emitOpError("requires ") << memType.getRank() << " indices";
   if (valueVType.getDimSize(0) != indVType.getDimSize(0))
     return emitOpError("expected valueToStore dim to match indices dim");
   if (valueVType.getDimSize(0) != maskVType.getDimSize(0))
     return emitOpError("expected valueToStore dim to match mask dim");
   return success();
 }
 
 namespace {
 class ScatterFolder final : public OpRewritePattern<ScatterOp> {
 public:
   using OpRewritePattern<ScatterOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(ScatterOp scatter,
                                 PatternRewriter &rewriter) const override {
-    switch (get1DMaskFormat(scatter.mask())) {
+    switch (get1DMaskFormat(scatter.getMask())) {
     case MaskFormat::AllTrue:
       return failure(); // no unmasked equivalent
     case MaskFormat::AllFalse:
       rewriter.eraseOp(scatter);
       return success();
     case MaskFormat::Unknown:
       return failure();
     }

 LogicalResult ExpandLoadOp::verify() {
   VectorType maskVType = getMaskVectorType();
   VectorType passVType = getPassThruVectorType();
   VectorType resVType = getVectorType();
   MemRefType memType = getMemRefType();
 
   if (resVType.getElementType() != memType.getElementType())
     return emitOpError("base and result element type should match");
-  if (llvm::size(indices()) != memType.getRank())
+  if (llvm::size(getIndices()) != memType.getRank())
     return emitOpError("requires ") << memType.getRank() << " indices";
   if (resVType.getDimSize(0) != maskVType.getDimSize(0))
     return emitOpError("expected result dim to match mask dim");
   if (resVType != passVType)
     return emitOpError("expected pass_thru of same type as result type");
   return success();
 }
 
 namespace {
 class ExpandLoadFolder final : public OpRewritePattern<ExpandLoadOp> {
 public:
   using OpRewritePattern<ExpandLoadOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(ExpandLoadOp expand,
                                 PatternRewriter &rewriter) const override {
-    switch (get1DMaskFormat(expand.mask())) {
+    switch (get1DMaskFormat(expand.getMask())) {
     case MaskFormat::AllTrue:
       rewriter.replaceOpWithNewOp<vector::LoadOp>(
-          expand, expand.getType(), expand.base(), expand.indices());
+          expand, expand.getType(), expand.getBase(), expand.getIndices());
       return success();
     case MaskFormat::AllFalse:
-      rewriter.replaceOp(expand, expand.pass_thru());
+      rewriter.replaceOp(expand, expand.getPassThru());
       return success();
     case MaskFormat::Unknown:
       return failure();
     }
     llvm_unreachable("Unexpected 1DMaskFormat on ExpandLoadFolder");
   }
 };
 } // namespace

 
 LogicalResult CompressStoreOp::verify() {
   VectorType maskVType = getMaskVectorType();
   VectorType valueVType = getVectorType();
   MemRefType memType = getMemRefType();
 
   if (valueVType.getElementType() != memType.getElementType())
     return emitOpError("base and valueToStore element type should match");
-  if (llvm::size(indices()) != memType.getRank())
+  if (llvm::size(getIndices()) != memType.getRank())
     return emitOpError("requires ") << memType.getRank() << " indices";
   if (valueVType.getDimSize(0) != maskVType.getDimSize(0))
     return emitOpError("expected valueToStore dim to match mask dim");
   return success();
 }
 
 namespace {
 class CompressStoreFolder final : public OpRewritePattern<CompressStoreOp> {
 public:
   using OpRewritePattern<CompressStoreOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(CompressStoreOp compress,
                                 PatternRewriter &rewriter) const override {
-    switch (get1DMaskFormat(compress.mask())) {
+    switch (get1DMaskFormat(compress.getMask())) {
     case MaskFormat::AllTrue:
       rewriter.replaceOpWithNewOp<vector::StoreOp>(
-          compress, compress.valueToStore(), compress.base(),
-          compress.indices());
+          compress, compress.getValueToStore(), compress.getBase(),
+          compress.getIndices());
       return success();
     case MaskFormat::AllFalse:
       rewriter.eraseOp(compress);
       return success();
     case MaskFormat::Unknown:
       return failure();
     }
     llvm_unreachable("Unexpected 1DMaskFormat on CompressStoreFolder");
static LogicalResult verifyVectorShapeCast(Operation *op,
   } else if (sourceRank > resultRank) {
     if (!isValidShapeCast(resultShape, sourceShape))
       return op->emitOpError("invalid shape cast");
   }
   return success();
 }
 
 LogicalResult ShapeCastOp::verify() {
-  auto sourceVectorType = source().getType().dyn_cast_or_null<VectorType>();
-  auto resultVectorType = result().getType().dyn_cast_or_null<VectorType>();
+  auto sourceVectorType = getSource().getType().dyn_cast_or_null<VectorType>();
+  auto resultVectorType = getResult().getType().dyn_cast_or_null<VectorType>();
 
   // Check if source/result are of vector type.
   if (sourceVectorType && resultVectorType)
     return verifyVectorShapeCast(*this, sourceVectorType, resultVectorType);
 
   return success();
 }
 
 OpFoldResult ShapeCastOp::fold(ArrayRef<Attribute> operands) {
   // Nop shape cast.
-  if (source().getType() == result().getType())
-    return source();
+  if (getSource().getType() == getResult().getType())
+    return getSource();
 
   // Canceling shape casts.
-  if (auto otherOp = source().getDefiningOp<ShapeCastOp>()) {
-    if (result().getType() == otherOp.source().getType())
-      return otherOp.source();
+  if (auto otherOp = getSource().getDefiningOp<ShapeCastOp>()) {
+    if (getResult().getType() == otherOp.getSource().getType())
+      return otherOp.getSource();
 
     // Only allows valid transitive folding.
-    VectorType srcType = otherOp.source().getType().cast<VectorType>();
+    VectorType srcType = otherOp.getSource().getType().cast<VectorType>();
     VectorType resultType = getResult().getType().cast<VectorType>();
     if (srcType.getRank() < resultType.getRank()) {
       if (!isValidShapeCast(srcType.getShape(), resultType.getShape()))
         return {};
     } else if (srcType.getRank() > resultType.getRank()) {
       if (!isValidShapeCast(resultType.getShape(), srcType.getShape()))
         return {};
     } else {
       return {};
     }
 
-    setOperand(otherOp.source());
+    setOperand(otherOp.getSource());
     return getResult();
   }
   return {};
 }
 
 namespace {
 // Pattern to rewrite a ShapeCast(splat ConstantOp) -> ConstantOp.
 class ShapeCastConstantFolder final : public OpRewritePattern<ShapeCastOp> {
 public:
   using OpRewritePattern<ShapeCastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ShapeCastOp shapeCastOp,
                                 PatternRewriter &rewriter) const override {
-    auto constantOp = shapeCastOp.source().getDefiningOp<arith::ConstantOp>();
+    auto constantOp =
+        shapeCastOp.getSource().getDefiningOp<arith::ConstantOp>();
     if (!constantOp)
       return failure();
     // Only handle splat for now.
     auto dense = constantOp.getValue().dyn_cast<SplatElementsAttr>();
     if (!dense)
       return failure();
     auto newAttr =
         DenseElementsAttr::get(shapeCastOp.getType().cast<VectorType>(),
return emitOpError(
         "source/result bitwidth of the minor 1-D vectors must be equal");
   }
 
   return success();
 }
 
 OpFoldResult BitCastOp::fold(ArrayRef<Attribute> operands) {
   // Nop cast.
-  if (source().getType() == result().getType())
-    return source();
+  if (getSource().getType() == getResult().getType())
+    return getSource();
 
   // Canceling bitcasts.
-  if (auto otherOp = source().getDefiningOp<BitCastOp>())
-    if (result().getType() == otherOp.source().getType())
-      return otherOp.source();
+  if (auto otherOp = getSource().getDefiningOp<BitCastOp>())
+    if (getResult().getType() == otherOp.getSource().getType())
+      return otherOp.getSource();
 
   Attribute sourceConstant = operands.front();
   if (!sourceConstant)
     return {};
 
   Type srcElemType = getSourceVectorType().getElementType();
   Type dstElemType = getResultVectorType().getElementType();
 
OpFoldResult vector::TransposeOp::fold(ArrayRef<Attribute> operands) {
 
   // Check if the permutation of the dimensions contains sequential values:
   // {0, 1, 2, ...}.
   for (int64_t i = 0, e = transp.size(); i < e; i++) {
     if (transp[i] != i)
       return {};
   }
 
-  return vector();
+  return getVector();
 }
 
 LogicalResult vector::TransposeOp::verify() {
   VectorType vectorType = getVectorType();
   VectorType resultType = getResultType();
   int64_t rank = resultType.getRank();
   if (vectorType.getRank() != rank)
     return emitOpError("vector result rank mismatch: ") << rank;
   // Verify transposition array.
-  auto transpAttr = transp().getValue();
+  auto transpAttr = getTransp().getValue();
   int64_t size = transpAttr.size();
   if (rank != size)
     return emitOpError("transposition length mismatch: ") << size;
   SmallVector<bool, 8> seen(rank, false);
   for (const auto &ta : llvm::enumerate(transpAttr)) {
     int64_t i = ta.value().cast<IntegerAttr>().getInt();
     if (i < 0 || i >= rank)
       return emitOpError("transposition index out of range: ") << i;
auto composePermutations = [](ArrayRef<int64_t> permutation1,
       SmallVector<int64_t, 4> result;
       for (auto index : permutation2)
         result.push_back(permutation1[index]);
       return result;
     };
 
     // Return if the input of 'transposeOp' is not defined by another transpose.
     vector::TransposeOp parentTransposeOp =
-        transposeOp.vector().getDefiningOp<vector::TransposeOp>();
+        transposeOp.getVector().getDefiningOp<vector::TransposeOp>();
     if (!parentTransposeOp)
       return failure();
 
     SmallVector<int64_t, 4> permutation = composePermutations(
         getPermutation(parentTransposeOp), getPermutation(transposeOp));
     // Replace 'transposeOp' with a new transpose operation.
     rewriter.replaceOpWithNewOp<vector::TransposeOp>(
         transposeOp, transposeOp.getResult().getType(),
-        parentTransposeOp.vector(),
+        parentTransposeOp.getVector(),
         vector::getVectorSubscriptAttr(rewriter, permutation));
     return success();
   }
 };
 
 } // namespace
 
 void vector::TransposeOp::getCanonicalizationPatterns(
     RewritePatternSet &results, MLIRContext *context) {
   results.add<TransposeFolder>(context);
 }
 
 void vector::TransposeOp::getTransp(SmallVectorImpl<int64_t> &results) {
-  populateFromInt64AttrArray(transp(), results);
+  populateFromInt64AttrArray(getTransp(), results);
 }
 
 //===----------------------------------------------------------------------===//
 // ConstantMaskOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ConstantMaskOp::verify() {
   auto resultType = getResult().getType().cast<VectorType>();
   // Check the corner case of 0-D vectors first.
   if (resultType.getRank() == 0) {
-    if (mask_dim_sizes().size() != 1)
+    if (getMaskDimSizes().size() != 1)
       return emitError("array attr must have length 1 for 0-D vectors");
-    auto dim = mask_dim_sizes()[0].cast<IntegerAttr>().getInt();
+    auto dim = getMaskDimSizes()[0].cast<IntegerAttr>().getInt();
     if (dim != 0 && dim != 1)
       return emitError("mask dim size must be either 0 or 1 for 0-D vectors");
     return success();
   }
 
   // Verify that array attr size matches the rank of the vector result.
-  if (static_cast<int64_t>(mask_dim_sizes().size()) != resultType.getRank())
+  if (static_cast<int64_t>(getMaskDimSizes().size()) != resultType.getRank())
     return emitOpError(
         "must specify array attr of size equal vector result rank");
   // Verify that each array attr element is in bounds of corresponding vector
   // result dimension size.
   auto resultShape = resultType.getShape();
   SmallVector<int64_t, 4> maskDimSizes;
-  for (const auto &it : llvm::enumerate(mask_dim_sizes())) {
+  for (const auto &it : llvm::enumerate(getMaskDimSizes())) {
     int64_t attrValue = it.value().cast<IntegerAttr>().getInt();
     if (attrValue < 0 || attrValue > resultShape[it.index()])
       return emitOpError(
           "array attr of size out of bounds of vector result dimension size");
     maskDimSizes.push_back(attrValue);
   }
   // Verify that if one mask dim size is zero, they all should be zero (because
   // the mask region is a conjunction of each mask dimension interval).
   bool anyZeros = llvm::is_contained(maskDimSizes, 0);
   bool allZeros = llvm::all_of(maskDimSizes, [](int64_t s) { return s == 0; });
   if (anyZeros && !allZeros)
     return emitOpError("expected all mask dim sizes to be zeros, "
                        "as a result of conjunction with zero mask dim");
   // Verify that if the mask type is scalable, dimensions should be zero because
   // constant scalable masks can only be defined for the "none set" or "all set"
   // cases, and there is no VLA way to define an "all set" case for
   // `vector.constant_mask`. In the future, a convention could be established
   // to decide if a specific dimension value could be considered as "all set".
   if (resultType.isScalable() &&
-      mask_dim_sizes()[0].cast<IntegerAttr>().getInt() != 0)
+      getMaskDimSizes()[0].cast<IntegerAttr>().getInt() != 0)
     return emitOpError("expected mask dim sizes for scalable masks to be 0");
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // CreateMaskOp
 //===----------------------------------------------------------------------===//
 

 // ScanOp
 //===----------------------------------------------------------------------===//
 
 LogicalResult ScanOp::verify() {
   VectorType srcType = getSourceType();
   VectorType initialType = getInitialValueType();
   // Check reduction dimension < rank.
   int64_t srcRank = srcType.getRank();
-  int64_t reductionDim = reduction_dim();
+  int64_t reductionDim = getReductionDim();
   if (reductionDim >= srcRank)
     return emitOpError("reduction dimension ")
            << reductionDim << " has to be less than " << srcRank;
 
   // Check that rank(initial_value) = rank(src) - 1.
   int64_t initialValueRank = initialType.getRank();
   if (initialValueRank != srcRank - 1)
     return emitOpError("initial value rank ")

mlir/lib/Dialect/Vector/Transforms/BufferizableOpInterfaceImpl.cpp

LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
     auto readOp = cast<vector::TransferReadOp>(op);
     assert(readOp.getShapedType().isa<TensorType>() &&
            "only tensor types expected");
 
     // TransferReadOp always reads from the bufferized op.source().
     Value buffer =
         *state.getBuffer(rewriter, readOp->getOpOperand(0) /*source*/);
     replaceOpWithNewBufferizedOp<vector::TransferReadOp>(
-        rewriter, readOp, readOp.getVectorType(), buffer, readOp.indices(),
-        readOp.permutation_map(), readOp.padding(), readOp.mask(),
-        readOp.in_boundsAttr());
+        rewriter, readOp, readOp.getVectorType(), buffer, readOp.getIndices(),
+        readOp.getPermutationMap(), readOp.getPadding(), readOp.getMask(),
+        readOp.getInBoundsAttr());
     return success();
   }
 };
 
 /// Bufferization of vector.transfer_write. Replace with a new
 /// vector.transfer_write that operates on a memref.
 struct TransferWriteOpInterface
     : public BufferizableOpInterface::ExternalModel<TransferWriteOpInterface,
LogicalResult bufferize(Operation *op, RewriterBase &rewriter,
     // Create a new transfer_write on buffer that doesn't have a return value.
     // Leave the previous transfer_write to dead code as it still has uses at
     // this point.
     FailureOr<Value> resultBuffer =
         state.getBuffer(rewriter, op->getOpOperand(1) /*source*/);
     if (failed(resultBuffer))
       return failure();
     rewriter.create<vector::TransferWriteOp>(
-        writeOp.getLoc(), writeOp.vector(), *resultBuffer, writeOp.indices(),
-        writeOp.permutation_mapAttr(), writeOp.in_boundsAttr());
+        writeOp.getLoc(), writeOp.getVector(), *resultBuffer,
+        writeOp.getIndices(), writeOp.getPermutationMapAttr(),
+        writeOp.getInBoundsAttr());
     replaceOpWithBufferizedValues(rewriter, op, *resultBuffer);
 
     return success();
   }
 };
 
 } // namespace
 } // namespace vector

mlir/lib/Dialect/Vector/Transforms/VectorDropLeadUnitDim.cpp

LogicalResult matchAndRewrite(vector::ExtractStridedSliceOp extractOp,
     VectorType oldDstType = extractOp.getType();
     VectorType newDstType =
         VectorType::get(oldDstType.getShape().drop_front(dropCount),
                         oldDstType.getElementType());
 
     Location loc = extractOp.getLoc();
 
     Value newSrcVector = rewriter.create<vector::ExtractOp>(
-        loc, extractOp.vector(), splatZero(dropCount));
+        loc, extractOp.getVector(), splatZero(dropCount));
 
     // The offsets/sizes/strides attribute can have a less number of elements
     // than the input vector's rank: it is meant for the leading dimensions.
     auto newOffsets = rewriter.getArrayAttr(
-        extractOp.offsets().getValue().drop_front(dropCount));
+        extractOp.getOffsets().getValue().drop_front(dropCount));
     auto newSizes = rewriter.getArrayAttr(
-        extractOp.sizes().getValue().drop_front(dropCount));
+        extractOp.getSizes().getValue().drop_front(dropCount));
     auto newStrides = rewriter.getArrayAttr(
-        extractOp.strides().getValue().drop_front(dropCount));
+        extractOp.getStrides().getValue().drop_front(dropCount));
 
     auto newExtractOp = rewriter.create<vector::ExtractStridedSliceOp>(
         loc, newDstType, newSrcVector, newOffsets, newSizes, newStrides);
 
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(extractOp, oldDstType,
                                                      newExtractOp);
 
     return success();
LogicalResult matchAndRewrite(vector::InsertStridedSliceOp insertOp,
     int64_t dstDropCount = oldDstType.getRank() - newDstType.getRank();
     if (srcDropCount == 0 && dstDropCount == 0)
       return failure();
 
     // Trim leading one dimensions from both operands.
     Location loc = insertOp.getLoc();
 
     Value newSrcVector = rewriter.create<vector::ExtractOp>(
-        loc, insertOp.source(), splatZero(srcDropCount));
+        loc, insertOp.getSource(), splatZero(srcDropCount));
     Value newDstVector = rewriter.create<vector::ExtractOp>(
-        loc, insertOp.dest(), splatZero(dstDropCount));
+        loc, insertOp.getDest(), splatZero(dstDropCount));
 
     auto newOffsets = rewriter.getArrayAttr(
-        insertOp.offsets().getValue().take_back(newDstType.getRank()));
+        insertOp.getOffsets().getValue().take_back(newDstType.getRank()));
     auto newStrides = rewriter.getArrayAttr(
-        insertOp.strides().getValue().take_back(newSrcType.getRank()));
+        insertOp.getStrides().getValue().take_back(newSrcType.getRank()));
 
     auto newInsertOp = rewriter.create<vector::InsertStridedSliceOp>(
         loc, newDstType, newSrcVector, newDstVector, newOffsets, newStrides);
 
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(insertOp, oldDstType,
                                                      newInsertOp);
 
     return success();
   }
 };
 
 // Turns vector.transfer_read on vector with leading 1 dimensions into
 // vector.shape_cast followed by vector.transfer_read on vector without leading
 // 1 dimensions.
 struct CastAwayTransferReadLeadingOneDim
     : public OpRewritePattern<vector::TransferReadOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferReadOp read,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (read.getTransferRank() == 0)
       return failure();
 
-    if (read.mask())
+    if (read.getMask())
       return failure();
 
-    auto shapedType = read.source().getType().cast<ShapedType>();
+    auto shapedType = read.getSource().getType().cast<ShapedType>();
     if (shapedType.getElementType() != read.getVectorType().getElementType())
       return failure();
 
     VectorType oldType = read.getVectorType();
     VectorType newType = trimLeadingOneDims(oldType);
 
     if (newType == oldType)
       return failure();
 
-    AffineMap oldMap = read.permutation_map();
+    AffineMap oldMap = read.getPermutationMap();
     ArrayRef<AffineExpr> newResults =
         oldMap.getResults().take_back(newType.getRank());
     AffineMap newMap =
         AffineMap::get(oldMap.getNumDims(), oldMap.getNumSymbols(), newResults,
                        rewriter.getContext());
 
     ArrayAttr inBoundsAttr;
-    if (read.in_bounds())
+    if (read.getInBounds())
       inBoundsAttr = rewriter.getArrayAttr(
-          read.in_boundsAttr().getValue().take_back(newType.getRank()));
+          read.getInBoundsAttr().getValue().take_back(newType.getRank()));
 
     auto newRead = rewriter.create<vector::TransferReadOp>(
-        read.getLoc(), newType, read.source(), read.indices(),
-        AffineMapAttr::get(newMap), read.padding(), /*mask=*/Value(),
+        read.getLoc(), newType, read.getSource(), read.getIndices(),
+        AffineMapAttr::get(newMap), read.getPadding(), /*mask=*/Value(),
         inBoundsAttr);
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(read, oldType, newRead);
 
     return success();
   }
 };
 
 // Turns vector.transfer_write on vector with leading 1 dimensions into
 // vector.shape_cast followed by vector.transfer_write on vector without leading
 // 1 dimensions.
 struct CastAwayTransferWriteLeadingOneDim
     : public OpRewritePattern<vector::TransferWriteOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferWriteOp write,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (write.getTransferRank() == 0)
       return failure();
 
-    if (write.mask())
+    if (write.getMask())
       return failure();
 
-    auto shapedType = write.source().getType().dyn_cast<ShapedType>();
+    auto shapedType = write.getSource().getType().dyn_cast<ShapedType>();
     if (shapedType.getElementType() != write.getVectorType().getElementType())
       return failure();
 
     VectorType oldType = write.getVectorType();
     VectorType newType = trimLeadingOneDims(oldType);
     if (newType == oldType)
       return failure();
     int64_t dropDim = oldType.getRank() - newType.getRank();
 
-    AffineMap oldMap = write.permutation_map();
+    AffineMap oldMap = write.getPermutationMap();
     ArrayRef<AffineExpr> newResults =
         oldMap.getResults().take_back(newType.getRank());
     AffineMap newMap =
         AffineMap::get(oldMap.getNumDims(), oldMap.getNumSymbols(), newResults,
                        rewriter.getContext());
 
     ArrayAttr inBoundsAttr;
-    if (write.in_bounds())
+    if (write.getInBounds())
       inBoundsAttr = rewriter.getArrayAttr(
-          write.in_boundsAttr().getValue().take_back(newType.getRank()));
+          write.getInBoundsAttr().getValue().take_back(newType.getRank()));
 
     auto newVector = rewriter.create<vector::ExtractOp>(
-        write.getLoc(), write.vector(), splatZero(dropDim));
+        write.getLoc(), write.getVector(), splatZero(dropDim));
     rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(
-        write, newVector, write.source(), write.indices(),
+        write, newVector, write.getSource(), write.getIndices(),
         AffineMapAttr::get(newMap), inBoundsAttr);
 
     return success();
   }
 };
 
 /// Turns vector.contract on vector with leading 1 dimensions into
 /// vector.extract followed by vector.contract on vector without leading
 /// 1 dimensions. Also performs tranpose of lhs and rhs operands if required
 /// prior to extract.
 struct CastAwayContractionLeadingOneDim
     : public OpRewritePattern<vector::ContractionOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
                                 PatternRewriter &rewriter) const override {
     VectorType oldAccType = contractOp.getAccType().dyn_cast<VectorType>();
     if (oldAccType == nullptr)
       return failure();
     if (oldAccType.getRank() < 2)
       return failure();
     // TODO: implement masks.
-    if (llvm::size(contractOp.masks()) != 0)
+    if (llvm::size(contractOp.getMasks()) != 0)
       return failure();
     if (oldAccType.getShape()[0] != 1)
       return failure();
     // currently we support only dropping one dim but the pattern can be applied
     // greedily to drop more.
     int64_t dropDim = 1;
 
     auto oldIndexingMaps = contractOp.getIndexingMaps();
     SmallVector<AffineMap> newIndexingMaps;
 
-    auto oldIteratorTypes = contractOp.iterator_types();
+    auto oldIteratorTypes = contractOp.getIteratorTypes();
     SmallVector<Attribute> newIteratorTypes;
 
     int64_t dimToDrop = oldIndexingMaps[2].getDimPosition(0);
 
     if (!isParallelIterator(oldIteratorTypes[dimToDrop]))
       // only parallel type iterators can be dropped.
       return failure();
 
     for (const auto &it : llvm::enumerate(oldIteratorTypes)) {
       int64_t currDim = it.index();
       if (currDim == dimToDrop)
         continue;
       newIteratorTypes.push_back(it.value());
     }
 
-    SmallVector<Value> operands = {contractOp.lhs(), contractOp.rhs(),
-                                   contractOp.acc()};
+    SmallVector<Value> operands = {contractOp.getLhs(), contractOp.getRhs(),
+                                   contractOp.getAcc()};
     SmallVector<Value> newOperands;
 
     for (const auto &it : llvm::enumerate(oldIndexingMaps)) {
       // Check if the dim to be dropped exists as a leading dim in the operand
       // if it does then we use vector.extract to drop it.
       bool validExtract = false;
       SmallVector<AffineExpr> results;
       auto map = it.value();
for (const auto &it : llvm::enumerate(oldIndexingMaps)) {
                                 ? rewriter.create<vector::ExtractOp>(
                                       contractOp.getLoc(), operands[it.index()],
                                       splatZero(dropDim))
                                 : operands[it.index()]);
     }
     auto newContractOp = rewriter.create<vector::ContractionOp>(
         contractOp.getLoc(), newOperands[0], newOperands[1], newOperands[2],
         rewriter.getAffineMapArrayAttr(newIndexingMaps),
-        rewriter.getArrayAttr(newIteratorTypes), contractOp.kind());
+        rewriter.getArrayAttr(newIteratorTypes), contractOp.getKind());
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(
         contractOp, contractOp->getResultTypes()[0], newContractOp);
     return success();
   }
 };
 
 class CastAwayElementwiseLeadingOneDim : public RewritePattern {
 public:

mlir/lib/Dialect/Vector/Transforms/VectorInsertExtractStridedSliceRewritePatterns.cpp

 public:
   using OpRewritePattern<InsertStridedSliceOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(InsertStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
     auto srcType = op.getSourceVectorType();
     auto dstType = op.getDestVectorType();
 
-    if (op.offsets().getValue().empty())
+    if (op.getOffsets().getValue().empty())
       return failure();
 
     auto loc = op.getLoc();
     int64_t rankDiff = dstType.getRank() - srcType.getRank();
     assert(rankDiff >= 0);
     if (rankDiff == 0)
       return failure();
 
     int64_t rankRest = dstType.getRank() - rankDiff;
     // Extract / insert the subvector of matching rank and InsertStridedSlice
     // on it.
-    Value extracted =
-        rewriter.create<ExtractOp>(loc, op.dest(),
-                                   getI64SubArray(op.offsets(), /*dropFront=*/0,
-                                                  /*dropBack=*/rankRest));
+    Value extracted = rewriter.create<ExtractOp>(
+        loc, op.getDest(),
+        getI64SubArray(op.getOffsets(), /*dropFront=*/0,
 
     // A different pattern will kick in for InsertStridedSlice with matching
     // ranks.
     auto stridedSliceInnerOp = rewriter.create<InsertStridedSliceOp>(
-        loc, op.source(), extracted,
-        getI64SubArray(op.offsets(), /*dropFront=*/rankDiff),
-        getI64SubArray(op.strides(), /*dropFront=*/0));
+        loc, op.getSource(), extracted,
+        getI64SubArray(op.getOffsets(), /*dropFront=*/rankDiff),
+        getI64SubArray(op.getStrides(), /*dropFront=*/0));
 
     rewriter.replaceOpWithNewOp<InsertOp>(
-        op, stridedSliceInnerOp.getResult(), op.dest(),
-        getI64SubArray(op.offsets(), /*dropFront=*/0,
+        op, stridedSliceInnerOp.getResult(), op.getDest(),
+        getI64SubArray(op.getOffsets(), /*dropFront=*/0,
                        /*dropBack=*/rankRest));
     return success();
   }
 };
 
 /// RewritePattern for InsertStridedSliceOp where source and destination vectors
 /// have the same rank. For each outermost index in the slice:
 ///   begin    end             stride
void initialize() {
     setHasBoundedRewriteRecursion();
   }
 
   LogicalResult matchAndRewrite(InsertStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
     auto srcType = op.getSourceVectorType();
     auto dstType = op.getDestVectorType();
 
-    if (op.offsets().getValue().empty())
+    if (op.getOffsets().getValue().empty())
       return failure();
 
     int64_t srcRank = srcType.getRank();
     int64_t dstRank = dstType.getRank();
     assert(dstRank >= srcRank);
     if (dstRank != srcRank)
       return failure();
 
     if (srcType == dstType) {
-      rewriter.replaceOp(op, op.source());
+      rewriter.replaceOp(op, op.getSource());
       return success();
     }
 
     int64_t offset =
-        op.offsets().getValue().front().cast<IntegerAttr>().getInt();
+        op.getOffsets().getValue().front().cast<IntegerAttr>().getInt();
     int64_t size = srcType.getShape().front();
     int64_t stride =
-        op.strides().getValue().front().cast<IntegerAttr>().getInt();
+        op.getStrides().getValue().front().cast<IntegerAttr>().getInt();
 
     auto loc = op.getLoc();
-    Value res = op.dest();
+    Value res = op.getDest();
 
     if (srcRank == 1) {
       int nSrc = srcType.getShape().front();
       int nDest = dstType.getShape().front();
       // 1. Scale source to destType so we can shufflevector them together.
       SmallVector<int64_t> offsets(nDest, 0);
       for (int64_t i = 0; i < nSrc; ++i)
         offsets[i] = i;
-      Value scaledSource =
-          rewriter.create<ShuffleOp>(loc, op.source(), op.source(), offsets);
+      Value scaledSource = rewriter.create<ShuffleOp>(loc, op.getSource(),
+                                                      op.getSource(), offsets);
 
       // 2. Create a mask where we take the value from scaledSource of dest
       // depending on the offset.
       offsets.clear();
       for (int64_t i = 0, e = offset + size * stride; i < nDest; ++i) {
         if (i < offset || i >= e || (i - offset) % stride != 0)
           offsets.push_back(nDest + i);
         else
           offsets.push_back((i - offset) / stride);
       }
 
       // 3. Replace with a ShuffleOp.
-      rewriter.replaceOpWithNewOp<ShuffleOp>(op, scaledSource, op.dest(),
+      rewriter.replaceOpWithNewOp<ShuffleOp>(op, scaledSource, op.getDest(),
                                              offsets);
 
       return success();
     }
 
     // For each slice of the source vector along the most major dimension.
     for (int64_t off = offset, e = offset + size * stride, idx = 0; off < e;
          off += stride, ++idx) {
       // 1. extract the proper subvector (or element) from source
-      Value extractedSource = extractOne(rewriter, loc, op.source(), idx);
+      Value extractedSource = extractOne(rewriter, loc, op.getSource(), idx);
       if (extractedSource.getType().isa<VectorType>()) {
         // 2. If we have a vector, extract the proper subvector from destination
         // Otherwise we are at the element level and no need to recurse.
-        Value extractedDest = extractOne(rewriter, loc, op.dest(), off);
+        Value extractedDest = extractOne(rewriter, loc, op.getDest(), off);
         // 3. Reduce the problem to lowering a new InsertStridedSlice op with
         // smaller rank.
         extractedSource = rewriter.create<InsertStridedSliceOp>(
             loc, extractedSource, extractedDest,
-            getI64SubArray(op.offsets(), /* dropFront=*/1),
-            getI64SubArray(op.strides(), /* dropFront=*/1));
+            getI64SubArray(op.getOffsets(), /* dropFront=*/1),
+            getI64SubArray(op.getStrides(), /* dropFront=*/1));
       }
       // 4. Insert the extractedSource into the res vector.
       res = insertOne(rewriter, loc, extractedSource, res, off);
     }
 
     rewriter.replaceOp(op, res);
     return success();
   }
void initialize() {
     // is bounded as the rank is strictly decreasing.
     setHasBoundedRewriteRecursion();
   }
 
   LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
                                 PatternRewriter &rewriter) const override {
     auto dstType = op.getType();
 
-    assert(!op.offsets().getValue().empty() && "Unexpected empty offsets");
+    assert(!op.getOffsets().getValue().empty() && "Unexpected empty offsets");
 
     int64_t offset =
-        op.offsets().getValue().front().cast<IntegerAttr>().getInt();
-    int64_t size = op.sizes().getValue().front().cast<IntegerAttr>().getInt();
+        op.getOffsets().getValue().front().cast<IntegerAttr>().getInt();
+    int64_t size =
+        op.getSizes().getValue().front().cast<IntegerAttr>().getInt();
     int64_t stride =
-        op.strides().getValue().front().cast<IntegerAttr>().getInt();
+        op.getStrides().getValue().front().cast<IntegerAttr>().getInt();
 
     auto loc = op.getLoc();
     auto elemType = dstType.getElementType();
     assert(elemType.isSignlessIntOrIndexOrFloat());
 
     // Single offset can be more efficiently shuffled.
-    if (op.offsets().getValue().size() == 1) {
+    if (op.getOffsets().getValue().size() == 1) {
       SmallVector<int64_t, 4> offsets;
       offsets.reserve(size);
       for (int64_t off = offset, e = offset + size * stride; off < e;
            off += stride)
         offsets.push_back(off);
-      rewriter.replaceOpWithNewOp<ShuffleOp>(op, dstType, op.vector(),
-                                             op.vector(),
+      rewriter.replaceOpWithNewOp<ShuffleOp>(op, dstType, op.getVector(),
+                                             op.getVector(),
                                              rewriter.getI64ArrayAttr(offsets));
       return success();
     }
 
     // Extract/insert on a lower ranked extract strided slice op.
     Value zero = rewriter.create<arith::ConstantOp>(
         loc, elemType, rewriter.getZeroAttr(elemType));
     Value res = rewriter.create<SplatOp>(loc, dstType, zero);
     for (int64_t off = offset, e = offset + size * stride, idx = 0; off < e;
          off += stride, ++idx) {
-      Value one = extractOne(rewriter, loc, op.vector(), off);
+      Value one = extractOne(rewriter, loc, op.getVector(), off);
       Value extracted = rewriter.create<ExtractStridedSliceOp>(
-          loc, one, getI64SubArray(op.offsets(), /* dropFront=*/1),
-          getI64SubArray(op.sizes(), /* dropFront=*/1),
-          getI64SubArray(op.strides(), /* dropFront=*/1));
+          loc, one, getI64SubArray(op.getOffsets(), /* dropFront=*/1),
+          getI64SubArray(op.getSizes(), /* dropFront=*/1),
+          getI64SubArray(op.getStrides(), /* dropFront=*/1));
       res = insertOne(rewriter, loc, extracted, res, idx);
     }
     rewriter.replaceOp(op, res);
     return success();
   }
 };
 
 /// Populate the given list with patterns that convert from Vector to LLVM.
 void mlir::vector::populateVectorInsertExtractStridedSliceTransforms(
     RewritePatternSet &patterns) {
   patterns.add<VectorInsertStridedSliceOpDifferentRankRewritePattern,
                VectorInsertStridedSliceOpSameRankRewritePattern,
                VectorExtractStridedSliceOpRewritePattern>(
       patterns.getContext());
 }

mlir/lib/Dialect/Vector/Transforms/VectorMultiDimReductionTransforms.cpp

public:
   explicit InnerOuterDimReductionConversion(
       MLIRContext *context, vector::VectorMultiReductionLowering options)
       : mlir::OpRewritePattern<vector::MultiDimReductionOp>(context),
         useInnerDimsForReduction(
             options == vector::VectorMultiReductionLowering::InnerReduction) {}
 
   LogicalResult matchAndRewrite(vector::MultiDimReductionOp multiReductionOp,
                                 PatternRewriter &rewriter) const override {
-    auto src = multiReductionOp.source();
+    auto src = multiReductionOp.getSource();
     auto loc = multiReductionOp.getLoc();
     auto srcRank = multiReductionOp.getSourceVectorType().getRank();
 
     // Separate reduction and parallel dims
     auto reductionDimsRange =
-        multiReductionOp.reduction_dims().getAsValueRange<IntegerAttr>();
+        multiReductionOp.getReductionDims().getAsValueRange<IntegerAttr>();
     auto reductionDims = llvm::to_vector<4>(llvm::map_range(
         reductionDimsRange, [](const APInt &a) { return a.getZExtValue(); }));
     llvm::SmallDenseSet<int64_t> reductionDimsSet(reductionDims.begin(),
                                                   reductionDims.end());
     int64_t reductionSize = reductionDims.size();
     SmallVector<int64_t, 4> parallelDims;
     for (int64_t i = 0; i < srcRank; ++i)
       if (!reductionDimsSet.contains(i))
LogicalResult matchAndRewrite(vector::MultiDimReductionOp multiReductionOp,
     SmallVector<bool> reductionMask(srcRank, false);
     for (int i = 0; i < reductionSize; ++i) {
       if (useInnerDimsForReduction)
         reductionMask[srcRank - i - 1] = true;
       else
         reductionMask[i] = true;
     }
     rewriter.replaceOpWithNewOp<vector::MultiDimReductionOp>(
-        multiReductionOp, transposeOp.result(), reductionMask,
-        multiReductionOp.kind());
+        multiReductionOp, transposeOp.getResult(), reductionMask,
+        multiReductionOp.getKind());
     return success();
   }
 
 private:
   const bool useInnerDimsForReduction;
 };
 
 /// Reduces the rank of vector.multi_reduction nd -> 2d given all reduction
LogicalResult matchAndRewrite(vector::MultiDimReductionOp multiReductionOp,
     }
     if (!useInnerDimsForReduction && vectorShape.size() == 2) {
       std::swap(mask.front(), mask.back());
       std::swap(vectorShape.front(), vectorShape.back());
     }
     auto castedType = VectorType::get(
         vectorShape, multiReductionOp.getSourceVectorType().getElementType());
     Value cast = rewriter.create<vector::ShapeCastOp>(
-        loc, castedType, multiReductionOp.source());
+        loc, castedType, multiReductionOp.getSource());
 
     // 5. Creates the flattened form of vector.multi_reduction with inner/outer
     // most dim as reduction.
     auto newOp = rewriter.create<vector::MultiDimReductionOp>(
-        loc, cast, mask, multiReductionOp.kind());
+        loc, cast, mask, multiReductionOp.getKind());
 
     // 6. If there are no parallel shapes, the result is a scalar.
     // TODO: support 0-d vectors when available.
     if (parallelShapes.empty()) {
-      rewriter.replaceOp(multiReductionOp, newOp.dest());
+      rewriter.replaceOp(multiReductionOp, newOp.getDest());
       return success();
     }
 
     // 7. Creates shape cast for the output n-D -> 2-D
     VectorType outputCastedType = VectorType::get(
         parallelShapes,
         multiReductionOp.getSourceVectorType().getElementType());
     rewriter.replaceOpWithNewOp<vector::ShapeCastOp>(
-        multiReductionOp, outputCastedType, newOp.dest());
+        multiReductionOp, outputCastedType, newOp.getDest());
     return success();
   }
 
 private:
   const bool useInnerDimsForReduction;
 };
 
 /// Unrolls vector.multi_reduction with outermost reductions
LogicalResult matchAndRewrite(vector::MultiDimReductionOp multiReductionOp,
     ArrayRef<int64_t> srcShape =
         multiReductionOp.getSourceVectorType().getShape();
 
     Type elementType = getElementTypeOrSelf(multiReductionOp.getDestType());
     if (!elementType.isIntOrIndexOrFloat())
       return failure();
 
     Value result =
-        rewriter.create<vector::ExtractOp>(loc, multiReductionOp.source(), 0)
+        rewriter.create<vector::ExtractOp>(loc, multiReductionOp.getSource(), 0)
             .getResult();
     for (int64_t i = 1; i < srcShape[0]; i++) {
-      auto operand =
-          rewriter.create<vector::ExtractOp>(loc, multiReductionOp.source(), i);
-      result = makeArithReduction(rewriter, loc, multiReductionOp.kind(),
+      auto operand = rewriter.create<vector::ExtractOp>(
+          loc, multiReductionOp.getSource(), i);
+      result = makeArithReduction(rewriter, loc, multiReductionOp.getKind(),
                                   operand, result);
     }
 
     rewriter.replaceOp(multiReductionOp, result);
     return success();
   }
 };
 
LogicalResult matchAndRewrite(vector::MultiDimReductionOp multiReductionOp,
     auto loc = multiReductionOp.getLoc();
     Value result = rewriter.create<arith::ConstantOp>(
         loc, multiReductionOp.getDestType(),
         rewriter.getZeroAttr(multiReductionOp.getDestType()));
     int outerDim = multiReductionOp.getSourceVectorType().getShape()[0];
 
     for (int i = 0; i < outerDim; ++i) {
       auto v = rewriter.create<vector::ExtractOp>(
-          loc, multiReductionOp.source(), ArrayRef<int64_t>{i});
-      auto reducedValue =
-          rewriter.create<vector::ReductionOp>(loc, multiReductionOp.kind(), v);
+          loc, multiReductionOp.getSource(), ArrayRef<int64_t>{i});
+      auto reducedValue = rewriter.create<vector::ReductionOp>(
+          loc, multiReductionOp.getKind(), v);
       result = rewriter.create<vector::InsertElementOp>(
           loc, reducedValue, result,
           rewriter.create<arith::ConstantIndexOp>(loc, i));
     }
     rewriter.replaceOp(multiReductionOp, result);
     return success();
   }
 };
assert(!multiReductionOp.getDestType().isa<VectorType>() &&
            "multi_reduction with a single dimension expects a scalar result");
 
     // If the unique dim is reduced and we insert a parallel in front, we need a
     // {false, true} mask.
     SmallVector<bool, 2> mask{false, true};
 
     /// vector.extract(vector.multi_reduce(vector.shape_cast(v, 1xk)), 0)
     Value cast = rewriter.create<vector::ShapeCastOp>(
-        loc, castedType, multiReductionOp.source());
+        loc, castedType, multiReductionOp.getSource());
     Value reduced = rewriter.create<vector::MultiDimReductionOp>(
-        loc, cast, mask, multiReductionOp.kind());
+        loc, cast, mask, multiReductionOp.getKind());
     rewriter.replaceOpWithNewOp<vector::ExtractOp>(multiReductionOp, reduced,
                                                    ArrayRef<int64_t>{0});
     return success();
   }
 };
 
 void mlir::vector::populateVectorMultiReductionLoweringPatterns(
     RewritePatternSet &patterns, VectorMultiReductionLowering options) {
   patterns.add<InnerOuterDimReductionConversion, ReduceMultiDimReductionRank>(
       patterns.getContext(), options);
   patterns.add<OneDimMultiReductionToTwoDim>(patterns.getContext());
   if (options == VectorMultiReductionLowering ::InnerReduction)
     patterns.add<TwoDimMultiReductionToReduction>(patterns.getContext());
   else
     patterns.add<TwoDimMultiReductionToElementWise>(patterns.getContext());
 }

mlir/lib/Dialect/Vector/Transforms/VectorTransferOpTransforms.cpp

 /// If we found such an overwriting transfer_write we know that the original
 /// transfer_write is dead if all reads that can be reached from the potentially
 /// dead transfer_write are dominated by the overwriting transfer_write.
 void TransferOptimization::deadStoreOp(vector::TransferWriteOp write) {
   LLVM_DEBUG(DBGS() << "Candidate for dead store: " << *write.getOperation()
                     << "\n");
   llvm::SmallVector<Operation *, 8> reads;
   Operation *firstOverwriteCandidate = nullptr;
-  for (auto *user : write.source().getUsers()) {
+  for (auto *user : write.getSource().getUsers()) {
     if (user == write.getOperation())
       continue;
     if (auto nextWrite = dyn_cast<vector::TransferWriteOp>(user)) {
       // Check candidate that can override the store.
       if (checkSameValueWAW(nextWrite, write) &&
           postDominators.postDominates(nextWrite, write)) {
         if (firstOverwriteCandidate == nullptr ||
             postDominators.postDominates(firstOverwriteCandidate, nextWrite))

 /// by the transfer_write.
 void TransferOptimization::storeToLoadForwarding(vector::TransferReadOp read) {
   if (read.hasOutOfBoundsDim())
     return;
   LLVM_DEBUG(DBGS() << "Candidate for Forwarding: " << *read.getOperation()
                     << "\n");
   SmallVector<Operation *, 8> blockingWrites;
   vector::TransferWriteOp lastwrite = nullptr;
-  for (Operation *user : read.source().getUsers()) {
+  for (Operation *user : read.getSource().getUsers()) {
     if (isa<vector::TransferReadOp>(user))
       continue;
     if (auto write = dyn_cast<vector::TransferWriteOp>(user)) {
       // If there is a write, but we can prove that it is disjoint we can ignore
       // the write.
       if (vector::isDisjointTransferSet(
               cast<VectorTransferOpInterface>(write.getOperation()),
               cast<VectorTransferOpInterface>(read.getOperation())))
if (!postDominators.postDominates(lastwrite, write)) {
       LLVM_DEBUG(DBGS() << "Fail to do write to read forwarding due to op: "
                         << *write << "\n");
       return;
     }
   }
 
   LLVM_DEBUG(DBGS() << "Forward value from " << *lastwrite.getOperation()
                     << " to: " << *read.getOperation() << "\n");
-  read.replaceAllUsesWith(lastwrite.vector());
+  read.replaceAllUsesWith(lastwrite.getVector());
   opToErase.push_back(read.getOperation());
 }
 
 /// Drops unit dimensions from the input MemRefType.
 static MemRefType dropUnitDims(MemRefType inputType, ArrayRef<int64_t> offsets,
                                ArrayRef<int64_t> sizes,
                                ArrayRef<int64_t> strides) {
   Type rankReducedType = memref::SubViewOp::inferRankReducedResultType(

 /// inserting a memref.subview dropping those unit dims.
 class TransferReadDropUnitDimsPattern
     : public OpRewritePattern<vector::TransferReadOp> {
   using OpRewritePattern<vector::TransferReadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferReadOp transferReadOp,
                                 PatternRewriter &rewriter) const override {
     auto loc = transferReadOp.getLoc();
-    Value vector = transferReadOp.vector();
+    Value vector = transferReadOp.getVector();
     VectorType vectorType = vector.getType().cast<VectorType>();
-    Value source = transferReadOp.source();
+    Value source = transferReadOp.getSource();
     MemRefType sourceType = source.getType().dyn_cast<MemRefType>();
     // TODO: support tensor types.
     if (!sourceType || !sourceType.hasStaticShape())
       return failure();
     if (sourceType.getNumElements() != vectorType.getNumElements())
       return failure();
     // TODO: generalize this pattern, relax the requirements here.
     if (transferReadOp.hasOutOfBoundsDim())
       return failure();
-    if (!transferReadOp.permutation_map().isMinorIdentity())
+    if (!transferReadOp.getPermutationMap().isMinorIdentity())
       return failure();
     int reducedRank = getReducedRank(sourceType.getShape());
     if (reducedRank == sourceType.getRank())
       return failure(); // The source shape can't be further reduced.
     if (reducedRank != vectorType.getRank())
       return failure(); // This pattern requires the vector shape to match the
                         // reduced source shape.
-    if (llvm::any_of(transferReadOp.indices(),
+    if (llvm::any_of(transferReadOp.getIndices(),
                      [](Value v) { return !isZero(v); }))
       return failure();
     Value reducedShapeSource =
         rankReducingSubviewDroppingUnitDims(rewriter, loc, source);
     Value c0 = rewriter.create<arith::ConstantIndexOp>(loc, 0);
     SmallVector<Value> zeros(reducedRank, c0);
     auto identityMap = rewriter.getMultiDimIdentityMap(reducedRank);
     rewriter.replaceOpWithNewOp<vector::TransferReadOp>(
         transferReadOp, vectorType, reducedShapeSource, zeros, identityMap);
     return success();
   }
 };
 
 /// Rewrites vector.transfer_write ops where the "source" (i.e. destination) has
 /// unit dims, by inserting a memref.subview dropping those unit dims.
 class TransferWriteDropUnitDimsPattern
     : public OpRewritePattern<vector::TransferWriteOp> {
   using OpRewritePattern<vector::TransferWriteOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferWriteOp transferWriteOp,
                                 PatternRewriter &rewriter) const override {
     auto loc = transferWriteOp.getLoc();
-    Value vector = transferWriteOp.vector();
+    Value vector = transferWriteOp.getVector();
     VectorType vectorType = vector.getType().cast<VectorType>();
-    Value source = transferWriteOp.source();
+    Value source = transferWriteOp.getSource();
     MemRefType sourceType = source.getType().dyn_cast<MemRefType>();
     // TODO: support tensor type.
     if (!sourceType || !sourceType.hasStaticShape())
       return failure();
     if (sourceType.getNumElements() != vectorType.getNumElements())
       return failure();
     // TODO: generalize this pattern, relax the requirements here.
     if (transferWriteOp.hasOutOfBoundsDim())
       return failure();
-    if (!transferWriteOp.permutation_map().isMinorIdentity())
+    if (!transferWriteOp.getPermutationMap().isMinorIdentity())
       return failure();
     int reducedRank = getReducedRank(sourceType.getShape());
     if (reducedRank == sourceType.getRank())
       return failure(); // The source shape can't be further reduced.
     if (reducedRank != vectorType.getRank())
       return failure(); // This pattern requires the vector shape to match the
                         // reduced source shape.
-    if (llvm::any_of(transferWriteOp.indices(),
+    if (llvm::any_of(transferWriteOp.getIndices(),
                      [](Value v) { return !isZero(v); }))
       return failure();
     Value reducedShapeSource =
         rankReducingSubviewDroppingUnitDims(rewriter, loc, source);
     Value c0 = rewriter.create<arith::ConstantIndexOp>(loc, 0);
     SmallVector<Value> zeros(reducedRank, c0);
     auto identityMap = rewriter.getMultiDimIdentityMap(reducedRank);
     rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(

 /// already reduced i.e. without unit dims.
 class FlattenContiguousRowMajorTransferReadPattern
     : public OpRewritePattern<vector::TransferReadOp> {
   using OpRewritePattern<vector::TransferReadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferReadOp transferReadOp,
                                 PatternRewriter &rewriter) const override {
     auto loc = transferReadOp.getLoc();
-    Value vector = transferReadOp.vector();
+    Value vector = transferReadOp.getVector();
     VectorType vectorType = vector.getType().cast<VectorType>();
-    Value source = transferReadOp.source();
+    Value source = transferReadOp.getSource();
     MemRefType sourceType = source.getType().dyn_cast<MemRefType>();
     // Contiguity check is valid on tensors only.
     if (!sourceType)
       return failure();
     if (vectorType.getRank() <= 1)
       // Already 0D/1D, nothing to do.
       return failure();
     if (!isStaticShapeAndContiguousRowMajor(sourceType))
       return failure();
     if (getReducedRank(sourceType.getShape()) != sourceType.getRank())
       // This pattern requires the source to already be rank-reduced.
       return failure();
     if (sourceType.getNumElements() != vectorType.getNumElements())
       return failure();
     // TODO: generalize this pattern, relax the requirements here.
     if (transferReadOp.hasOutOfBoundsDim())
       return failure();
-    if (!transferReadOp.permutation_map().isMinorIdentity())
+    if (!transferReadOp.getPermutationMap().isMinorIdentity())
       return failure();
-    if (transferReadOp.mask())
+    if (transferReadOp.getMask())
       return failure();
-    if (llvm::any_of(transferReadOp.indices(),
+    if (llvm::any_of(transferReadOp.getIndices(),
                      [](Value v) { return !isZero(v); }))
       return failure();
     Value c0 = rewriter.create<arith::ConstantIndexOp>(loc, 0);
     auto identityMap1D = rewriter.getMultiDimIdentityMap(1);
     VectorType vectorType1d = VectorType::get({sourceType.getNumElements()},
                                               sourceType.getElementType());
     Value source1d =
         collapseContiguousRowMajorMemRefTo1D(rewriter, loc, source);

 /// already reduced i.e. without unit dims.
 class FlattenContiguousRowMajorTransferWritePattern
     : public OpRewritePattern<vector::TransferWriteOp> {
   using OpRewritePattern<vector::TransferWriteOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferWriteOp transferWriteOp,
                                 PatternRewriter &rewriter) const override {
     auto loc = transferWriteOp.getLoc();
-    Value vector = transferWriteOp.vector();
+    Value vector = transferWriteOp.getVector();
     VectorType vectorType = vector.getType().cast<VectorType>();
-    Value source = transferWriteOp.source();
+    Value source = transferWriteOp.getSource();
     MemRefType sourceType = source.getType().dyn_cast<MemRefType>();
     // Contiguity check is valid on tensors only.
     if (!sourceType)
       return failure();
     if (vectorType.getRank() <= 1)
       // Already 0D/1D, nothing to do.
       return failure();
     if (!isStaticShapeAndContiguousRowMajor(sourceType))
       return failure();
     if (getReducedRank(sourceType.getShape()) != sourceType.getRank())
       // This pattern requires the source to already be rank-reduced.
       return failure();
     if (sourceType.getNumElements() != vectorType.getNumElements())
       return failure();
     // TODO: generalize this pattern, relax the requirements here.
     if (transferWriteOp.hasOutOfBoundsDim())
       return failure();
-    if (!transferWriteOp.permutation_map().isMinorIdentity())
+    if (!transferWriteOp.getPermutationMap().isMinorIdentity())
       return failure();
-    if (transferWriteOp.mask())
+    if (transferWriteOp.getMask())
       return failure();
-    if (llvm::any_of(transferWriteOp.indices(),
+    if (llvm::any_of(transferWriteOp.getIndices(),
                      [](Value v) { return !isZero(v); }))
       return failure();
     Value c0 = rewriter.create<arith::ConstantIndexOp>(loc, 0);
     auto identityMap1D = rewriter.getMultiDimIdentityMap(1);
     VectorType vectorType1d = VectorType::get({sourceType.getNumElements()},
                                               sourceType.getElementType());
     Value source1d =
         collapseContiguousRowMajorMemRefTo1D(rewriter, loc, source);

mlir/lib/Dialect/Vector/Transforms/VectorTransferPermutationMapRewritePatterns.cpp

struct TransferReadPermutationLowering
 
   LogicalResult matchAndRewrite(vector::TransferReadOp op,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (op.getTransferRank() == 0)
       return failure();
 
     SmallVector<unsigned> permutation;
-    AffineMap map = op.permutation_map();
+    AffineMap map = op.getPermutationMap();
     if (map.getNumResults() == 0)
       return failure();
     if (!map.isPermutationOfMinorIdentityWithBroadcasting(permutation))
       return failure();
     AffineMap permutationMap =
         map.getPermutationMap(permutation, op.getContext());
     if (permutationMap.isIdentity())
       return failure();
 
     permutationMap = map.getPermutationMap(permutation, op.getContext());
     // Caluclate the map of the new read by applying the inverse permutation.
     permutationMap = inversePermutation(permutationMap);
     AffineMap newMap = permutationMap.compose(map);
     // Apply the reverse transpose to deduce the type of the transfer_read.
     ArrayRef<int64_t> originalShape = op.getVectorType().getShape();
     SmallVector<int64_t> newVectorShape(originalShape.size());
     for (const auto &pos : llvm::enumerate(permutation)) {
       newVectorShape[pos.value()] = originalShape[pos.index()];
     }
 
     // Transpose mask operand.
     Value newMask;
-    if (op.mask()) {
+    if (op.getMask()) {
       // Remove unused dims from the permutation map. E.g.:
       // E.g.:  (d0, d1, d2, d3, d4, d5) -> (d5, 0, d3, 0, d2)
       // comp = (d0, d1, d2) -> (d2, 0, d1, 0 d0)
       auto comp = compressUnusedDims(map);
       // Get positions of remaining result dims.
       // E.g.:  (d0, d1, d2) -> (d2, 0, d1, 0 d0)
       // maskTransposeIndices = [ 2,     1,    0]
       SmallVector<int64_t> maskTransposeIndices;
       for (unsigned i = 0; i < comp.getNumResults(); ++i) {
         if (auto expr = comp.getResult(i).dyn_cast<AffineDimExpr>())
           maskTransposeIndices.push_back(expr.getPosition());
       }
 
-      newMask = rewriter.create<vector::TransposeOp>(op.getLoc(), op.mask(),
+      newMask = rewriter.create<vector::TransposeOp>(op.getLoc(), op.getMask(),
                                                      maskTransposeIndices);
     }
 
     // Transpose in_bounds attribute.
     ArrayAttr newInBoundsAttr =
-        op.in_bounds() ? transposeInBoundsAttr(
-                             rewriter, op.in_bounds().getValue(), permutation)
-                       : ArrayAttr();
+        op.getInBounds()
+            ? transposeInBoundsAttr(rewriter, op.getInBounds().getValue(),
+                                    permutation)
 
     // Generate new transfer_read operation.
     VectorType newReadType =
         VectorType::get(newVectorShape, op.getVectorType().getElementType());
     Value newRead = rewriter.create<vector::TransferReadOp>(
-        op.getLoc(), newReadType, op.source(), op.indices(),
-        AffineMapAttr::get(newMap), op.padding(), newMask, newInBoundsAttr);
+        op.getLoc(), newReadType, op.getSource(), op.getIndices(),
+        AffineMapAttr::get(newMap), op.getPadding(), newMask, newInBoundsAttr);
 
     // Transpose result of transfer_read.
     SmallVector<int64_t> transposePerm(permutation.begin(), permutation.end());
     rewriter.replaceOpWithNewOp<vector::TransposeOp>(op, newRead,
                                                      transposePerm);
     return success();
   }
 };
struct TransferWritePermutationLowering
 
   LogicalResult matchAndRewrite(vector::TransferWriteOp op,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (op.getTransferRank() == 0)
       return failure();
 
     SmallVector<unsigned> permutation;
-    AffineMap map = op.permutation_map();
+    AffineMap map = op.getPermutationMap();
     if (map.isMinorIdentity())
       return failure();
     if (!map.isPermutationOfMinorIdentityWithBroadcasting(permutation))
       return failure();
 
     // Remove unused dims from the permutation map. E.g.:
     // E.g.:  (d0, d1, d2, d3, d4, d5) -> (d5, d3, d4)
     // comp = (d0, d1, d2) -> (d2, d0, d1)
     auto comp = compressUnusedDims(map);
     // Get positions of remaining result dims.
     SmallVector<int64_t> indices;
     llvm::transform(comp.getResults(), std::back_inserter(indices),
                     [](AffineExpr expr) {
                       return expr.dyn_cast<AffineDimExpr>().getPosition();
                     });
 
     // Transpose mask operand.
-    Value newMask = op.mask() ? rewriter.create<vector::TransposeOp>(
-                                    op.getLoc(), op.mask(), indices)
+    Value newMask = op.getMask() ? rewriter.create<vector::TransposeOp>(
+                                       op.getLoc(), op.getMask(), indices)
                                  : Value();
 
     // Transpose in_bounds attribute.
     ArrayAttr newInBoundsAttr =
-        op.in_bounds() ? transposeInBoundsAttr(
-                             rewriter, op.in_bounds().getValue(), permutation)
-                       : ArrayAttr();
+        op.getInBounds()
+            ? transposeInBoundsAttr(rewriter, op.getInBounds().getValue(),
+                                    permutation)
 
     // Generate new transfer_write operation.
-    Value newVec =
-        rewriter.create<vector::TransposeOp>(op.getLoc(), op.vector(), indices);
+    Value newVec = rewriter.create<vector::TransposeOp>(
+        op.getLoc(), op.getVector(), indices);
     auto newMap = AffineMap::getMinorIdentityMap(
         map.getNumDims(), map.getNumResults(), rewriter.getContext());
     rewriter.replaceOpWithNewOp<vector::TransferWriteOp>(
-        op, newVec, op.source(), op.indices(), AffineMapAttr::get(newMap),
+        op, newVec, op.getSource(), op.getIndices(), AffineMapAttr::get(newMap),
         newMask, newInBoundsAttr);
 
     return success();
   }
 };
 
 /// Lower transfer_read op with broadcast in the leading dimensions into
 /// transfer_read of lower rank + vector.broadcast.
 /// Ex: vector.transfer_read ...
 ///         permutation_map: (d0, d1, d2, d3) -> (0, d1, 0, d3)
 /// into:
 ///     %v = vector.transfer_read ...
 ///         permutation_map: (d0, d1, d2, d3) -> (d1, 0, d3)
 ///     vector.broadcast %v
 struct TransferOpReduceRank : public OpRewritePattern<vector::TransferReadOp> {
   using OpRewritePattern<vector::TransferReadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::TransferReadOp op,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (op.getTransferRank() == 0)
       return failure();
 
-    AffineMap map = op.permutation_map();
+    AffineMap map = op.getPermutationMap();
     unsigned numLeadingBroadcast = 0;
     for (auto expr : map.getResults()) {
       auto dimExpr = expr.dyn_cast<AffineConstantExpr>();
       if (!dimExpr || dimExpr.getValue() != 0)
         break;
       numLeadingBroadcast++;
     }
     // If there are no leading zeros in the map there is nothing to do.
if (!newMap.isMinorIdentityWithBroadcasting())
       return failure();
 
     // TODO: support zero-dimension vectors natively.  See:
     // https://llvm.discourse.group/t/should-we-have-0-d-vectors/3097.
     // In the meantime, lower these to a scalar load when they pop up.
     if (reducedShapeRank == 0) {
       Value newRead;
       if (op.getShapedType().isa<TensorType>()) {
-        newRead = rewriter.create<tensor::ExtractOp>(op.getLoc(), op.source(),
-                                                     op.indices());
+        newRead = rewriter.create<tensor::ExtractOp>(
+            op.getLoc(), op.getSource(), op.getIndices());
       } else {
         newRead = rewriter.create<memref::LoadOp>(
-            op.getLoc(), originalVecType.getElementType(), op.source(),
-            op.indices());
+            op.getLoc(), originalVecType.getElementType(), op.getSource(),
+            op.getIndices());
       }
       rewriter.replaceOpWithNewOp<vector::BroadcastOp>(op, originalVecType,
                                                        newRead);
       return success();
     }
     SmallVector<int64_t> newShape = llvm::to_vector<4>(
         originalVecType.getShape().take_back(reducedShapeRank));
     // Vector rank cannot be zero. Handled by TransferReadToVectorLoadLowering.
     if (newShape.empty())
       return failure();
     VectorType newReadType =
         VectorType::get(newShape, originalVecType.getElementType());
     ArrayAttr newInBoundsAttr =
-        op.in_bounds()
+        op.getInBounds()
             ? rewriter.getArrayAttr(
-                  op.in_boundsAttr().getValue().take_back(reducedShapeRank))
+                  op.getInBoundsAttr().getValue().take_back(reducedShapeRank))
             : ArrayAttr();
     Value newRead = rewriter.create<vector::TransferReadOp>(
-        op.getLoc(), newReadType, op.source(), op.indices(),
-        AffineMapAttr::get(newMap), op.padding(), op.mask(), newInBoundsAttr);
+        op.getLoc(), newReadType, op.getSource(), op.getIndices(),
+        AffineMapAttr::get(newMap), op.getPadding(), op.getMask(),
+        newInBoundsAttr);
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(op, originalVecType,
                                                      newRead);
     return success();
   }
 };
 
 void mlir::vector::populateVectorTransferPermutationMapLoweringPatterns(
     RewritePatternSet &patterns) {
   patterns.add<TransferReadPermutationLowering,
                TransferWritePermutationLowering, TransferOpReduceRank>(
       patterns.getContext());
 }

mlir/lib/Dialect/Vector/Transforms/VectorTransferSplitRewritePatterns.cpp

 /// ```
 /// Return the produced scf::IfOp.
 static scf::IfOp
 createFullPartialLinalgCopy(RewriterBase &b, vector::TransferReadOp xferOp,
                             TypeRange returnTypes, Value inBoundsCond,
                             MemRefType compatibleMemRefType, Value alloc) {
   Location loc = xferOp.getLoc();
   Value zero = b.create<arith::ConstantIndexOp>(loc, 0);
-  Value memref = xferOp.source();
+  Value memref = xferOp.getSource();
   return b.create<scf::IfOp>(
       loc, returnTypes, inBoundsCond,
       [&](OpBuilder &b, Location loc) {
         Value res = memref;
         if (compatibleMemRefType != xferOp.getShapedType())
           res = b.create<memref::CastOp>(loc, compatibleMemRefType, memref);
         scf::ValueVector viewAndIndices{res};
-        viewAndIndices.insert(viewAndIndices.end(), xferOp.indices().begin(),
-                              xferOp.indices().end());
+        viewAndIndices.insert(viewAndIndices.end(), xferOp.getIndices().begin(),
+                              xferOp.getIndices().end());
         b.create<scf::YieldOp>(loc, viewAndIndices);
       },
       [&](OpBuilder &b, Location loc) {
-        b.create<linalg::FillOp>(loc, ValueRange{xferOp.padding()},
+        b.create<linalg::FillOp>(loc, ValueRange{xferOp.getPadding()},
                                  ValueRange{alloc});
         // Take partial subview of memref which guarantees no dimension
         // overflows.
         IRRewriter rewriter(b);
         std::pair<Value, Value> copyArgs = createSubViewIntersection(
             rewriter, cast<VectorTransferOpInterface>(xferOp.getOperation()),
             alloc);
         b.create<memref::CopyOp>(loc, copyArgs.first, copyArgs.second);

 /// ```
 /// Return the produced scf::IfOp.
 static scf::IfOp createFullPartialVectorTransferRead(
     RewriterBase &b, vector::TransferReadOp xferOp, TypeRange returnTypes,
     Value inBoundsCond, MemRefType compatibleMemRefType, Value alloc) {
   Location loc = xferOp.getLoc();
   scf::IfOp fullPartialIfOp;
   Value zero = b.create<arith::ConstantIndexOp>(loc, 0);
-  Value memref = xferOp.source();
+  Value memref = xferOp.getSource();
   return b.create<scf::IfOp>(
       loc, returnTypes, inBoundsCond,
       [&](OpBuilder &b, Location loc) {
         Value res = memref;
         if (compatibleMemRefType != xferOp.getShapedType())
           res = b.create<memref::CastOp>(loc, compatibleMemRefType, memref);
         scf::ValueVector viewAndIndices{res};
-        viewAndIndices.insert(viewAndIndices.end(), xferOp.indices().begin(),
-                              xferOp.indices().end());
+        viewAndIndices.insert(viewAndIndices.end(), xferOp.getIndices().begin(),
+                              xferOp.getIndices().end());
         b.create<scf::YieldOp>(loc, viewAndIndices);
       },
       [&](OpBuilder &b, Location loc) {
         Operation *newXfer = b.clone(*xferOp.getOperation());
         Value vector = cast<VectorTransferOpInterface>(newXfer).vector();
         b.create<memref::StoreOp>(
             loc, vector,
             b.create<vector::TypeCastOp>(

 ///   }
 /// ```
 static ValueRange
 getLocationToWriteFullVec(RewriterBase &b, vector::TransferWriteOp xferOp,
                           TypeRange returnTypes, Value inBoundsCond,
                           MemRefType compatibleMemRefType, Value alloc) {
   Location loc = xferOp.getLoc();
   Value zero = b.create<arith::ConstantIndexOp>(loc, 0);
-  Value memref = xferOp.source();
+  Value memref = xferOp.getSource();
   return b
       .create<scf::IfOp>(
           loc, returnTypes, inBoundsCond,
           [&](OpBuilder &b, Location loc) {
             Value res = memref;
             if (compatibleMemRefType != xferOp.getShapedType())
               res = b.create<memref::CastOp>(loc, compatibleMemRefType, memref);
             scf::ValueVector viewAndIndices{res};
             viewAndIndices.insert(viewAndIndices.end(),
-                                  xferOp.indices().begin(),
-                                  xferOp.indices().end());
+                                  xferOp.getIndices().begin(),
+                                  xferOp.getIndices().end());
             b.create<scf::YieldOp>(loc, viewAndIndices);
           },
           [&](OpBuilder &b, Location loc) {
             Value casted =
                 b.create<memref::CastOp>(loc, compatibleMemRefType, alloc);
             scf::ValueVector viewAndIndices{casted};
             viewAndIndices.insert(viewAndIndices.end(),
                                   xferOp.getTransferRank(), zero);
static void createFullPartialVectorTransferWrite(RewriterBase &b,
                                                  Value inBoundsCond,
                                                  Value alloc) {
   Location loc = xferOp.getLoc();
   auto notInBounds = b.create<arith::XOrIOp>(
       loc, inBoundsCond, b.create<arith::ConstantIntOp>(loc, true, 1));
   b.create<scf::IfOp>(loc, notInBounds, [&](OpBuilder &b, Location loc) {
     BlockAndValueMapping mapping;
     Value load = b.create<memref::LoadOp>(
-        loc, b.create<vector::TypeCastOp>(
-                 loc, MemRefType::get({}, xferOp.vector().getType()), alloc));
-    mapping.map(xferOp.vector(), load);
+        loc,
+        b.create<vector::TypeCastOp>(
+            loc, MemRefType::get({}, xferOp.getVector().getType()), alloc));
+    mapping.map(xferOp.getVector(), load);
     b.clone(*xferOp.getOperation(), mapping);
     b.create<scf::YieldOp>(loc, ValueRange{});
   });
 }
 
 // TODO: Parallelism and threadlocal considerations with a ParallelScope trait.
 static Operation *getAutomaticAllocationScope(Operation *op) {
   Operation *scope =
// ensure they aren't used in the wrong scopes further down.
     assert(succeeded(splitFullAndPartialTransferPrecondition(xferOp)) &&
            "Expected splitFullAndPartialTransferPrecondition to hold");
 
     auto xferReadOp = dyn_cast<vector::TransferReadOp>(xferOp.getOperation());
     auto xferWriteOp = dyn_cast<vector::TransferWriteOp>(xferOp.getOperation());
 
     if (!(xferReadOp || xferWriteOp))
       return failure();
-    if (xferWriteOp && xferWriteOp.mask())
+    if (xferWriteOp && xferWriteOp.getMask())
       return failure();
-    if (xferReadOp && xferReadOp.mask())
+    if (xferReadOp && xferReadOp.getMask())
       return failure();
   }
 
   RewriterBase::InsertionGuard guard(b);
   b.setInsertionPoint(xferOp);
   Value inBoundsCond = createInBoundsCond(
       b, cast<VectorTransferOpInterface>(xferOp.getOperation()));
   if (!inBoundsCond)
LogicalResult mlir::vector::splitFullAndPartialTransfer(
   // Decide which location to write the entire vector to.
   auto memrefAndIndices = getLocationToWriteFullVec(
       b, xferWriteOp, returnTypes, inBoundsCond, compatibleMemRefType, alloc);
 
   // Do an in bounds write to either the output or the extra allocated buffer.
   // The operation is cloned to prevent deleting information needed for the
   // later IR creation.
   BlockAndValueMapping mapping;
-  mapping.map(xferWriteOp.source(), memrefAndIndices.front());
-  mapping.map(xferWriteOp.indices(), memrefAndIndices.drop_front());
+  mapping.map(xferWriteOp.getSource(), memrefAndIndices.front());
+  mapping.map(xferWriteOp.getIndices(), memrefAndIndices.drop_front());
   auto *clone = b.clone(*xferWriteOp, mapping);
   clone->setAttr(xferWriteOp.getInBoundsAttrName(), inBoundsAttr);
 
   // Create a potential copy from the allocated buffer to the final output in
   // the slow path case.
   if (options.vectorTransferSplit == VectorTransferSplit::VectorTransfer)
     createFullPartialVectorTransferWrite(b, xferWriteOp, inBoundsCond, alloc);
   else

mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp

 //
 struct ShapeCastOpFolder : public OpRewritePattern<vector::ShapeCastOp> {
   using OpRewritePattern<vector::ShapeCastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ShapeCastOp shapeCastOp,
                                 PatternRewriter &rewriter) const override {
     // Check if 'shapeCastOp' has vector source/result type.
     auto sourceVectorType =
-        shapeCastOp.source().getType().dyn_cast_or_null<VectorType>();
+        shapeCastOp.getSource().getType().dyn_cast_or_null<VectorType>();
     auto resultVectorType =
-        shapeCastOp.result().getType().dyn_cast_or_null<VectorType>();
+        shapeCastOp.getResult().getType().dyn_cast_or_null<VectorType>();
     if (!sourceVectorType || !resultVectorType)
       return failure();
 
     // Check if shape cast op source operand is also a shape cast op.
     auto sourceShapeCastOp = dyn_cast_or_null<vector::ShapeCastOp>(
-        shapeCastOp.source().getDefiningOp());
+        shapeCastOp.getSource().getDefiningOp());
     if (!sourceShapeCastOp)
       return failure();
     auto operandSourceVectorType =
-        sourceShapeCastOp.source().getType().cast<VectorType>();
+        sourceShapeCastOp.getSource().getType().cast<VectorType>();
     auto operandResultVectorType = sourceShapeCastOp.getType();
 
     // Check if shape cast operations invert each other.
     if (operandSourceVectorType != resultVectorType ||
         operandResultVectorType != sourceVectorType)
       return failure();
 
-    rewriter.replaceOp(shapeCastOp, sourceShapeCastOp.source());
+    rewriter.replaceOp(shapeCastOp, sourceShapeCastOp.getSource());
     return success();
   }
 };
 
 /// Progressive lowering of BroadcastOp.
 class BroadcastOpLowering : public OpRewritePattern<vector::BroadcastOp> {
 public:
   using OpRewritePattern<vector::BroadcastOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::BroadcastOp op,
                                 PatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
     VectorType dstType = op.getVectorType();
     VectorType srcType = op.getSourceType().dyn_cast<VectorType>();
     Type eltType = dstType.getElementType();
 
     // Scalar to any vector can use splat.
     if (!srcType) {
-      rewriter.replaceOpWithNewOp<vector::SplatOp>(op, dstType, op.source());
+      rewriter.replaceOpWithNewOp<vector::SplatOp>(op, dstType, op.getSource());
       return success();
     }
 
     // Determine rank of source and destination.
     int64_t srcRank = srcType.getRank();
     int64_t dstRank = dstType.getRank();
 
     // Stretching scalar inside vector (e.g. vector<1xf32>) can use splat.
     if (srcRank <= 1 && dstRank == 1) {
       Value ext;
       if (srcRank == 0)
-        ext = rewriter.create<vector::ExtractElementOp>(loc, op.source());
+        ext = rewriter.create<vector::ExtractElementOp>(loc, op.getSource());
       else
-        ext = rewriter.create<vector::ExtractOp>(loc, op.source(), 0);
+        ext = rewriter.create<vector::ExtractOp>(loc, op.getSource(), 0);
       rewriter.replaceOpWithNewOp<vector::SplatOp>(op, dstType, ext);
       return success();
     }
 
     // Duplicate this rank.
     // For example:
     //   %x = broadcast %y  : k-D to n-D, k < n
     // becomes:
     //   %b = broadcast %y  : k-D to (n-1)-D
     //   %x = [%b,%b,%b,%b] : n-D
     // becomes:
     //   %b = [%y,%y]       : (n-1)-D
     //   %x = [%b,%b,%b,%b] : n-D
     if (srcRank < dstRank) {
       // Duplication.
       VectorType resType =
           VectorType::get(dstType.getShape().drop_front(), eltType);
       Value bcst =
-          rewriter.create<vector::BroadcastOp>(loc, resType, op.source());
+          rewriter.create<vector::BroadcastOp>(loc, resType, op.getSource());
       Value result = rewriter.create<arith::ConstantOp>(
           loc, dstType, rewriter.getZeroAttr(dstType));
       for (int64_t d = 0, dim = dstType.getDimSize(0); d < dim; ++d)
         result = rewriter.create<vector::InsertOp>(loc, bcst, result, d);
       rewriter.replaceOp(op, result);
       return success();
     }
 
     // Find non-matching dimension, if any.
     assert(srcRank == dstRank);
     int64_t m = -1;
     for (int64_t r = 0; r < dstRank; r++)
       if (srcType.getDimSize(r) != dstType.getDimSize(r)) {
         m = r;
         break;
       }
 
     // All trailing dimensions are the same. Simply pass through.
     if (m == -1) {
-      rewriter.replaceOp(op, op.source());
+      rewriter.replaceOp(op, op.getSource());
       return success();
     }
 
     // Any non-matching dimension forces a stretch along this rank.
     // For example:
     //   %x = broadcast %y : vector<4x1x2xf32> to vector<4x2x2xf32>
     // becomes:
     //   %a = broadcast %y[0] : vector<1x2xf32> to vector<2x2xf32>
     //   %b = broadcast %y[1] : vector<1x2xf32> to vector<2x2xf32>
     //   %c = broadcast %y[2] : vector<1x2xf32> to vector<2x2xf32>
     //   %d = broadcast %y[3] : vector<1x2xf32> to vector<2x2xf32>
     //   %x = [%a,%b,%c,%d]
     // becomes:
     //   %u = broadcast %y[0][0] : vector<2xf32> to vector <2x2xf32>
     //   %v = broadcast %y[1][0] : vector<2xf32> to vector <2x2xf32>
     //   %a = [%u, %v]
     //   ..
     //   %x = [%a,%b,%c,%d]
     VectorType resType =
         VectorType::get(dstType.getShape().drop_front(), eltType);
     Value result = rewriter.create<arith::ConstantOp>(
         loc, dstType, rewriter.getZeroAttr(dstType));
     if (m == 0) {
       // Stetch at start.
-      Value ext = rewriter.create<vector::ExtractOp>(loc, op.source(), 0);
+      Value ext = rewriter.create<vector::ExtractOp>(loc, op.getSource(), 0);
       Value bcst = rewriter.create<vector::BroadcastOp>(loc, resType, ext);
       for (int64_t d = 0, dim = dstType.getDimSize(0); d < dim; ++d)
         result = rewriter.create<vector::InsertOp>(loc, bcst, result, d);
     } else {
       // Stetch not at start.
       for (int64_t d = 0, dim = dstType.getDimSize(0); d < dim; ++d) {
-        Value ext = rewriter.create<vector::ExtractOp>(loc, op.source(), d);
+        Value ext = rewriter.create<vector::ExtractOp>(loc, op.getSource(), d);
         Value bcst = rewriter.create<vector::BroadcastOp>(loc, resType, ext);
         result = rewriter.create<vector::InsertOp>(loc, bcst, result, d);
       }
     }
     rewriter.replaceOp(op, result);
     return success();
   }
 };
TransposeOpLowering(vector::VectorTransformsOptions vectorTransformOptions,
                       MLIRContext *context)
       : OpRewritePattern<vector::TransposeOp>(context),
         vectorTransformOptions(vectorTransformOptions) {}
 
   LogicalResult matchAndRewrite(vector::TransposeOp op,
                                 PatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
 
-    Value input = op.vector();
+    Value input = op.getVector();
     VectorType inputType = op.getVectorType();
     VectorType resType = op.getResultType();
 
     // Set up convenience transposition table.
     SmallVector<int64_t, 4> transp;
-    for (auto attr : op.transp())
+    for (auto attr : op.getTransp())
       transp.push_back(attr.cast<IntegerAttr>().getInt());
 
     if (vectorTransformOptions.vectorTransposeLowering ==
             vector::VectorTransposeLowering::Shuffle &&
         resType.getRank() == 2 && transp[0] == 1 && transp[1] == 0)
       return rewriter.notifyMatchFailure(
           op, "Options specifies lowering to shuffle");
 
LogicalResult matchAndRewrite(vector::TransposeOp op,
                                 PatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
 
     VectorType srcType = op.getVectorType();
     if (srcType.getRank() != 2)
       return rewriter.notifyMatchFailure(op, "Not a 2D transpose");
 
     SmallVector<int64_t, 4> transp;
-    for (auto attr : op.transp())
+    for (auto attr : op.getTransp())
       transp.push_back(attr.cast<IntegerAttr>().getInt());
     if (transp[0] != 1 && transp[1] != 0)
       return rewriter.notifyMatchFailure(op, "Not a 2D transpose permutation");
 
     if (vectorTransformOptions.vectorTransposeLowering !=
         VectorTransposeLowering::Shuffle)
       return rewriter.notifyMatchFailure(op, "Options do not ask for Shuffle");
 
     int64_t m = srcType.getShape().front(), n = srcType.getShape().back();
     Value casted = rewriter.create<vector::ShapeCastOp>(
-        loc, VectorType::get({m * n}, srcType.getElementType()), op.vector());
+        loc, VectorType::get({m * n}, srcType.getElementType()),
+        op.getVector());
     SmallVector<int64_t> mask;
     mask.reserve(m * n);
     for (int64_t j = 0; j < n; ++j)
       for (int64_t i = 0; i < m; ++i)
         mask.push_back(i * n + j);
 
     Value shuffled =
         rewriter.create<vector::ShuffleOp>(loc, casted, casted, mask);
LogicalResult matchAndRewrite(vector::OuterProductOp op,
                                 PatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
 
     VectorType lhsType = op.getOperandVectorTypeLHS();
     VectorType rhsType = op.getOperandTypeRHS().dyn_cast<VectorType>();
     VectorType resType = op.getVectorType();
     Type eltType = resType.getElementType();
     bool isInt = eltType.isa<IntegerType, IndexType>();
-    Value acc = (op.acc().empty()) ? nullptr : op.acc()[0];
-    vector::CombiningKind kind = op.kind();
+    Value acc = (op.getAcc().empty()) ? nullptr : op.getAcc()[0];
+    vector::CombiningKind kind = op.getKind();
 
     if (!rhsType) {
       // Special case: AXPY operation.
-      Value b = rewriter.create<vector::BroadcastOp>(loc, lhsType, op.rhs());
+      Value b = rewriter.create<vector::BroadcastOp>(loc, lhsType, op.getRhs());
       Optional<Value> mult =
-          isInt ? genMultI(loc, op.lhs(), b, acc, kind, rewriter)
-                : genMultF(loc, op.lhs(), b, acc, kind, rewriter);
+          isInt ? genMultI(loc, op.getLhs(), b, acc, kind, rewriter)
+                : genMultF(loc, op.getLhs(), b, acc, kind, rewriter);
       if (!mult.hasValue())
         return failure();
       rewriter.replaceOp(op, mult.getValue());
       return success();
     }
 
     Value result = rewriter.create<arith::ConstantOp>(
         loc, resType, rewriter.getZeroAttr(resType));
     for (int64_t d = 0, e = resType.getDimSize(0); d < e; ++d) {
       auto pos = rewriter.getI64ArrayAttr(d);
-      Value x = rewriter.create<vector::ExtractOp>(loc, eltType, op.lhs(), pos);
+      Value x =
+          rewriter.create<vector::ExtractOp>(loc, eltType, op.getLhs(), pos);
       Value a = rewriter.create<vector::BroadcastOp>(loc, rhsType, x);
       Value r = nullptr;
       if (acc)
         r = rewriter.create<vector::ExtractOp>(loc, rhsType, acc, pos);
-      Optional<Value> m = isInt ? genMultI(loc, a, op.rhs(), r, kind, rewriter)
-                                : genMultF(loc, a, op.rhs(), r, kind, rewriter);
+      Optional<Value> m =
+          isInt ? genMultI(loc, a, op.getRhs(), r, kind, rewriter)
+                : genMultF(loc, a, op.getRhs(), r, kind, rewriter);
       if (!m.hasValue())
         return failure();
       result = rewriter.create<vector::InsertOp>(loc, resType, m.getValue(),
                                                  result, pos);
     }
     rewriter.replaceOp(op, result);
     return success();
   }

 public:
   using OpRewritePattern<vector::ConstantMaskOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ConstantMaskOp op,
                                 PatternRewriter &rewriter) const override {
     auto loc = op.getLoc();
     auto dstType = op.getType();
     auto eltType = dstType.getElementType();
-    auto dimSizes = op.mask_dim_sizes();
+    auto dimSizes = op.getMaskDimSizes();
     int64_t rank = dstType.getRank();
 
     if (rank == 0) {
       assert(dimSizes.size() == 1 &&
              "Expected exactly one dim size for a 0-D vector");
       bool value = dimSizes[0].cast<IntegerAttr>().getInt() == 1;
       rewriter.replaceOpWithNewOp<arith::ConstantOp>(
           op, dstType,
LogicalResult matchAndRewrite(vector::ShapeCastOp op,
     if (sourceVectorType.getRank() != 2 || resultVectorType.getRank() != 1)
       return failure();
 
     auto loc = op.getLoc();
     Value desc = rewriter.create<arith::ConstantOp>(
         loc, resultVectorType, rewriter.getZeroAttr(resultVectorType));
     unsigned mostMinorVectorSize = sourceVectorType.getShape()[1];
     for (int64_t i = 0, e = sourceVectorType.getShape().front(); i != e; ++i) {
-      Value vec = rewriter.create<vector::ExtractOp>(loc, op.source(), i);
+      Value vec = rewriter.create<vector::ExtractOp>(loc, op.getSource(), i);
       desc = rewriter.create<vector::InsertStridedSliceOp>(
           loc, vec, desc,
           /*offsets=*/i * mostMinorVectorSize, /*strides=*/1);
     }
     rewriter.replaceOp(op, desc);
     return success();
   }
 };
if (sourceVectorType.getRank() != 1 || resultVectorType.getRank() != 2)
       return failure();
 
     auto loc = op.getLoc();
     Value desc = rewriter.create<arith::ConstantOp>(
         loc, resultVectorType, rewriter.getZeroAttr(resultVectorType));
     unsigned mostMinorVectorSize = resultVectorType.getShape()[1];
     for (int64_t i = 0, e = resultVectorType.getShape().front(); i != e; ++i) {
       Value vec = rewriter.create<vector::ExtractStridedSliceOp>(
-          loc, op.source(), /*offsets=*/i * mostMinorVectorSize,
+          loc, op.getSource(), /*offsets=*/i * mostMinorVectorSize,
           /*sizes=*/mostMinorVectorSize,
           /*strides=*/1);
       desc = rewriter.create<vector::InsertOp>(loc, vec, desc, i);
     }
     rewriter.replaceOp(op, desc);
     return success();
   }
 };
LogicalResult matchAndRewrite(vector::ShapeCastOp op,
     SmallVector<int64_t, 4> resIdx(resRank);
     Value result = rewriter.create<arith::ConstantOp>(
         loc, resultVectorType, rewriter.getZeroAttr(resultVectorType));
     for (int64_t i = 0; i < numElts; i++) {
       if (i != 0) {
         incIdx(srcIdx, sourceVectorType, srcRank - 1);
         incIdx(resIdx, resultVectorType, resRank - 1);
       }
-      Value e = rewriter.create<vector::ExtractOp>(loc, op.source(), srcIdx);
+      Value e = rewriter.create<vector::ExtractOp>(loc, op.getSource(), srcIdx);
       result = rewriter.create<vector::InsertOp>(loc, e, result, resIdx);
     }
     rewriter.replaceOp(op, result);
     return success();
   }
 
 private:
   static void incIdx(SmallVector<int64_t, 4> &idx, VectorType tp, int64_t r) {

 ///    : vector<8x32x16xf32>, vector<8x32x16xf32> into vector<8x32xf32>
 ///  ```
 struct MultiReduceToContract
     : public OpRewritePattern<vector::MultiDimReductionOp> {
   using OpRewritePattern<vector::MultiDimReductionOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::MultiDimReductionOp reduceOp,
                                 PatternRewriter &rewriter) const override {
-    if (reduceOp.kind() != vector::CombiningKind::ADD)
+    if (reduceOp.getKind() != vector::CombiningKind::ADD)
       return failure();
-    Operation *mulOp = reduceOp.source().getDefiningOp();
+    Operation *mulOp = reduceOp.getSource().getDefiningOp();
     if (!mulOp || !isa<arith::MulIOp, arith::MulFOp>(mulOp))
       return failure();
     SmallVector<bool> reductionMask = reduceOp.getReductionMask();
     auto srcMap = rewriter.getMultiDimIdentityMap(reductionMask.size());
     SmallVector<AffineExpr> exprs;
     SmallVector<StringRef> iteratorTypes;
     for (const auto &isReduceDim : llvm::enumerate(reductionMask)) {
       if (!isReduceDim.value()) {

 struct CombineContractTranspose
     : public OpRewritePattern<vector::ContractionOp> {
   using OpRewritePattern<vector::ContractionOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
                                 PatternRewriter &rewriter) const override {
     SmallVector<AffineMap, 4> maps =
         llvm::to_vector<4>(contractOp.getIndexingMaps());
-    Value lhs = contractOp.lhs();
-    Value rhs = contractOp.rhs();
+    Value lhs = contractOp.getLhs();
+    Value rhs = contractOp.getRhs();
     size_t index = 0;
     bool changed = false;
     for (Value *operand : {&lhs, &rhs}) {
       AffineMap &map = maps[index++];
       auto transposeOp = operand->getDefiningOp<vector::TransposeOp>();
       if (!transposeOp)
         continue;
       SmallVector<int64_t> perm;
       transposeOp.getTransp(perm);
       AffineMap permutationMap = AffineMap::getPermutationMap(
-          extractVector<unsigned>(transposeOp.transp()),
+          extractVector<unsigned>(transposeOp.getTransp()),
           contractOp.getContext());
       map = inversePermutation(permutationMap).compose(map);
-      *operand = transposeOp.vector();
+      *operand = transposeOp.getVector();
       changed = true;
     }
     if (!changed)
       return failure();
     rewriter.replaceOpWithNewOp<vector::ContractionOp>(
-        contractOp, lhs, rhs, contractOp.acc(),
-        rewriter.getAffineMapArrayAttr(maps), contractOp.iterator_types());
+        contractOp, lhs, rhs, contractOp.getAcc(),
+        rewriter.getAffineMapArrayAttr(maps), contractOp.getIteratorTypes());
     return success();
   }
 };
 
 /// Merge BroadcastOp into ContractionOp user.
 /// Ex:
 /// ```
 ///   %0 = vector.broadcast %arg0 : vector<32x16xf32> to vector<8x32x16xf32>

 struct CombineContractBroadcast
     : public OpRewritePattern<vector::ContractionOp> {
   using OpRewritePattern<vector::ContractionOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ContractionOp contractOp,
                                 PatternRewriter &rewriter) const override {
     SmallVector<AffineMap, 4> maps =
         llvm::to_vector<4>(contractOp.getIndexingMaps());
-    Value lhs = contractOp.lhs();
-    Value rhs = contractOp.rhs();
+    Value lhs = contractOp.getLhs();
+    Value rhs = contractOp.getRhs();
     size_t index = 0;
     bool changed = false;
     for (Value *operand : {&lhs, &rhs}) {
       AffineMap &map = maps[index++];
       auto broadcast = operand->getDefiningOp<vector::BroadcastOp>();
       if (!broadcast)
         continue;
       // contractionOp can only take vector as operands.
for (Value *operand : {&lhs, &rhs}) {
       // Contract doesn't support inner dimension broadcast. Once this is
       // relaxed we can remove this case.
       if (innerDimBroadcast)
         continue;
       AffineMap broadcastMap =
           AffineMap::get(broadcast.getVectorType().getRank(), 0, originalDims,
                          contractOp.getContext());
       map = broadcastMap.compose(map);
-      *operand = broadcast.source();
+      *operand = broadcast.getSource();
       changed = true;
     }
     if (!changed)
       return failure();
     rewriter.replaceOpWithNewOp<vector::ContractionOp>(
-        contractOp, lhs, rhs, contractOp.acc(),
-        rewriter.getAffineMapArrayAttr(maps), contractOp.iterator_types());
+        contractOp, lhs, rhs, contractOp.getAcc(),
+        rewriter.getAffineMapArrayAttr(maps), contractOp.getIteratorTypes());
     return success();
   }
 };
 
 /// Reorders cast(broadcast) to broadcast(cast). This makes broadcast ops and
 /// contraction ops closer, which kicks in CombineContractBroadcast pattern when
 /// casting ops are around these operations.
 /// Ex:
if (op->getNumOperands() != 1)
       return failure();
     auto bcastOp = op->getOperand(0).getDefiningOp<vector::BroadcastOp>();
     if (!bcastOp)
       return failure();
 
     Type castResTy = getElementTypeOrSelf(op->getResult(0));
     if (auto vecTy = bcastOp.getSourceType().dyn_cast<VectorType>())
       castResTy = VectorType::get(vecTy.getShape(), castResTy);
-    auto castOp = rewriter.create(op->getLoc(), op->getName().getIdentifier(),
-                                  bcastOp.source(), castResTy, op->getAttrs());
+    auto castOp =
+        rewriter.create(op->getLoc(), op->getName().getIdentifier(),
+                        bcastOp.getSource(), castResTy, op->getAttrs());
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(
         op, op->getResult(0).getType(), castOp->getResult(0));
     return success();
   }
 };
 
 /// Reorders cast(transpose) to transpose(cast). This makes broadcast ops and
 /// contraction ops closer, which kicks in CombineContractTranspose pattern when
if (op->getNumOperands() != 1)
       return failure();
     auto transpOp = op->getOperand(0).getDefiningOp<vector::TransposeOp>();
     if (!transpOp)
       return failure();
 
     auto castResTy = transpOp.getVectorType();
     castResTy = VectorType::get(castResTy.getShape(),
                                 getElementTypeOrSelf(op->getResult(0)));
-    auto castOp = rewriter.create(op->getLoc(), op->getName().getIdentifier(),
-                                  transpOp.vector(), castResTy, op->getAttrs());
+    auto castOp =
+        rewriter.create(op->getLoc(), op->getName().getIdentifier(),
+                        transpOp.getVector(), castResTy, op->getAttrs());
     rewriter.replaceOpWithNewOp<vector::TransposeOp>(
         op, op->getResult(0).getType(), castOp->getResult(0),
         transpOp.getTransp());
     return success();
   }
 };
 
 } // namespace

 //
 /// This only kicks in when VectorTransformsOptions is set to `Matmul`.
 /// vector.transpose operations are inserted if the vector.contract op is not a
 /// row-major matrix multiply.
 LogicalResult
 ContractionOpToMatmulOpLowering::matchAndRewrite(vector::ContractionOp op,
                                                  PatternRewriter &rew) const {
   // TODO: implement masks
-  if (llvm::size(op.masks()) != 0)
+  if (llvm::size(op.getMasks()) != 0)
     return failure();
   if (vectorTransformOptions.vectorContractLowering !=
       vector::VectorContractLowering::Matmul)
     return failure();
   if (failed(filter(op)))
     return failure();
 
-  auto iteratorTypes = op.iterator_types().getValue();
+  auto iteratorTypes = op.getIteratorTypes().getValue();
   if (!isParallelIterator(iteratorTypes[0]) ||
       !isParallelIterator(iteratorTypes[1]) ||
       !isReductionIterator(iteratorTypes[2]))
     return failure();
 
   Type elementType = op.getLhsType().getElementType();
   if (!elementType.isIntOrFloat())
     return failure();
 
   // Perform lhs + rhs transpositions to conform to matmul row-major semantics.
   // Bail out if the contraction cannot be put in this form.
   MLIRContext *ctx = op.getContext();
   Location loc = op.getLoc();
   AffineExpr m, n, k;
   bindDims(rew.getContext(), m, n, k);
   // LHS must be A(m, k) or A(k, m).
-  Value lhs = op.lhs();
-  auto lhsMap = op.indexing_maps()[0];
+  Value lhs = op.getLhs();
+  auto lhsMap = op.getIndexingMaps()[0];
   if (lhsMap == AffineMap::get(3, 0, {k, m}, ctx))
     lhs = rew.create<vector::TransposeOp>(loc, lhs, ArrayRef<int64_t>{1, 0});
   else if (lhsMap != AffineMap::get(3, 0, {m, k}, ctx))
     return failure();
 
   // RHS must be B(k, n) or B(n, k).
-  Value rhs = op.rhs();
-  auto rhsMap = op.indexing_maps()[1];
+  Value rhs = op.getRhs();
+  auto rhsMap = op.getIndexingMaps()[1];
   if (rhsMap == AffineMap::get(3, 0, {n, k}, ctx))
     rhs = rew.create<vector::TransposeOp>(loc, rhs, ArrayRef<int64_t>{1, 0});
   else if (rhsMap != AffineMap::get(3, 0, {k, n}, ctx))
     return failure();
 
   // At this point lhs and rhs are in row-major.
   VectorType lhsType = lhs.getType().cast<VectorType>();
   VectorType rhsType = rhs.getType().cast<VectorType>();
Type flattenedRHSType =
       VectorType::get(rhsType.getNumElements(), rhsType.getElementType());
   rhs = rew.create<vector::ShapeCastOp>(loc, flattenedRHSType, rhs);
 
   Value mul = rew.create<vector::MatmulOp>(loc, lhs, rhs, lhsRows, lhsColumns,
                                            rhsColumns);
   mul = rew.create<vector::ShapeCastOp>(
       loc,
       VectorType::get({lhsRows, rhsColumns},
-                      getElementTypeOrSelf(op.acc().getType())),
+                      getElementTypeOrSelf(op.getAcc().getType())),
       mul);
 
   // ACC must be C(m, n) or C(n, m).
-  auto accMap = op.indexing_maps()[2];
+  auto accMap = op.getIndexingMaps()[2];
   if (accMap == AffineMap::get(3, 0, {n, m}, ctx))
     mul = rew.create<vector::TransposeOp>(loc, mul, ArrayRef<int64_t>{1, 0});
   else if (accMap != AffineMap::get(3, 0, {m, n}, ctx))
     llvm_unreachable("invalid contraction semantics");
 
   Value res =
       elementType.isa<IntegerType>()
-          ? static_cast<Value>(rew.create<arith::AddIOp>(loc, op.acc(), mul))
-          : static_cast<Value>(rew.create<arith::AddFOp>(loc, op.acc(), mul));
+          ? static_cast<Value>(rew.create<arith::AddIOp>(loc, op.getAcc(), mul))
+          : static_cast<Value>(
+                rew.create<arith::AddFOp>(loc, op.getAcc(), mul));
 
   rew.replaceOp(op, res);
   return success();
 }
 
 namespace {
 struct IteratorType {
   IteratorType(StringRef strRef) : strRef(strRef) {}

 struct Red : public IteratorType {
   Red() : IteratorType(getReductionIteratorTypeName()) {}
 };
 
 /// Generate a vector implementation for matmat, matvec and tmatvec.
 /// This unrolls outer-products along the reduction dimension.
 struct UnrolledOuterProductGenerator
     : public StructuredGenerator<vector::ContractionOp> {
-
   UnrolledOuterProductGenerator(OpBuilder &builder, vector::ContractionOp op)
       : StructuredGenerator<vector::ContractionOp>(builder, op),
-        kind(op.kind()), lhs(op.lhs()), rhs(op.rhs()), res(op.acc()),
-        lhsType(op.getLhsType()) {}
+        kind(op.getKind()), lhs(op.getLhs()), rhs(op.getRhs()),
+        res(op.getAcc()), lhsType(op.getLhsType()) {}
 
   Value t(Value v) {
     static constexpr std::array<int64_t, 2> perm = {1, 0};
     return builder.create<vector::TransposeOp>(loc, v, perm);
   }
 
   Value outerProd(Value lhs, Value rhs, Value res, int reductionSize) {
     assert(reductionSize > 0);

 ///    %cK = vector.outerproduct %atRowK, %bRowK, %cK-1
 /// ```
 ///
 /// This only kicks in when VectorTransformsOptions is set to OuterProduct but
 /// otherwise supports any layout permutation of the matrix-multiply.
 LogicalResult ContractionOpToOuterProductOpLowering::matchAndRewrite(
     vector::ContractionOp op, PatternRewriter &rewriter) const {
   // TODO: implement masks
-  if (llvm::size(op.masks()) != 0)
+  if (llvm::size(op.getMasks()) != 0)
     return failure();
 
   if (vectorTransformOptions.vectorContractLowering !=
       vector::VectorContractLowering::OuterProduct)
     return failure();
 
   if (failed(filter(op)))
     return failure();
LogicalResult ContractionOpToOuterProductOpLowering::matchAndRewrite(
 
   return failure();
 }
 
 LogicalResult
 ContractionOpToDotLowering::matchAndRewrite(vector::ContractionOp op,
                                             PatternRewriter &rewriter) const {
   // TODO: implement masks
-  if (llvm::size(op.masks()) != 0)
+  if (llvm::size(op.getMasks()) != 0)
     return failure();
 
   if (failed(filter(op)))
     return failure();
 
   if (vectorTransformOptions.vectorContractLowering !=
       vector::VectorContractLowering::Dot)
     return failure();
 
-  auto iteratorTypes = op.iterator_types().getValue();
+  auto iteratorTypes = op.getIteratorTypes().getValue();
   static constexpr std::array<int64_t, 2> perm = {1, 0};
   Location loc = op.getLoc();
-  Value lhs = op.lhs(), rhs = op.rhs();
+  Value lhs = op.getLhs(), rhs = op.getRhs();
 
   using MapList = ArrayRef<ArrayRef<AffineExpr>>;
   auto infer = [](MapList m) { return AffineMap::inferFromExprList(m); };
   AffineExpr m, n, k;
   bindDims(rewriter.getContext(), m, n, k);
   SmallVector<AffineMap, 4> maps = op.getIndexingMaps();
   //
   // In the following we wish to make the reduction dimension innermost so we
for (unsigned c = 0; c < dstColumns; ++c) {
       Value reduced = rewriter.create<vector::ReductionOp>(
           op.getLoc(), vector::CombiningKind::ADD, m);
 
       SmallVector<int64_t, 2> pos = rank == 1 ? SmallVector<int64_t, 2>{r}
                                               : SmallVector<int64_t, 2>{r, c};
       res = rewriter.create<vector::InsertOp>(op.getLoc(), reduced, res, pos);
     }
   }
-  if (auto acc = op.acc())
+  if (auto acc = op.getAcc())
     res = createAdd(op.getLoc(), res, acc, isInt, rewriter);
   rewriter.replaceOp(op, res);
   return success();
 }
 
 /// Progressive lowering of ContractionOp.
 /// One:
 ///   %x = vector.contract with at least one free/batch dimension

 //
 // TODO: break down into transpose/reshape/cast ops
 //               when they become available to avoid code dup
 // TODO: investigate lowering order impact on performance
 LogicalResult
 ContractionOpLowering::matchAndRewrite(vector::ContractionOp op,
                                        PatternRewriter &rewriter) const {
   // TODO: implement masks.
-  if (llvm::size(op.masks()) != 0)
+  if (llvm::size(op.getMasks()) != 0)
     return failure();
 
   if (failed(filter(op)))
     return failure();
 
   // TODO: support mixed mode contract lowering.
   if (op.getLhsType().getElementType() !=
           getElementTypeOrSelf(op.getAccType()) ||
Value ContractionOpLowering::lowerParallel(vector::ContractionOp op,
   int64_t resIndex = lookup.getValue();
   // Construct new iterator types and affine map array attribute.
   std::array<AffineMap, 3> lowIndexingMaps = {
       adjustMap(iMap[0], iterIndex, rewriter),
       adjustMap(iMap[1], iterIndex, rewriter),
       adjustMap(iMap[2], iterIndex, rewriter)};
   auto lowAffine = rewriter.getAffineMapArrayAttr(lowIndexingMaps);
   auto lowIter =
-      rewriter.getArrayAttr(adjustIter(op.iterator_types(), iterIndex));
+      rewriter.getArrayAttr(adjustIter(op.getIteratorTypes(), iterIndex));
   // Unroll into a series of lower dimensional vector.contract ops.
   Location loc = op.getLoc();
   Value result = rewriter.create<arith::ConstantOp>(
       loc, resType, rewriter.getZeroAttr(resType));
   for (int64_t d = 0; d < dimSize; ++d) {
-    auto lhs = reshapeLoad(loc, op.lhs(), lhsType, lhsIndex, d, rewriter);
-    auto rhs = reshapeLoad(loc, op.rhs(), rhsType, rhsIndex, d, rewriter);
-    auto acc = reshapeLoad(loc, op.acc(), resType, resIndex, d, rewriter);
+    auto lhs = reshapeLoad(loc, op.getLhs(), lhsType, lhsIndex, d, rewriter);
+    auto rhs = reshapeLoad(loc, op.getRhs(), rhsType, rhsIndex, d, rewriter);
+    auto acc = reshapeLoad(loc, op.getAcc(), resType, resIndex, d, rewriter);
     Value lowContract = rewriter.create<vector::ContractionOp>(
         loc, lhs, rhs, acc, lowAffine, lowIter);
     result =
         reshapeStore(loc, lowContract, result, resType, resIndex, d, rewriter);
   }
   return result;
 }
 
Value ContractionOpLowering::lowerReduction(vector::ContractionOp op,
   assert(lookupRhs.hasValue() && "missing RHS parallel index");
   int64_t lhsIndex = lookupLhs.getValue();
   int64_t rhsIndex = lookupRhs.getValue();
   int64_t dimSize = lhsType.getDimSize(lhsIndex);
   assert(dimSize == rhsType.getDimSize(rhsIndex) && "corrupt shape");
   // Base case.
   if (lhsType.getRank() == 1) {
     assert(rhsType.getRank() == 1 && "corrupt contraction");
-    Value m = createMul(loc, op.lhs(), op.rhs(), isInt, rewriter);
+    Value m = createMul(loc, op.getLhs(), op.getRhs(), isInt, rewriter);
     auto kind = vector::CombiningKind::ADD;
     Value res = rewriter.create<vector::ReductionOp>(loc, kind, m);
-    if (auto acc = op.acc())
+    if (auto acc = op.getAcc())
       res = createAdd(op.getLoc(), res, acc, isInt, rewriter);
     return res;
   }
   // Construct new iterator types and affine map array attribute.
   std::array<AffineMap, 3> lowIndexingMaps = {
       adjustMap(iMap[0], iterIndex, rewriter),
       adjustMap(iMap[1], iterIndex, rewriter),
       adjustMap(iMap[2], iterIndex, rewriter)};
   auto lowAffine = rewriter.getAffineMapArrayAttr(lowIndexingMaps);
   auto lowIter =
-      rewriter.getArrayAttr(adjustIter(op.iterator_types(), iterIndex));
+      rewriter.getArrayAttr(adjustIter(op.getIteratorTypes(), iterIndex));
   // Unroll into a series of lower dimensional vector.contract ops.
   // By feeding the initial accumulator into the first contraction,
   // and the result of each contraction into the next, eventually
   // the sum of all reductions is computed.
-  Value result = op.acc();
+  Value result = op.getAcc();
   for (int64_t d = 0; d < dimSize; ++d) {
-    auto lhs = reshapeLoad(loc, op.lhs(), lhsType, lhsIndex, d, rewriter);
-    auto rhs = reshapeLoad(loc, op.rhs(), rhsType, rhsIndex, d, rewriter);
+    auto lhs = reshapeLoad(loc, op.getLhs(), lhsType, lhsIndex, d, rewriter);
+    auto rhs = reshapeLoad(loc, op.getRhs(), rhsType, rhsIndex, d, rewriter);
     result = rewriter.create<vector::ContractionOp>(loc, lhs, rhs, result,
                                                     lowAffine, lowIter);
   }
   return result;
 }
 
 } // namespace mlir
 
LogicalResult matchAndRewrite(vector::TransferReadOp read,
                                 PatternRewriter &rewriter) const override {
     if (maxTransferRank && read.getVectorType().getRank() > *maxTransferRank)
       return failure();
 
     SmallVector<unsigned, 4> broadcastedDims;
     // Permutations are handled by VectorToSCF or
     // populateVectorTransferPermutationMapLoweringPatterns.
     // We let the 0-d corner case pass-through as it is supported.
-    if (!read.permutation_map().isMinorIdentityWithBroadcasting(
+    if (!read.getPermutationMap().isMinorIdentityWithBroadcasting(
             &broadcastedDims))
       return failure();
 
     auto memRefType = read.getShapedType().dyn_cast<MemRefType>();
     if (!memRefType)
       return failure();
 
     // Non-unit strides are handled by VectorToSCF.
if (!memrefElTy.isa<VectorType>() &&
       return failure();
 
     // Out-of-bounds dims are handled by MaterializeTransferMask.
     if (read.hasOutOfBoundsDim())
       return failure();
 
     // Create vector load op.
     Operation *loadOp;
-    if (read.mask()) {
+    if (read.getMask()) {
       Value fill = rewriter.create<vector::SplatOp>(
-          read.getLoc(), unbroadcastedVectorType, read.padding());
+          read.getLoc(), unbroadcastedVectorType, read.getPadding());
       loadOp = rewriter.create<vector::MaskedLoadOp>(
-          read.getLoc(), unbroadcastedVectorType, read.source(), read.indices(),
-          read.mask(), fill);
+          read.getLoc(), unbroadcastedVectorType, read.getSource(),
+          read.getIndices(), read.getMask(), fill);
     } else {
-      loadOp = rewriter.create<vector::LoadOp>(read.getLoc(),
-                                               unbroadcastedVectorType,
-                                               read.source(), read.indices());
+      loadOp = rewriter.create<vector::LoadOp>(
+          read.getLoc(), unbroadcastedVectorType, read.getSource(),
+          read.getIndices());
     }
 
     // Insert a broadcasting op if required.
     if (!broadcastedDims.empty()) {
       rewriter.replaceOpWithNewOp<vector::BroadcastOp>(
           read, read.getVectorType(), loadOp->getResult(0));
     } else {
       rewriter.replaceOp(read, loadOp->getResult(0));
struct VectorLoadToMemrefLoadLowering
   using OpRewritePattern<vector::LoadOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::LoadOp loadOp,
                                 PatternRewriter &rewriter) const override {
     auto vecType = loadOp.getVectorType();
     if (vecType.getNumElements() != 1)
       return failure();
     auto memrefLoad = rewriter.create<memref::LoadOp>(
-        loadOp.getLoc(), loadOp.base(), loadOp.indices());
+        loadOp.getLoc(), loadOp.getBase(), loadOp.getIndices());
     rewriter.replaceOpWithNewOp<vector::BroadcastOp>(loadOp, vecType,
                                                      memrefLoad);
     return success();
   }
 };
 
 /// Replace a 0-d vector.store with a vector.extractelement + memref.store.
 struct VectorStoreToMemrefStoreLowering
     : public OpRewritePattern<vector::StoreOp> {
   using OpRewritePattern<vector::StoreOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::StoreOp storeOp,
                                 PatternRewriter &rewriter) const override {
     auto vecType = storeOp.getVectorType();
     if (vecType.getNumElements() != 1)
       return failure();
     Value extracted;
     if (vecType.getRank() == 0) {
       // TODO: Unifiy once ExtractOp supports 0-d vectors.
       extracted = rewriter.create<vector::ExtractElementOp>(
-          storeOp.getLoc(), storeOp.valueToStore());
+          storeOp.getLoc(), storeOp.getValueToStore());
     } else {
       SmallVector<int64_t> indices(vecType.getRank(), 0);
       extracted = rewriter.create<vector::ExtractOp>(
-          storeOp.getLoc(), storeOp.valueToStore(), indices);
+          storeOp.getLoc(), storeOp.getValueToStore(), indices);
     }
 
     rewriter.replaceOpWithNewOp<memref::StoreOp>(
-        storeOp, extracted, storeOp.base(), storeOp.indices());
+        storeOp, extracted, storeOp.getBase(), storeOp.getIndices());
     return success();
   }
 };
 
 /// Progressive lowering of transfer_write. This pattern supports lowering of
 /// `vector.transfer_write` to `vector.store` if all of the following hold:
 /// - Stride of most minor memref dimension must be 1.
 /// - Out-of-bounds masking is not required.
struct TransferWriteToVectorStoreLowering
   LogicalResult matchAndRewrite(vector::TransferWriteOp write,
                                 PatternRewriter &rewriter) const override {
     if (maxTransferRank && write.getVectorType().getRank() > *maxTransferRank)
       return failure();
 
     // Permutations are handled by VectorToSCF or
     // populateVectorTransferPermutationMapLoweringPatterns.
     if ( // pass-through for the 0-d corner case.
-        !write.permutation_map().isMinorIdentity())
+        !write.getPermutationMap().isMinorIdentity())
       return failure();
 
     auto memRefType = write.getShapedType().dyn_cast<MemRefType>();
     if (!memRefType)
       return failure();
 
     // Non-unit strides are handled by VectorToSCF.
     if (!vector::isLastMemrefDimUnitStride(memRefType))
       return failure();
 
     // `vector.store` supports vector types as memref's elements only when the
     // type of the vector value being written is the same as the element type.
     auto memrefElTy = memRefType.getElementType();
     if (memrefElTy.isa<VectorType>() && memrefElTy != write.getVectorType())
       return failure();
 
     // Otherwise, element types of the memref and the vector must match.
     if (!memrefElTy.isa<VectorType>() &&
         memrefElTy != write.getVectorType().getElementType())
       return failure();
 
     // Out-of-bounds dims are handled by MaterializeTransferMask.
     if (write.hasOutOfBoundsDim())
       return failure();
-    if (write.mask()) {
+    if (write.getMask()) {
       rewriter.replaceOpWithNewOp<vector::MaskedStoreOp>(
-          write, write.source(), write.indices(), write.mask(), write.vector());
+          write, write.getSource(), write.getIndices(), write.getMask(),
+          write.getVector());
     } else {
       rewriter.replaceOpWithNewOp<vector::StoreOp>(
-          write, write.vector(), write.source(), write.indices());
+          write, write.getVector(), write.getSource(), write.getIndices());
     }
     return success();
   }
 
   llvm::Optional<unsigned> maxTransferRank;
 };
 
 // Returns the values in `arrayAttr` as an integer vector.
struct BubbleDownVectorBitCastForExtract
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ExtractOp extractOp,
                                 PatternRewriter &rewriter) const override {
     // Only support extracting scalars for now.
     if (extractOp.getVectorType().getRank() != 1)
       return failure();
 
-    auto castOp = extractOp.vector().getDefiningOp<vector::BitCastOp>();
+    auto castOp = extractOp.getVector().getDefiningOp<vector::BitCastOp>();
     if (!castOp)
       return failure();
 
     VectorType castSrcType = castOp.getSourceVectorType();
     VectorType castDstType = castOp.getResultVectorType();
     assert(castSrcType.getRank() == castDstType.getRank());
 
     // Fail to match if we only have one element in the cast op source.
LogicalResult matchAndRewrite(vector::ExtractOp extractOp,
 
     unsigned expandRatio =
         castDstType.getNumElements() / castSrcType.getNumElements();
 
     auto getFirstIntValue = [](ArrayAttr attr) -> uint64_t {
       return (*attr.getAsValueRange<IntegerAttr>().begin()).getZExtValue();
     };
 
-    uint64_t index = getFirstIntValue(extractOp.position());
+    uint64_t index = getFirstIntValue(extractOp.getPosition());
 
     // Get the single scalar (as a vector) in the source value that packs the
     // desired scalar. E.g. extract vector<1xf32> from vector<4xf32>
     VectorType oneScalarType =
         VectorType::get({1}, castSrcType.getElementType());
     Value packedValue = rewriter.create<vector::ExtractOp>(
-        extractOp.getLoc(), oneScalarType, castOp.source(),
+        extractOp.getLoc(), oneScalarType, castOp.getSource(),
         rewriter.getI64ArrayAttr(index / expandRatio));
 
     // Cast it to a vector with the desired scalar's type.
     // E.g. f32 -> vector<2xf16>
     VectorType packedType =
         VectorType::get({expandRatio}, castDstType.getElementType());
     Value castedValue = rewriter.create<vector::BitCastOp>(
         extractOp.getLoc(), packedType, packedValue);

 //        } : vector<4xf32> to vector<2xf32>
 //   %1 = vector.bitcast %0 : vector<2xf32> to vector<4xf16>
 struct BubbleDownBitCastForStridedSliceExtract
     : public OpRewritePattern<vector::ExtractStridedSliceOp> {
   using OpRewritePattern::OpRewritePattern;
 
   LogicalResult matchAndRewrite(vector::ExtractStridedSliceOp extractOp,
                                 PatternRewriter &rewriter) const override {
-    auto castOp = extractOp.vector().getDefiningOp<vector::BitCastOp>();
+    auto castOp = extractOp.getVector().getDefiningOp<vector::BitCastOp>();
     if (!castOp)
       return failure();
 
     VectorType castSrcType = castOp.getSourceVectorType();
     VectorType castDstType = castOp.getResultVectorType();
     assert(castSrcType.getRank() == castDstType.getRank());
 
     int64_t castSrcLastDim = castSrcType.getShape().back();
     int64_t castDstLastDim = castDstType.getShape().back();
     // Require casting to more elements for now; other cases to be implemented.
     if (castSrcLastDim > castDstLastDim)
       return failure();
 
     // Only accept all one strides for now.
-    if (llvm::any_of(extractOp.strides().getAsValueRange<IntegerAttr>(),
+    if (llvm::any_of(extractOp.getStrides().getAsValueRange<IntegerAttr>(),
                      [](const APInt &val) { return !val.isOneValue(); }))
       return failure();
 
     unsigned rank = extractOp.getVectorType().getRank();
     assert(castDstLastDim % castSrcLastDim == 0);
     int64_t expandRatio = castDstLastDim / castSrcLastDim;
 
     // If we have a less number of offsets than the rank, then implicitly we
     // are selecting the full range for the last bitcasted dimension; other
     // dimensions aren't affected. Otherwise, we need to scale down the last
     // dimension's offset given we are extracting from less elements now.
-    ArrayAttr newOffsets = extractOp.offsets();
+    ArrayAttr newOffsets = extractOp.getOffsets();
     if (newOffsets.size() == rank) {
       SmallVector<int64_t, 4> offsets = getIntValueVector(newOffsets);
       if (offsets.back() % expandRatio != 0)
         return failure();
       offsets.back() = offsets.back() / expandRatio;
       newOffsets = rewriter.getI64ArrayAttr(offsets);
     }
 
     // Similarly for sizes.
-    ArrayAttr newSizes = extractOp.sizes();
+    ArrayAttr newSizes = extractOp.getSizes();
     if (newSizes.size() == rank) {
       SmallVector<int64_t, 4> sizes = getIntValueVector(newSizes);
       if (sizes.back() % expandRatio != 0)
         return failure();
       sizes.back() = sizes.back() / expandRatio;
       newSizes = rewriter.getI64ArrayAttr(sizes);
     }
 
     SmallVector<int64_t, 4> dims =
         llvm::to_vector<4>(extractOp.getType().cast<VectorType>().getShape());
     dims.back() = dims.back() / expandRatio;
     VectorType newExtractType =
         VectorType::get(dims, castSrcType.getElementType());
 
     auto newExtractOp = rewriter.create<vector::ExtractStridedSliceOp>(
-        extractOp.getLoc(), newExtractType, castOp.source(), newOffsets,
-        newSizes, extractOp.strides());
+        extractOp.getLoc(), newExtractType, castOp.getSource(), newOffsets,
+        newSizes, extractOp.getStrides());
 
     rewriter.replaceOpWithNewOp<vector::BitCastOp>(
         extractOp, extractOp.getType(), newExtractOp);
 
     return success();
   }
 };
 
LogicalResult matchAndRewrite(vector::BitCastOp bitcastOp,
     // Require casting to less elements for now; other cases to be implemented.
     if (castSrcLastDim < castDstLastDim)
       return failure();
 
     assert(castSrcLastDim % castDstLastDim == 0);
     int64_t shrinkRatio = castSrcLastDim / castDstLastDim;
 
     auto insertOp =
-        bitcastOp.source().getDefiningOp<vector::InsertStridedSliceOp>();
+        bitcastOp.getSource().getDefiningOp<vector::InsertStridedSliceOp>();
     if (!insertOp)
       return failure();
 
     // Only accept all one strides for now.
-    if (llvm::any_of(insertOp.strides().getAsValueRange<IntegerAttr>(),
+    if (llvm::any_of(insertOp.getStrides().getAsValueRange<IntegerAttr>(),
                      [](const APInt &val) { return !val.isOneValue(); }))
       return failure();
 
     unsigned rank = insertOp.getSourceVectorType().getRank();
     // Require insert op to have the same rank for the source and destination
     // vector; other cases to be implemented.
     if (rank != insertOp.getDestVectorType().getRank())
       return failure();
 
-    ArrayAttr newOffsets = insertOp.offsets();
+    ArrayAttr newOffsets = insertOp.getOffsets();
     assert(newOffsets.size() == rank);
     SmallVector<int64_t, 4> offsets = getIntValueVector(newOffsets);
     if (offsets.back() % shrinkRatio != 0)
       return failure();
     offsets.back() = offsets.back() / shrinkRatio;
     newOffsets = rewriter.getI64ArrayAttr(offsets);
 
     SmallVector<int64_t, 4> srcDims =
         llvm::to_vector<4>(insertOp.getSourceVectorType().getShape());
     srcDims.back() = srcDims.back() / shrinkRatio;
     VectorType newCastSrcType =
         VectorType::get(srcDims, castDstType.getElementType());
 
     auto newCastSrcOp = rewriter.create<vector::BitCastOp>(
-        bitcastOp.getLoc(), newCastSrcType, insertOp.source());
+        bitcastOp.getLoc(), newCastSrcType, insertOp.getSource());
 
     SmallVector<int64_t, 4> dstDims =
         llvm::to_vector<4>(insertOp.getDestVectorType().getShape());
     dstDims.back() = dstDims.back() / shrinkRatio;
     VectorType newCastDstType =
         VectorType::get(dstDims, castDstType.getElementType());
 
     auto newCastDstOp = rewriter.create<vector::BitCastOp>(
-        bitcastOp.getLoc(), newCastDstType, insertOp.dest());
+        bitcastOp.getLoc(), newCastDstType, insertOp.getDest());
 
     rewriter.replaceOpWithNewOp<vector::InsertStridedSliceOp>(
         bitcastOp, bitcastOp.getType(), newCastSrcOp, newCastDstOp, newOffsets,
-        insertOp.strides());
+        insertOp.getStrides());
 
     return success();
   }
 };
 
 // Helper that returns a vector comparison that constructs a mask:
 //     mask = [0,1,..,n-1] + [o,o,..,o] < [b,b,..,b]
 //
explicit MaterializeTransferMask(MLIRContext *context, bool enableIndexOpt)
         indexOptimizations(enableIndexOpt) {}
 
   LogicalResult matchAndRewrite(ConcreteOp xferOp,
                                 PatternRewriter &rewriter) const override {
     if (!xferOp.hasOutOfBoundsDim())
       return failure();
 
     if (xferOp.getVectorType().getRank() > 1 ||
-        llvm::size(xferOp.indices()) == 0)
+        llvm::size(xferOp.getIndices()) == 0)
       return failure();
 
     Location loc = xferOp->getLoc();
     VectorType vtp = xferOp.getVectorType();
 
     // Create the in-bounds mask with all elements between [0 .. dim - offset)
     // set and [dim - offset .. vector_length) unset.
     //
     // TODO: when the leaf transfer rank is k > 1, we need the last `k`
     //       dimensions here.
-    unsigned lastIndex = llvm::size(xferOp.indices()) - 1;
-    Value off = xferOp.indices()[lastIndex];
+    unsigned lastIndex = llvm::size(xferOp.getIndices()) - 1;
+    Value off = xferOp.getIndices()[lastIndex];
     Value dim =
-        vector::createOrFoldDimOp(rewriter, loc, xferOp.source(), lastIndex);
+        vector::createOrFoldDimOp(rewriter, loc, xferOp.getSource(), lastIndex);
     Value b = rewriter.create<arith::SubIOp>(loc, dim.getType(), dim, off);
     Value mask = rewriter.create<vector::CreateMaskOp>(
         loc,
         VectorType::get(vtp.getShape(), rewriter.getI1Type(),
                         vtp.getNumScalableDims()),
         b);
-    if (xferOp.mask()) {
+    if (xferOp.getMask()) {
       // Intersect the in-bounds with the mask specified as an op parameter.
-      mask = rewriter.create<arith::AndIOp>(loc, mask, xferOp.mask());
+      mask = rewriter.create<arith::AndIOp>(loc, mask, xferOp.getMask());
     }
 
     rewriter.updateRootInPlace(xferOp, [&]() {
-      xferOp.maskMutable().assign(mask);
-      xferOp.in_boundsAttr(rewriter.getBoolArrayAttr({true}));
+      xferOp.getMaskMutable().assign(mask);
+      xferOp.setInBoundsAttr(rewriter.getBoolArrayAttr({true}));
     });
 
     return success();
   }
 
 private:
   const bool indexOptimizations;
 };
class DropInnerMostUnitDims : public OpRewritePattern<vector::TransferReadOp> {
 
   LogicalResult matchAndRewrite(vector::TransferReadOp readOp,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (readOp.getTransferRank() == 0)
       return failure();
 
     // TODO: support mask.
-    if (readOp.mask())
+    if (readOp.getMask())
       return failure();
 
-    auto srcType = readOp.source().getType().dyn_cast<MemRefType>();
+    auto srcType = readOp.getSource().getType().dyn_cast<MemRefType>();
     if (!srcType || !srcType.hasStaticShape())
       return failure();
 
-    if (!readOp.permutation_map().isMinorIdentity())
+    if (!readOp.getPermutationMap().isMinorIdentity())
       return failure();
 
     auto targetType = readOp.getVectorType();
     if (targetType.getRank() <= 1)
       return failure();
 
     SmallVector<int64_t> srcStrides;
     int64_t srcOffset;
if (srcType.getLayout().getAffineMap().isIdentity()) {
           map, srcType.getMemorySpaceAsInt());
     }
 
     auto loc = readOp.getLoc();
     SmallVector<int64_t> offsets(srcType.getRank(), 0);
     SmallVector<int64_t> strides(srcType.getRank(), 1);
 
     ArrayAttr inBoundsAttr =
-        readOp.in_bounds()
+        readOp.getInBounds()
             ? rewriter.getArrayAttr(
-                  readOp.in_boundsAttr().getValue().drop_back(dimsToDrop))
+                  readOp.getInBoundsAttr().getValue().drop_back(dimsToDrop))
             : ArrayAttr();
     Value rankedReducedView = rewriter.create<memref::SubViewOp>(
-        loc, resultMemrefType, readOp.source(), offsets, srcType.getShape(),
+        loc, resultMemrefType, readOp.getSource(), offsets, srcType.getShape(),
         strides);
     auto permMap = getTransferMinorIdentityMap(
         rankedReducedView.getType().cast<ShapedType>(), resultTargetVecType);
     Value result = rewriter.create<vector::TransferReadOp>(
         loc, resultTargetVecType, rankedReducedView,
-        readOp.indices().drop_back(dimsToDrop), AffineMapAttr::get(permMap),
-        readOp.padding(),
+        readOp.getIndices().drop_back(dimsToDrop), AffineMapAttr::get(permMap),
+        readOp.getPadding(),
         // TODO: support mask.
         /*mask=*/Value(), inBoundsAttr);
     rewriter.replaceOpWithNewOp<vector::ShapeCastOp>(readOp, targetType,
                                                      result);
     return success();
   }
 };
 
struct ScanToArithOps : public OpRewritePattern<vector::ScanOp> {
 
   LogicalResult matchAndRewrite(vector::ScanOp scanOp,
                                 PatternRewriter &rewriter) const override {
     auto loc = scanOp.getLoc();
     VectorType destType = scanOp.getDestType();
     ArrayRef<int64_t> destShape = destType.getShape();
     auto elType = destType.getElementType();
     bool isInt = elType.isIntOrIndex();
-    if (!isValidKind(isInt, scanOp.kind()))
+    if (!isValidKind(isInt, scanOp.getKind()))
       return failure();
 
     VectorType resType = VectorType::get(destShape, elType);
     Value result = rewriter.create<arith::ConstantOp>(
         loc, resType, rewriter.getZeroAttr(resType));
-    int64_t reductionDim = scanOp.reduction_dim();
-    bool inclusive = scanOp.inclusive();
+    int64_t reductionDim = scanOp.getReductionDim();
+    bool inclusive = scanOp.getInclusive();
     int64_t destRank = destType.getRank();
     VectorType initialValueType = scanOp.getInitialValueType();
     int64_t initialValueRank = initialValueType.getRank();
 
     SmallVector<int64_t> reductionShape(destShape.begin(), destShape.end());
     reductionShape[reductionDim] = 1;
     VectorType reductionType = VectorType::get(reductionShape, elType);
     SmallVector<int64_t> offsets(destRank, 0);
     SmallVector<int64_t> strides(destRank, 1);
     SmallVector<int64_t> sizes(destShape.begin(), destShape.end());
     sizes[reductionDim] = 1;
     ArrayAttr scanSizes = rewriter.getI64ArrayAttr(sizes);
     ArrayAttr scanStrides = rewriter.getI64ArrayAttr(strides);
 
     Value lastOutput, lastInput;
     for (int i = 0; i < destShape[reductionDim]; i++) {
       offsets[reductionDim] = i;
       ArrayAttr scanOffsets = rewriter.getI64ArrayAttr(offsets);
       Value input = rewriter.create<vector::ExtractStridedSliceOp>(
-          loc, reductionType, scanOp.source(), scanOffsets, scanSizes,
+          loc, reductionType, scanOp.getSource(), scanOffsets, scanSizes,
           scanStrides);
       Value output;
       if (i == 0) {
         if (inclusive) {
           output = input;
         } else {
           if (initialValueRank == 0) {
             // ShapeCastOp cannot handle 0-D vectors
             output = rewriter.create<vector::BroadcastOp>(
-                loc, input.getType(), scanOp.initial_value());
+                loc, input.getType(), scanOp.getInitialValue());
           } else {
             output = rewriter.create<vector::ShapeCastOp>(
-                loc, input.getType(), scanOp.initial_value());
+                loc, input.getType(), scanOp.getInitialValue());
           }
         }
       } else {
         Value y = inclusive ? input : lastInput;
-        output = genOperator(loc, lastOutput, y, scanOp.kind(), rewriter);
+        output = genOperator(loc, lastOutput, y, scanOp.getKind(), rewriter);
         assert(output != nullptr);
       }
       result = rewriter.create<vector::InsertStridedSliceOp>(
           loc, output, result, offsets, strides);
       lastOutput = output;
       lastInput = input;
     }
 

mlir/lib/Dialect/Vector/Transforms/VectorUnrollDistribute.cpp

UnrollTransferReadPattern(MLIRContext *context,
                             const vector::UnrollVectorOptions &options)
       : OpRewritePattern<vector::TransferReadOp>(context, /*benefit=*/1),
         options(options) {}
   LogicalResult matchAndRewrite(vector::TransferReadOp readOp,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (readOp.getTransferRank() == 0)
       return failure();
-    if (readOp.mask())
+    if (readOp.getMask())
       return failure();
     auto targetShape = getTargetShape(options, readOp);
     if (!targetShape)
       return failure();
     auto sourceVectorType = readOp.getVectorType();
     SmallVector<int64_t, 4> strides(targetShape->size(), 1);
     Location loc = readOp.getLoc();
     ArrayRef<int64_t> originalSize = readOp.getVectorType().getShape();
     SmallVector<int64_t, 4> ratio = *shapeRatio(originalSize, *targetShape);
     // Compute shape ratio of 'shape' and 'sizes'.
     int64_t sliceCount = computeMaxLinearIndex(ratio);
     // Prepare the result vector;
     Value result = rewriter.create<arith::ConstantOp>(
         loc, sourceVectorType, rewriter.getZeroAttr(sourceVectorType));
     auto targetType =
         VectorType::get(*targetShape, sourceVectorType.getElementType());
-    SmallVector<Value, 4> originalIndices(readOp.indices().begin(),
-                                          readOp.indices().end());
+    SmallVector<Value, 4> originalIndices(readOp.getIndices().begin(),
+                                          readOp.getIndices().end());
     for (int64_t i = 0; i < sliceCount; i++) {
       SmallVector<Value, 4> indices =
           sliceTransferIndices(i, originalSize, *targetShape, originalIndices,
-                               readOp.permutation_map(), loc, rewriter);
+                               readOp.getPermutationMap(), loc, rewriter);
       auto slicedRead = rewriter.create<vector::TransferReadOp>(
-          loc, targetType, readOp.source(), indices,
-          readOp.permutation_mapAttr(), readOp.padding(), readOp.mask(),
-          readOp.in_boundsAttr());
+          loc, targetType, readOp.getSource(), indices,
+          readOp.getPermutationMapAttr(), readOp.getPadding(), readOp.getMask(),
+          readOp.getInBoundsAttr());
 
       SmallVector<int64_t, 4> elementOffsets =
           getVectorOffset(originalSize, *targetShape, i);
       result = rewriter.create<vector::InsertStridedSliceOp>(
           loc, slicedRead, result, elementOffsets, strides);
     }
     rewriter.replaceOp(readOp, result);
     return success();
UnrollTransferWritePattern(MLIRContext *context,
       : OpRewritePattern<vector::TransferWriteOp>(context, /*benefit=*/1),
         options(options) {}
   LogicalResult matchAndRewrite(vector::TransferWriteOp writeOp,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (writeOp.getTransferRank() == 0)
       return failure();
 
-    if (writeOp.mask())
+    if (writeOp.getMask())
       return failure();
     auto targetShape = getTargetShape(options, writeOp);
     if (!targetShape)
       return failure();
     auto sourceVectorType = writeOp.getVectorType();
     SmallVector<int64_t, 4> strides(targetShape->size(), 1);
     Location loc = writeOp.getLoc();
     ArrayRef<int64_t> originalSize = sourceVectorType.getShape();
     SmallVector<int64_t, 4> ratio = *shapeRatio(originalSize, *targetShape);
     // Compute shape ratio of 'shape' and 'sizes'.
     int64_t sliceCount = computeMaxLinearIndex(ratio);
-    SmallVector<Value, 4> originalIndices(writeOp.indices().begin(),
-                                          writeOp.indices().end());
+    SmallVector<Value, 4> originalIndices(writeOp.getIndices().begin(),
+                                          writeOp.getIndices().end());
     Value resultTensor;
     for (int64_t i = 0; i < sliceCount; i++) {
       SmallVector<int64_t, 4> elementOffsets =
           getVectorOffset(originalSize, *targetShape, i);
       Value slicedVector = rewriter.create<vector::ExtractStridedSliceOp>(
-          loc, writeOp.vector(), elementOffsets, *targetShape, strides);
+          loc, writeOp.getVector(), elementOffsets, *targetShape, strides);
 
       SmallVector<Value, 4> indices =
           sliceTransferIndices(i, originalSize, *targetShape, originalIndices,
-                               writeOp.permutation_map(), loc, rewriter);
+                               writeOp.getPermutationMap(), loc, rewriter);
       Operation *slicedWrite = rewriter.create<vector::TransferWriteOp>(
-          loc, slicedVector, resultTensor ? resultTensor : writeOp.source(),
-          indices, writeOp.permutation_mapAttr(), writeOp.in_boundsAttr());
+          loc, slicedVector, resultTensor ? resultTensor : writeOp.getSource(),
+          indices, writeOp.getPermutationMapAttr(), writeOp.getInBoundsAttr());
       // For the tensor case update the destination for the next transfer write.
       if (!slicedWrite->getResults().empty())
         resultTensor = slicedWrite->getResult(0);
     }
     if (resultTensor)
       rewriter.replaceOp(writeOp, resultTensor);
     else
       rewriter.eraseOp(writeOp);
for (int64_t i = 0; i < sliceCount; i++) {
         slicesOperands[index] = rewriter.create<vector::ExtractStridedSliceOp>(
             loc, operand, operandOffets, operandShape, operandStrides);
       };
 
       // Extract the new lhs operand.
       AffineMap lhsPermutationMap = contractOp.getIndexingMaps()[0];
       SmallVector<int64_t> lhsOffets =
           applyPermutationMap(lhsPermutationMap, ArrayRef<int64_t>(offsets));
-      extractOperand(0, contractOp.lhs(), lhsPermutationMap, lhsOffets);
+      extractOperand(0, contractOp.getLhs(), lhsPermutationMap, lhsOffets);
       // If there is a mask associated to lhs, extract it as well.
       if (slicesOperands.size() > 3)
-        extractOperand(3, contractOp.masks()[0], lhsPermutationMap, lhsOffets);
+        extractOperand(3, contractOp.getMasks()[0], lhsPermutationMap,
+                       lhsOffets);
 
       // Extract the new rhs operand.
       AffineMap rhsPermutationMap = contractOp.getIndexingMaps()[1];
       SmallVector<int64_t> rhsOffets =
           applyPermutationMap(rhsPermutationMap, ArrayRef<int64_t>(offsets));
-      extractOperand(1, contractOp.rhs(), rhsPermutationMap, rhsOffets);
+      extractOperand(1, contractOp.getRhs(), rhsPermutationMap, rhsOffets);
       // If there is a mask associated to rhs, extract it as well.
       if (slicesOperands.size() > 4)
-        extractOperand(4, contractOp.masks()[1], rhsPermutationMap, rhsOffets);
+        extractOperand(4, contractOp.getMasks()[1], rhsPermutationMap,
+                       rhsOffets);
 
       AffineMap accPermutationMap = contractOp.getIndexingMaps()[2];
       SmallVector<int64_t> accOffets =
           applyPermutationMap(accPermutationMap, ArrayRef<int64_t>(offsets));
       // If a version of the accumulator has already been computed, use it
       // otherwise extract the first version from the original operand.
       auto accIt = accCache.find(accOffets);
       if (accIt != accCache.end())
         slicesOperands[2] = accIt->second;
       else
-        extractOperand(2, contractOp.acc(), accPermutationMap, accOffets);
+        extractOperand(2, contractOp.getAcc(), accPermutationMap, accOffets);
 
       SmallVector<int64_t> dstShape =
           applyPermutationMap(dstAffineMap, ArrayRef<int64_t>(*targetShape));
       auto targetType = VectorType::get(dstShape, dstVecType.getElementType());
       Operation *newOp = cloneOpWithOperandsAndTypes(
           rewriter, loc, contractOp, slicesOperands, targetType);
 
       SmallVector<int64_t> dstOffets =
for (int64_t i = 0; i < sliceCount; i++) {
           dstShape, reductionOp.getSourceVectorType().getElementType());
       Operation *newOp = cloneOpWithOperandsAndTypes(rewriter, loc, reductionOp,
                                                      slicedOperand, targetType);
       Value result = newOp->getResult(0);
       // Save the accumulated value until all the loops are unrolled since
       // reduction loop keeps updating the accumulator.
       auto accIt = accCache.find(destOffset);
       if (accIt != accCache.end())
-        result = makeArithReduction(rewriter, loc, reductionOp.kind(), result,
-                                    accIt->second);
+        result = makeArithReduction(rewriter, loc, reductionOp.getKind(),
+                                    result, accIt->second);
       accCache[destOffset] = result;
     }
     // Assemble back the accumulator into a single vector.
     Value result = rewriter.create<arith::ConstantOp>(
         loc, reductionOp.getDestType(),
         rewriter.getZeroAttr(reductionOp.getDestType()));
     for (const auto &it : accCache) {
       SmallVector<int64_t> dstStrides(it.first.size(), 1);

 /// to:
 /// %da = vector.extract_map %a[%id] : vector<32xf32> to vector<1xf32>
 /// %db = vector.extract_map %a[%id] : vector<32xf32> to vector<1xf32>
 /// %dv = arith.addf %da, %db : vector<1xf32>
 struct PointwiseExtractPattern : public OpRewritePattern<vector::ExtractMapOp> {
   using OpRewritePattern<vector::ExtractMapOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(vector::ExtractMapOp extract,
                                 PatternRewriter &rewriter) const override {
-    Operation *definedOp = extract.vector().getDefiningOp();
+    Operation *definedOp = extract.getVector().getDefiningOp();
     if (!definedOp || !OpTrait::hasElementwiseMappableTraits(definedOp) ||
         definedOp->getNumResults() != 1)
       return failure();
     Location loc = extract.getLoc();
     SmallVector<Value, 4> extractOperands;
     for (OpOperand &operand : definedOp->getOpOperands()) {
       auto vecType = operand.get().getType().template dyn_cast<VectorType>();
       if (!vecType) {
         extractOperands.push_back(operand.get());
         continue;
       }
       extractOperands.push_back(rewriter.create<vector::ExtractMapOp>(
           loc,
           VectorType::get(extract.getResultType().getShape(),
                           vecType.getElementType()),
-          operand.get(), extract.ids()));
+          operand.get(), extract.getIds()));
     }
     Operation *newOp = cloneOpWithOperandsAndTypes(
         rewriter, loc, definedOp, extractOperands, extract.getResultType());
     rewriter.replaceOp(extract, newOp->getResult(0));
     return success();
   }
 };
 
 /// Canonicalize an extract_map using the result of a contract operation.
 /// This propagate the extract_map to operands.
 struct ContractExtractPattern : public OpRewritePattern<vector::ExtractMapOp> {
   using OpRewritePattern<vector::ExtractMapOp>::OpRewritePattern;
   LogicalResult matchAndRewrite(vector::ExtractMapOp extract,
                                 PatternRewriter &rewriter) const override {
-    Operation *definedOp = extract.vector().getDefiningOp();
+    Operation *definedOp = extract.getVector().getDefiningOp();
     auto contract = dyn_cast_or_null<vector::ContractionOp>(definedOp);
     if (!contract)
       return failure();
     Location loc = contract.getLoc();
     unsigned accIndex = vector::ContractionOp::getAccOperandIndex();
     AffineMap affineMap = contract.getIndexingMaps()[accIndex];
     // Create a map of the dimensions distributed based on the acc affine map.
     // Only parallel dimensions are being distributed, reduction dimensions are
for (const auto &it : llvm::enumerate(contract.getIndexingMaps())) {
         // doesn't get distributed.
         if (distributedDim == map.end())
           continue;
         operandShape[i] = distributedDim->second;
       }
       VectorType newVecType =
           VectorType::get(operandShape, vecType.getElementType());
       extractOperands.push_back(rewriter.create<vector::ExtractMapOp>(
-          loc, newVecType, operand, extract.ids()));
+          loc, newVecType, operand, extract.getIds()));
     }
     Operation *newOp =
         cloneOpWithOperandsAndTypes(rewriter, loc, definedOp, extractOperands,
                                     extract.getResult().getType());
     rewriter.replaceOp(extract, newOp->getResult(0));
     return success();
   }
 };
if (read.getTransferRank() == 0)
       return failure();
 
     if (!read.getResult().hasOneUse())
       return failure();
     auto extract =
         dyn_cast<vector::ExtractMapOp>(*read.getResult().getUsers().begin());
     if (!extract)
       return failure();
-    if (read.mask())
+    if (read.getMask())
       return failure();
 
-    SmallVector<Value, 4> indices(read.indices().begin(), read.indices().end());
-    AffineMap indexMap = extract.map().compose(read.permutation_map());
+    SmallVector<Value, 4> indices(read.getIndices().begin(),
+                                  read.getIndices().end());
+    AffineMap indexMap = extract.map().compose(read.getPermutationMap());
     unsigned idCount = 0;
     ImplicitLocOpBuilder lb(read.getLoc(), rewriter);
     for (auto it :
          llvm::zip(indexMap.getResults(), extract.map().getResults())) {
       AffineExpr d0, d1;
       bindDims(read.getContext(), d0, d1);
       auto indexExpr = std::get<0>(it).dyn_cast<AffineDimExpr>();
       if (!indexExpr)
         continue;
       unsigned indexPos = indexExpr.getPosition();
       unsigned vectorPos = std::get<1>(it).cast<AffineDimExpr>().getPosition();
       auto scale = getAffineConstantExpr(
           extract.getResultType().getDimSize(vectorPos), read.getContext());
       indices[indexPos] = makeComposedAffineApply(
           rewriter, read.getLoc(), d0 + scale * d1,
-          {indices[indexPos], extract.ids()[idCount++]});
+          {indices[indexPos], extract.getIds()[idCount++]});
     }
     Value newRead = lb.create<vector::TransferReadOp>(
-        extract.getType(), read.source(), indices, read.permutation_mapAttr(),
-        read.padding(), read.mask(), read.in_boundsAttr());
+        extract.getType(), read.getSource(), indices,
+        read.getPermutationMapAttr(), read.getPadding(), read.getMask(),
+        read.getInBoundsAttr());
     Value dest = lb.create<arith::ConstantOp>(
         read.getType(), rewriter.getZeroAttr(read.getType()));
-    newRead = lb.create<vector::InsertMapOp>(newRead, dest, extract.ids());
+    newRead = lb.create<vector::InsertMapOp>(newRead, dest, extract.getIds());
     rewriter.replaceOp(read, newRead);
     return success();
   }
 };
 
 struct TransferWriteInsertPattern
     : public OpRewritePattern<vector::TransferWriteOp> {
   TransferWriteInsertPattern(MLIRContext *context)
       : OpRewritePattern<vector::TransferWriteOp>(context) {}
   LogicalResult matchAndRewrite(vector::TransferWriteOp write,
                                 PatternRewriter &rewriter) const override {
     // TODO: support 0-d corner case.
     if (write.getTransferRank() == 0)
       return failure();
 
-    auto insert = write.vector().getDefiningOp<vector::InsertMapOp>();
+    auto insert = write.getVector().getDefiningOp<vector::InsertMapOp>();
     if (!insert)
       return failure();
-    if (write.mask())
+    if (write.getMask())
       return failure();
-    SmallVector<Value, 4> indices(write.indices().begin(),
-                                  write.indices().end());
-    AffineMap indexMap = insert.map().compose(write.permutation_map());
+    SmallVector<Value, 4> indices(write.getIndices().begin(),
+                                  write.getIndices().end());
+    AffineMap indexMap = insert.map().compose(write.getPermutationMap());
     unsigned idCount = 0;
     Location loc = write.getLoc();
     for (auto it :
          llvm::zip(indexMap.getResults(), insert.map().getResults())) {
       AffineExpr d0, d1;
       bindDims(write.getContext(), d0, d1);
       auto indexExpr = std::get<0>(it).dyn_cast<AffineDimExpr>();
       if (!indexExpr)
         continue;
       unsigned indexPos = indexExpr.getPosition();
       unsigned vectorPos = std::get<1>(it).cast<AffineDimExpr>().getPosition();
       auto scale = getAffineConstantExpr(
           insert.getSourceVectorType().getDimSize(vectorPos),
           write.getContext());
-      indices[indexPos] =
-          makeComposedAffineApply(rewriter, loc, d0 + scale * d1,
-                                  {indices[indexPos], insert.ids()[idCount++]});
+      indices[indexPos] = makeComposedAffineApply(
+          rewriter, loc, d0 + scale * d1,
+          {indices[indexPos], insert.getIds()[idCount++]});
     }
     rewriter.create<vector::TransferWriteOp>(
-        loc, insert.vector(), write.source(), indices,
-        write.permutation_mapAttr(), write.in_boundsAttr());
+        loc, insert.getVector(), write.getSource(), indices,
+        write.getPermutationMapAttr(), write.getInBoundsAttr());
     rewriter.eraseOp(write);
     return success();
   }
 };
 
 struct UnrollReductionPattern : public OpRewritePattern<vector::ReductionOp> {
   UnrollReductionPattern(MLIRContext *context,
                          const vector::UnrollVectorOptions &options)
LogicalResult matchAndRewrite(vector::ReductionOp reductionOp,
     // Create unrolled vector reduction.
     Location loc = reductionOp.getLoc();
     Value accumulator = nullptr;
     for (int64_t i = 0; i < ratio; ++i) {
       SmallVector<int64_t> offsets =
           getVectorOffset(originalSize, *targetShape, i);
       SmallVector<int64_t> strides(offsets.size(), 1);
       Value slicedOperand = rewriter.create<vector::ExtractStridedSliceOp>(
-          loc, reductionOp.vector(), offsets, *targetShape, strides);
+          loc, reductionOp.getVector(), offsets, *targetShape, strides);
       Operation *newOp = cloneOpWithOperandsAndTypes(
           rewriter, loc, reductionOp, slicedOperand, reductionOp.getType());
       Value result = newOp->getResult(0);
 
       if (!accumulator) {
         // This is the first reduction.
         accumulator = result;
       } else {
         // On subsequent reduction, combine with the accumulator.
-        accumulator = makeArithReduction(rewriter, loc, reductionOp.kind(),
+        accumulator = makeArithReduction(rewriter, loc, reductionOp.getKind(),
                                          accumulator, result);
       }
     }
 
     rewriter.replaceOp(reductionOp, accumulator);
     return success();
   }
 

mlir/lib/Dialect/X86Vector/Transforms/AVXTranspose.cpp

LogicalResult matchAndRewrite(vector::TransposeOp op,
     for (auto &en : llvm::enumerate(srcType.getShape()))
       if (en.value() > 1)
         srcGtOneDims.push_back(en.index());
 
     if (srcGtOneDims.size() != 2)
       return rewriter.notifyMatchFailure(op, "Unsupported vector type");
 
     SmallVector<int64_t, 4> transp;
-    for (auto attr : op.transp())
+    for (auto attr : op.getTransp())
       transp.push_back(attr.cast<IntegerAttr>().getInt());
 
     // Check whether the two source vector dimensions that are greater than one
     // must be transposed with each other so that we can apply one of the 2-D
     // AVX2 transpose pattens. Otherwise, these patterns are not applicable.
     if (!areDimsTransposedIn2DSlice(srcGtOneDims[0], srcGtOneDims[1], transp))
       return rewriter.notifyMatchFailure(
           op, "Not applicable to this transpose permutation");
 
     // Retrieve the sizes of the two dimensions greater than one to be
     // transposed.
     auto srcShape = srcType.getShape();
     int64_t m = srcShape[srcGtOneDims[0]], n = srcShape[srcGtOneDims[1]];
 
     auto applyRewrite = [&]() {
       ImplicitLocOpBuilder ib(loc, rewriter);
       SmallVector<Value> vs;
 
       // Reshape the n-D input vector with only two dimensions greater than one
       // to a 2-D vector.
       auto flattenedType =
           VectorType::get({n * m}, op.getVectorType().getElementType());
       auto reshInputType = VectorType::get({m, n}, srcType.getElementType());
       auto reshInput =
-          ib.create<vector::ShapeCastOp>(flattenedType, op.vector());
+          ib.create<vector::ShapeCastOp>(flattenedType, op.getVector());
       reshInput = ib.create<vector::ShapeCastOp>(reshInputType, reshInput);
 
       // Extract 1-D vectors from the higher-order dimension of the input
       // vector.
       for (int64_t i = 0; i < m; ++i)
         vs.push_back(ib.create<vector::ExtractOp>(reshInput, i));
 
       // Transpose set of 1-D vectors.

mlir/test/lib/Dialect/Vector/TestVectorTransforms.cpp

if (auto readOp = dyn_cast<vector::TransferReadOp>(op)) {
         if (dstVec && dstVec != vecType)
           return llvm::None;
         dstVec = vecType;
       }
       return SmallVector<int64_t, 4>(dstVec.getShape().begin(),
                                      dstVec.getShape().end());
     }
     if (auto writeOp = dyn_cast<vector::TransferWriteOp>(op)) {
-      auto insert = writeOp.vector().getDefiningOp<InsertStridedSliceOp>();
+      auto insert = writeOp.getVector().getDefiningOp<InsertStridedSliceOp>();
       if (!insert)
         return llvm::None;
       ArrayRef<int64_t> shape = insert.getSourceVectorType().getShape();
       return SmallVector<int64_t, 4>(shape.begin(), shape.end());
     }
     return llvm::None;
   }