[mlir][ODS] Add explicit namespace to `ViewLikeInterface` definition

[vinograd47]

Summary

To allow it usage for Operation classes defined outside of mlir namespace.

[mehdi_amini]

Thanks!

Do you have commit access?

[vinograd47]

@mehdi_amini I don't have commit access. Could you please land this change?

mlir/include/mlir/Interfaces/ViewLikeInterface.td

let description = [{
     takes in a (view of) buffer (and potentially some other operands) and returns
     another view of buffer.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<
       "Returns the source buffer from which the view is created.",
-      "Value", "getViewSource">
+      "::mlir::Value", "getViewSource">
   ];
 }
 
 def OffsetSizeAndStrideOpInterface : OpInterface<"OffsetSizeAndStrideOpInterface"> {
   let description = [{
     Common interface for ops that allow specifying mixed dynamic and static
     offsets, sizes and strides variadic operands.
     Ops that implement this interface need to expose the following methods:
InterfaceMethod<
       /*retTy=*/"std::array<unsigned, 3>",
       /*methodName=*/"getArrayAttrMaxRanks",
       /*args=*/(ins)
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic offset operands.
       }],
-      /*retTy=*/"OperandRange",
+      /*retTy=*/"::mlir::OperandRange",
       /*methodName=*/"offsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.offsets();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic size operands.
       }],
-      /*retTy=*/"OperandRange",
+      /*retTy=*/"::mlir::OperandRange",
       /*methodName=*/"sizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.sizes();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic stride operands.
       }],
-      /*retTy=*/"OperandRange",
+      /*retTy=*/"::mlir::OperandRange",
       /*methodName=*/"strides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.strides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static offset attributes.
       }],
-      /*retTy=*/"ArrayAttr",
+      /*retTy=*/"::mlir::ArrayAttr",
       /*methodName=*/"static_offsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.static_offsets();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the static size attributes.
       }],
-      /*retTy=*/"ArrayAttr",
+      /*retTy=*/"::mlir::ArrayAttr",
       /*methodName=*/"static_sizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.static_sizes();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return the dynamic stride attributes.
       }],
-      /*retTy=*/"ArrayAttr",
+      /*retTy=*/"::mlir::ArrayAttr",
       /*methodName=*/"static_strides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.static_strides();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic sizes of the op.
       }],
-      /*retTy=*/"SmallVector<OpFoldResult, 4>",
+      /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedOffsets",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        SmallVector<OpFoldResult, 4> res;
+        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
         unsigned numDynamic = 0;
         unsigned count = $_op.static_offsets().size();
         for (unsigned idx = 0; idx < count; ++idx) {
           if (isDynamicOffset(idx))
             res.push_back($_op.offsets()[numDynamic++]);
           else
             res.push_back($_op.static_offsets()[idx]);
         }
         return res;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic sizes of the op.
       }],
-      /*retTy=*/"SmallVector<OpFoldResult, 4>",
+      /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedSizes",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        SmallVector<OpFoldResult, 4> res;
+        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
         unsigned numDynamic = 0;
         unsigned count = $_op.static_sizes().size();
         for (unsigned idx = 0; idx < count; ++idx) {
           if (isDynamicSize(idx))
             res.push_back($_op.sizes()[numDynamic++]);
           else
             res.push_back($_op.static_sizes()[idx]);
         }
         return res;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return a vector of all the static or dynamic strides of the op.
       }],
-      /*retTy=*/"SmallVector<OpFoldResult, 4>",
+      /*retTy=*/"::mlir::SmallVector<::mlir::OpFoldResult, 4>",
       /*methodName=*/"getMixedStrides",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        SmallVector<OpFoldResult, 4> res;
+        ::mlir::SmallVector<::mlir::OpFoldResult, 4> res;
         unsigned numDynamic = 0;
         unsigned count = $_op.static_strides().size();
         for (unsigned idx = 0; idx < count; ++idx) {
           if (isDynamicStride(idx))
             res.push_back($_op.strides()[numDynamic++]);
           else
             res.push_back($_op.static_strides()[idx]);
         }
         return res;
       }]
     >,
 
     InterfaceMethod<
       /*desc=*/[{
         Return true if the offset `idx` is dynamic.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        APInt v = *(static_offsets()
-          .template getAsValueRange<IntegerAttr>().begin() + idx);
-        return ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
+        ::llvm::APInt v = *(static_offsets()
+          .template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
+        return ::mlir::ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Return true if the size `idx` is dynamic.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        APInt v = *(static_sizes()
-          .template getAsValueRange<IntegerAttr>().begin() + idx);
-        return ShapedType::isDynamic(v.getSExtValue());
+        ::llvm::APInt v = *(static_sizes()
+          .template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
+        return ::mlir::ShapedType::isDynamic(v.getSExtValue());
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
        Return true if the stride `idx` is dynamic.
       }],
       /*retTy=*/"bool",
       /*methodName=*/"isDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        APInt v = *(static_strides()
-          .template getAsValueRange<IntegerAttr>().begin() + idx);
-        return ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
+        ::llvm::APInt v = *(static_strides()
+          .template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
+        return ::mlir::ShapedType::isDynamicStrideOrOffset(v.getSExtValue());
       }]
     >,
 
     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");
