[mlir][Interfaces][NFC] Use camel case for offset/size/stride accessors

[springerm]

Summary

This is for consistency with the remaining MLIR code base.

mlir/include/mlir/Interfaces/ViewLikeInterface.td

InterfaceMethod<
       /*methodName=*/"getArrayAttrMaxRanks",
       /*args=*/(ins)
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic offset operands.
       }],
       /*retTy=*/"::mlir::OperandRange",
-      /*methodName=*/"offsets",
+      /*methodName=*/"getOffsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getOffsets();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic size operands.
       }],
       /*retTy=*/"::mlir::OperandRange",
-      /*methodName=*/"sizes",
+      /*methodName=*/"getSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getSizes();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic stride operands.
       }],
       /*retTy=*/"::mlir::OperandRange",
-      /*methodName=*/"strides",
+      /*methodName=*/"getStrides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStrides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static offset attributes.
       }],
       /*retTy=*/"::llvm::ArrayRef<int64_t>",
-      /*methodName=*/"static_offsets",
+      /*methodName=*/"getStaticOffsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStaticOffsets();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static size attributes.
       }],
       /*retTy=*/"::llvm::ArrayRef<int64_t>",
-      /*methodName=*/"static_sizes",
+      /*methodName=*/"getStaticSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStaticSizes();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic stride attributes.
       }],
       /*retTy=*/"::llvm::ArrayRef<int64_t>",
-      /*methodName=*/"static_strides",
+      /*methodName=*/"getStaticStrides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getStaticStrides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
InterfaceMethod<
         Return a vector of all the static or dynamic sizes of the op.
       }],
       /*retTy=*/"::llvm::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         Builder b($_op->getContext());
-        return ::mlir::getMixedValues($_op.getStaticSizes(), $_op.sizes(), b);
+        return
+            ::mlir::getMixedValues($_op.getStaticSizes(), $_op.getSizes(), b);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic strides of the op.
       }],
       /*retTy=*/"::llvm::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedStrides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         Builder b($_op->getContext());
         return ::mlir::getMixedValues($_op.getStaticStrides(),
                                       $_op.getStrides(), b);
       }]
     >,
 
     InterfaceMethod<
       /*desc=*/"Return true if the offset `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::mlir::ShapedType::isDynamic(static_offsets()[idx]);