-        APInt v = *(static_offsets().
-          template getAsValueRange<IntegerAttr>().begin() + idx);
+        ::llvm::APInt v = *(static_offsets().
+          template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
         return v.getSExtValue();
       }]
     >,
     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");
-        APInt v = *(static_sizes().
-          template getAsValueRange<IntegerAttr>().begin() + idx);
+        ::llvm::APInt v = *(static_sizes().
+          template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
         return v.getSExtValue();
       }]
     >,
     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");
-        APInt v = *(static_strides().
-          template getAsValueRange<IntegerAttr>().begin() + idx);
+        ::llvm::APInt v = *(static_strides().
+          template getAsValueRange<::mlir::IntegerAttr>().begin() + idx);
         return v.getSExtValue();
       }]
     >,
 
     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().template cast<ArrayAttr>(),
-          ShapedType::isDynamicStrideOrOffset,
+          static_offsets().template cast<::mlir::ArrayAttr>(),
+          ::mlir::ShapedType::isDynamicStrideOrOffset,
           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().template cast<ArrayAttr>(), ShapedType::isDynamic, idx);
+          static_sizes().template cast<::mlir::ArrayAttr>(), ::mlir::ShapedType::isDynamic, idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           offsets().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().template cast<ArrayAttr>(),
-          ShapedType::isDynamicStrideOrOffset,
+          static_strides().template cast<::mlir::ArrayAttr>(),
+          ::mlir::ShapedType::isDynamicStrideOrOffset,
           idx);
         return $_op.getOffsetSizeAndStrideStartOperandIndex() +
           offsets().size() + sizes().size() + numDynamic;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Helper method to compute the number of dynamic entries of `attr`, up to
         `idx` using `isDynamic` to determine whether an entry is dynamic.
       }],
       /*retTy=*/"unsigned",
       /*methodName=*/"getNumDynamicEntriesUpToIdx",
-      /*args=*/(ins "ArrayAttr":$attr,
-                    "llvm::function_ref<bool(int64_t)>":$isDynamic,
+      /*args=*/(ins "::mlir::ArrayAttr":$attr,
+                    "::llvm::function_ref<bool(int64_t)>":$isDynamic,
                     "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return std::count_if(
           attr.getValue().begin(), attr.getValue().begin() + idx,
-          [&](Attribute attr) {
-            return isDynamic(attr.cast<IntegerAttr>().getInt());
+          [&](::mlir::Attribute attr) {
+            return isDynamic(attr.cast<::mlir::IntegerAttr>().getInt());
           });
       }]
     >,
 
     InterfaceMethod<
       /*desc=*/[{
         Assert the offset `idx` is dynamic and return its value.
       }],
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getDynamicOffset",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getOperand(getIndexOfDynamicOffset(idx));
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the size `idx` is dynamic and return its value.
       }],
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getDynamicSize",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getOperand(getIndexOfDynamicSize(idx));
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{
         Assert the stride `idx` is dynamic and return its value.
       }],
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getDynamicStride",
       /*args=*/(ins "unsigned":$idx),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getOperand(getIndexOfDynamicStride(idx));
       }]
     >,
   ];
 
   let extraClassDeclaration = [{
     static unsigned getOffsetOperandGroupPosition() { return 0; }
     static unsigned getSizeOperandGroupPosition() { return 1; }
     static unsigned getStrideOperandGroupPosition() { return 2; }
-    static StringRef getStaticOffsetsAttrName() {
+    static ::llvm::StringRef getStaticOffsetsAttrName() {
       return "static_offsets";
     }
-    static StringRef getStaticSizesAttrName() {
+    static ::llvm::StringRef getStaticSizesAttrName() {
       return "static_sizes";
     }
-    static StringRef getStaticStridesAttrName() {
+    static ::llvm::StringRef getStaticStridesAttrName() {
       return "static_strides";
     }
-    static ArrayRef<StringRef> getSpecialAttrNames() {
-      static SmallVector<StringRef, 4> names{
-        OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
-        OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
-        OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
-        OpTrait::AttrSizedOperandSegments<void>::getOperandSegmentSizeAttr()};
+    static ::llvm::ArrayRef<::llvm::StringRef> getSpecialAttrNames() {
+      static ::llvm::SmallVector<::llvm::StringRef, 4> names{
+        ::mlir::OffsetSizeAndStrideOpInterface::getStaticOffsetsAttrName(),
+        ::mlir::OffsetSizeAndStrideOpInterface::getStaticSizesAttrName(),
+        ::mlir::OffsetSizeAndStrideOpInterface::getStaticStridesAttrName(),
+        ::mlir::OpTrait::AttrSizedOperandSegments<void>::getOperandSegmentSizeAttr()};
       return names;
    }
   }];
 
   let verify = [{
-    return mlir::verify(cast<OffsetSizeAndStrideOpInterface>($_op));
+    return ::mlir::verify(::mlir::cast<::mlir::OffsetSizeAndStrideOpInterface>($_op));
   }];
 }
 
 #endif // MLIR_INTERFACES_VIEWLIKEINTERFACE