+        return ::mlir::ShapedType::isDynamic(getStaticOffsets()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the size `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::mlir::ShapedType::isDynamic(static_sizes()[idx]);
+        return ::mlir::ShapedType::isDynamic(getStaticSizes()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the stride `idx` is dynamic.",
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::mlir::ShapedType::isDynamic(static_strides()[idx]);
+        return ::mlir::ShapedType::isDynamic(getStaticStrides()[idx]);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the offset `idx` is a static constant and return its value.
       }],
       /*retTy=*/"int64_t",
       /*methodName=*/"getStaticOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(!$_op.isDynamicOffset(idx) && "expected static offset");
-        return static_offsets()[idx];
+        return getStaticOffsets()[idx];
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the size `idx` is a static constant and return its value.
       }],
       /*retTy=*/"int64_t",
       /*methodName=*/"getStaticSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(!$_op.isDynamicSize(idx) && "expected static size");
-        return static_sizes()[idx];
+        return getStaticSizes()[idx];
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the stride `idx` is a static constant and return its value.
       }],
       /*retTy=*/"int64_t",
       /*methodName=*/"getStaticStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(!$_op.isDynamicStride(idx) && "expected static stride");
-        return static_strides()[idx];
+        return getStaticStrides()[idx];
       }]
     >,
 
     InterfaceMethod<
       /*desc=*/[{
         Assert the offset `idx` is dynamic and return the position of the
         corresponding operand.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getIndexOfDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op.isDynamicOffset(idx) && "expected dynamic offset");
         auto numDynamic = getNumDynamicEntriesUpToIdx(
-          static_offsets(),
-          ::mlir::ShapedType::isDynamic,
-          idx);
+          getStaticOffsets(), ::mlir::ShapedType::isDynamic, idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the size `idx` is dynamic and return the position of the
         corresponding operand.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getIndexOfDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op.isDynamicSize(idx) && "expected dynamic size");
         auto numDynamic = getNumDynamicEntriesUpToIdx(
-          static_sizes(), ::mlir::ShapedType::isDynamic, idx);
+          getStaticSizes(), ::mlir::ShapedType::isDynamic, idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
-          offsets().size() + numDynamic;
+          getOffsets().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the stride `idx` is dynamic and return the position of the
         corresponding operand.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getIndexOfDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op.isDynamicStride(idx) && "expected dynamic stride");
         auto numDynamic = getNumDynamicEntriesUpToIdx(
-          static_strides(),
-          ::mlir::ShapedType::isDynamic,
-          idx);
+          getStaticStrides(), ::mlir::ShapedType::isDynamic, idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
-          offsets().size() + sizes().size() + numDynamic;
+          getOffsets().size() + getSizes().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
-        Helper method to compute the number of dynamic entries of `staticVals`, up to
-        `idx` using `isDynamic` to determine whether an entry is dynamic.
+        Helper method to compute the number of dynamic entries of `staticVals`,
+        up to `idx` using `isDynamic` to determine whether an entry is dynamic.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getNumDynamicEntriesUpToIdx",
       /*args=*/(ins "::llvm::ArrayRef<int64_t>":$staticVals,
                     "::llvm::function_ref<bool(int64_t)>":$isDynamic,
                     "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
InterfaceMethod<
       /*desc=*/[{
         Return true if all `other`'s offsets, sizes and strides are the same.
         Takes a custom `cmp` comparison function on OpFoldResult to avoid taking
         a dialect dependence.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"isSameAs",
       /*args=*/(ins "::mlir::OffsetSizeAndStrideOpInterface":$other,
                     "::llvm::function_ref<bool(::mlir::OpFoldResult, ::mlir::OpFoldResult)>":$cmp),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return ::mlir::detail::sameOffsetsSizesAndStrides(
           ::mlir::cast<::mlir::OffsetSizeAndStrideOpInterface>(
             $_op.getOperation()), other, cmp);
       }]
     >,
     InterfaceMethod<

mlir/lib/Interfaces/ViewLikeInterface.cpp

mlir::detail::verifyOffsetSizeAndStrideOp(OffsetSizeAndStrideOpInterface op) {
   // Ranks of mixed sizes and strides must always match so the result type is
   // well-formed.
   if (op.getMixedSizes().size() != op.getMixedStrides().size())
     return op->emitError(
                "expected mixed sizes rank to match mixed strides rank (")
            << op.getMixedSizes().size() << " vs " << op.getMixedStrides().size()
            << ") so the rank of the result type is well-formed.";
 
-  if (failed(verifyListOfOperandsOrIntegers(op, "offset", maxRanks[0],
-                                            op.static_offsets(), op.offsets())))
+  if (failed(verifyListOfOperandsOrIntegers(
+          op, "offset", maxRanks[0], op.getStaticOffsets(), op.getOffsets())))
     return failure();
-  if (failed(verifyListOfOperandsOrIntegers(op, "size", maxRanks[1],
-                                            op.static_sizes(), op.sizes())))
+  if (failed(verifyListOfOperandsOrIntegers(
+          op, "size", maxRanks[1], op.getStaticSizes(), op.getSizes())))
     return failure();
-  if (failed(verifyListOfOperandsOrIntegers(op, "stride", maxRanks[2],
-                                            op.static_strides(), op.strides())))
+  if (failed(verifyListOfOperandsOrIntegers(
+          op, "stride", maxRanks[2], op.getStaticStrides(), op.getStrides())))
     return failure();
   return success();
 }
 
 static char getLeftDelimiter(AsmParser::Delimiter delimiter) {
   switch (delimiter) {
   case AsmParser::Delimiter::Paren:
     return '(';
ParseResult mlir::parseDynamicIndexList(
   integers = parser.getBuilder().getDenseI64ArrayAttr(integerVals);
   scalables = parser.getBuilder().getDenseBoolArrayAttr(scalableVals);
   return success();
 }
 
 bool mlir::detail::sameOffsetsSizesAndStrides(
     OffsetSizeAndStrideOpInterface a, OffsetSizeAndStrideOpInterface b,
     llvm::function_ref<bool(OpFoldResult, OpFoldResult)> cmp) {
-  if (a.static_offsets().size() != b.static_offsets().size())
+  if (a.getStaticOffsets().size() != b.getStaticOffsets().size())
     return false;
-  if (a.static_sizes().size() != b.static_sizes().size())
+  if (a.getStaticSizes().size() != b.getStaticSizes().size())
     return false;
-  if (a.static_strides().size() != b.static_strides().size())
+  if (a.getStaticStrides().size() != b.getStaticStrides().size())
     return false;
   for (auto it : llvm::zip(a.getMixedOffsets(), b.getMixedOffsets()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;
   for (auto it : llvm::zip(a.getMixedSizes(), b.getMixedSizes()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;
   for (auto it : llvm::zip(a.getMixedStrides(), b.getMixedStrides()))
     if (!cmp(std::get<0>(it), std::get<1>(it)))
       return false;
   return true;
 }