[mlir] Fully qualify types and expressions in Interfaces

[zero9178]

Summary

This patch adds full qualification to the types and function calls used inside of (Static)InterfaceMethod in OpInterfaces. Without this patch using many of these interfaces in a downstream project yields compiler errors as the types and default implementations are mostly copied verbatim. Without then putting using namespace mlir; in the header file of the implementations of those interfaces, compilation is impossible.

Using fully qualified lookup fixes this issue.

[zero9178]

Add a few more I have missed in the first diff

[lattner]

nice

mlir/include/mlir/Interfaces/CallInterfaces.td

def CallOpInterface : OpInterface<"CallOpInterface"> {
 
   let methods = [
     InterfaceMethod<[{
         Returns the callee of this call-like operation. A `callee` is either a
         reference to a symbol, via SymbolRefAttr, or a reference to a defined
         SSA value. If the reference is an SSA value, the SSA value corresponds
         to a region of a lambda-like operation.
       }],
-      "CallInterfaceCallable", "getCallableForCallee"
+      "::mlir::CallInterfaceCallable", "getCallableForCallee"
     >,
     InterfaceMethod<[{
         Returns the operands within this call that are used as arguments to the
         callee.
       }],
-      "Operation::operand_range", "getArgOperands"
+      "::mlir::Operation::operand_range", "getArgOperands"
     >,
   ];
 
   let extraClassDeclaration = [{
     /// Resolve the callable operation for given callee to a
     /// CallableOpInterface, or nullptr if a valid callable was not resolved.
     /// `symbolTable` is an optional parameter that will allow for using a
     /// cached symbol table for symbol lookups instead of performing an O(N)
def CallableOpInterface : OpInterface<"CallableOpInterface"> {
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<[{
         Returns the region on the current operation that is callable. This may
         return null in the case of an external callable object, e.g. an external
         function.
       }],
-      "Region *", "getCallableRegion"
+      "::mlir::Region *", "getCallableRegion"
     >,
     InterfaceMethod<[{
         Returns the results types that the callable region produces when
         executed.
       }],
-      "ArrayRef<Type>", "getCallableResults"
+      "::mlir::ArrayRef<::mlir::Type>", "getCallableResults"
     >,
   ];
 }
 
 #endif // MLIR_INTERFACES_CALLINTERFACES

mlir/include/mlir/Interfaces/CastInterfaces.td

def CastOpInterface : OpInterface<"CastOpInterface"> {
   let cppNamespace = "::mlir";
 
   let methods = [
     StaticInterfaceMethod<[{
         Returns true if the given set of input and result types are compatible
         to cast using this cast operation.
       }],
       "bool", "areCastCompatible",
-      (ins "mlir::TypeRange":$inputs, "mlir::TypeRange":$outputs)
+      (ins "::mlir::TypeRange":$inputs, "::mlir::TypeRange":$outputs)
     >,
   ];
 
   let extraTraitClassDeclaration = [{
     /// Attempt to fold the given cast operation.
     static LogicalResult foldTrait(Operation *op, ArrayRef<Attribute> operands,
                                    SmallVectorImpl<OpFoldResult> &results) {
       return impl::foldCastInterfaceOp(op, operands, results);
     }
   }];
   let verify = [{
     return impl::verifyCastInterfaceOp($_op, ConcreteOp::areCastCompatible);
   }];
 }
 
 #endif // MLIR_INTERFACES_CASTINTERFACES

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

def BranchOpInterface : OpInterface<"BranchOpInterface"> {
 
   let methods = [
     InterfaceMethod<[{
         Returns a mutable range of operands that correspond to the arguments of
         successor at the given index. Returns None if the operands to the
         successor are non-materialized values, i.e. they are internal to the
         operation.
       }],
-      "Optional<MutableOperandRange>", "getMutableSuccessorOperands",
+      "::mlir::Optional<::mlir::MutableOperandRange>", "getMutableSuccessorOperands",
       (ins "unsigned":$index)
     >,
     InterfaceMethod<[{
         Returns a range of operands that correspond to the arguments of
         successor at the given index. Returns None if the operands to the
         successor are non-materialized values, i.e. they are internal to the
         operation.
       }],
-      "Optional<OperandRange>", "getSuccessorOperands",
+      "::mlir::Optional<::mlir::OperandRange>", "getSuccessorOperands",
       (ins "unsigned":$index), [{}], [{
         ConcreteOp *op = static_cast<ConcreteOp *>(this);
         auto operands = op->getMutableSuccessorOperands(index);
-        return operands ? Optional<OperandRange>(*operands) : llvm::None;
+        return operands ? ::mlir::Optional<::mlir::OperandRange>(*operands) : ::llvm::None;
       }]
     >,
     InterfaceMethod<[{
         Returns the `BlockArgument` corresponding to operand `operandIndex` in
         some successor, or None if `operandIndex` isn't a successor operand
         index.
       }],
-      "Optional<BlockArgument>", "getSuccessorBlockArgument",
+      "::mlir::Optional<::mlir::BlockArgument>", "getSuccessorBlockArgument",
       (ins "unsigned":$operandIndex), [{
-        Operation *opaqueOp = $_op;
+        ::mlir::Operation *opaqueOp = $_op;
         for (unsigned i = 0, e = opaqueOp->getNumSuccessors(); i != e; ++i) {
-          if (Optional<BlockArgument> arg = detail::getBranchSuccessorArgument(
+          if (::mlir::Optional<::mlir::BlockArgument> arg = ::mlir::detail::getBranchSuccessorArgument(
                 $_op.getSuccessorOperands(i), operandIndex,
                 opaqueOp->getSuccessor(i)))
             return arg;
         }
-        return llvm::None;
+        return ::llvm::None;
       }]
     >,
     InterfaceMethod<[{
         Returns the successor that would be chosen with the given constant
         operands. Returns nullptr if a single successor could not be chosen.
       }],
-      "Block *", "getSuccessorForOperands",
-      (ins "ArrayRef<Attribute>":$operands), [{}],
+      "::mlir::Block *", "getSuccessorForOperands",
+      (ins "::mlir::ArrayRef<::mlir::Attribute>":$operands), [{}],
       /*defaultImplementation=*/[{ return nullptr; }]
     >
   ];
 
   let verify = [{
-    auto concreteOp = cast<ConcreteOp>($_op);
+    auto concreteOp = ::mlir::cast<ConcreteOp>($_op);
     for (unsigned i = 0, e = $_op->getNumSuccessors(); i != e; ++i) {
-      Optional<OperandRange> operands = concreteOp.getSuccessorOperands(i);
-      if (failed(detail::verifyBranchSuccessorOperands($_op, i, operands)))
-        return failure();
+      ::mlir::Optional<OperandRange> operands = concreteOp.getSuccessorOperands(i);
+      if (::mlir::failed(::mlir::detail::verifyBranchSuccessorOperands($_op, i, operands)))
+        return ::mlir::failure();
     }
-    return success();
+    return ::mlir::success();
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // RegionBranchOpInterface
 //===----------------------------------------------------------------------===//
 
 def RegionBranchOpInterface : OpInterface<"RegionBranchOpInterface"> {
   let description = [{
     This interface provides information for region operations that contain
     branching behavior between held regions, i.e. this interface allows for
     expressing control flow information for region holding operations.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<[{
         Returns the operands of this operation used as the entry arguments when
         entering the region at `index`, which was specified as a successor of this
         operation by `getSuccessorRegions`. These operands should correspond 1-1
         with the successor inputs specified in `getSuccessorRegions`.
       }],
-      "OperandRange", "getSuccessorEntryOperands",
+      "::mlir::OperandRange", "getSuccessorEntryOperands",
       (ins "unsigned":$index), [{}], /*defaultImplementation=*/[{
         auto operandEnd = this->getOperation()->operand_end();
-        return OperandRange(operandEnd, operandEnd);
+        return ::mlir::OperandRange(operandEnd, operandEnd);
       }]
     >,
     InterfaceMethod<[{
         Returns the viable successors of a region at `index`, or the possible
         successors when branching from the parent op if `index` is None. These
         are the regions that may be selected during the flow of control. If
         `index` is None, `operands` is a set of optional attributes that
         either correspond to a constant value for each operand of this
         operation, or null if that operand is not a constant. If `index` is
         valid, `operands` corresponds to the exit values of the region at
         `index`. Only a region, i.e. a valid `index`, may use the parent
         operation as a successor. This method allows for describing which
         regions may be executed when entering an operation, and which regions
         are executed after having executed another region of the parent op. The
         successor region must be non-empty.
       }],
       "void", "getSuccessorRegions",
-      (ins "Optional<unsigned>":$index, "ArrayRef<Attribute>":$operands,
-           "SmallVectorImpl<RegionSuccessor> &":$regions)
+      (ins "::mlir::Optional<unsigned>":$index, "::mlir::ArrayRef<::mlir::Attribute>":$operands,
+           "::mlir::SmallVectorImpl<::mlir::RegionSuccessor> &":$regions)
     >,
     InterfaceMethod<[{
         Populates countPerRegion with the number of times this operation will
         invoke the attached regions (assuming the regions yield normally, i.e.
         do not abort or invoke an infinite loop). If the number of region
         invocations is not known statically it will set the number of
         invocations to `kUnknownNumRegionInvocations`.
 
         `operands` is a set of optional attributes that either correspond to a
         constant values for each operand of this operation, or null if that
         operand is not a constant.
       }],
       "void", "getNumRegionInvocations",
-      (ins "ArrayRef<Attribute>":$operands,
-           "SmallVectorImpl<int64_t> &":$countPerRegion), [{}],
+      (ins "::mlir::ArrayRef<::mlir::Attribute>":$operands,
+           "::mlir::SmallVectorImpl<int64_t> &":$countPerRegion), [{}],
       /*defaultImplementation=*/[{
         unsigned numRegions = this->getOperation()->getNumRegions();
         assert(countPerRegion.empty());
         countPerRegion.resize(numRegions, kUnknownNumRegionInvocations);
       }]
     >
   ];
 

mlir/include/mlir/Interfaces/DataLayoutInterfaces.td

def DataLayoutSpecInterface : AttrInterface<"DataLayoutSpecInterface"> {
 
   let methods = [
     InterfaceMethod<
       /*description=*/"Combines the current layout with the given list of "
                       "layouts, provided from the outermost (oldest) to the "
                       "innermost (newest). Returns null on failure.",
       /*retTy=*/"::mlir::DataLayoutSpecInterface",
       /*methodName=*/"combineWith",
-      /*args=*/(ins "::llvm::ArrayRef<DataLayoutSpecInterface>":$specs)
+      /*args=*/(ins "::llvm::ArrayRef<::mlir::DataLayoutSpecInterface>":$specs)
     >,
     InterfaceMethod<
       /*description=*/"Returns the list of layout entries.",
       /*retTy=*/"::mlir::DataLayoutEntryListRef",
       /*methodName=*/"getEntries",
       /*args=*/(ins)
     >,
     // Implementations may override this if they have an efficient lookup
let description = [{
     list of data layout entries relevant to the request. The entries are known
     to have passed the spec and entry verifier.
   }];
 
   let methods = [
     InterfaceMethod<
       /*description=*/"Returns the data layout specification for this op, or "
                       "null if it does not exist.",
-      /*retTy=*/"DataLayoutSpecInterface",
+      /*retTy=*/"::mlir::DataLayoutSpecInterface",
       /*methodName=*/"getDataLayoutSpec",
       /*args=*/(ins)
     >,
     StaticInterfaceMethod<
       /*description=*/"Returns the size of the given type computed using the "
                       "relevant entries. The data layout object can be used "
                       "for recursive queries.",
       /*retTy=*/"unsigned",

mlir/include/mlir/Interfaces/DerivedAttributeOpInterface.td

def DerivedAttributeOpInterface : OpInterface<"DerivedAttributeOpInterface"> {
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     StaticInterfaceMethod<
       /*desc=*/"Returns whether name corresponds to a derived attribute.",
       /*retTy=*/"bool",
       /*methodName=*/"isDerivedAttribute",
-      /*args=*/(ins "StringRef":$name)
+      /*args=*/(ins "::mlir::StringRef":$name)
     >,
     InterfaceMethod<
       /*desc=*/[{
         Materializes the derived attributes. Returns null attribute where
         unable to materialize a derived attribute as attribute.
       }],
-      /*retTy=*/"DictionaryAttr",
+      /*retTy=*/"::mlir::DictionaryAttr",
       /*methodName=*/"materializeDerivedAttributes"
     >,
   ];
 }
 
 #endif // MLIR_DERIVEDATTRIBUTEOPINTERFACE

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

InterfaceMethod<
       the design of the conversion pattern, that is, accepting passed in
       operands to avoid calling `getOperand` directly inside the interface
       implementation.
       }],
       /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"reifyReturnTypeShapes",
       /*args=*/(ins "::mlir::OpBuilder&":$builder,
           "::mlir::ValueRange":$operands,
-          "::mlir::SmallVectorImpl<Value> &":$reifiedReturnShapes),
+          "::mlir::SmallVectorImpl<::mlir::Value> &":$reifiedReturnShapes),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >,
     InterfaceMethod<
       /*desc=*/[{Reify the shape computation for the operation.
 
       Insert operations using the given OpBuilder that computes the
       result shape. The `reifiedReturnShapes` is expected to be
InterfaceMethod<
       adding additional instructions to aggregate individual dimension
       of a result shape into an single `Value` (and consequently
       avoids the need to extract the value from the shape on the
       client side).
       }],
       /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"reifyReturnTypeShapesPerResultDim",
       /*args=*/(ins "::mlir::OpBuilder&":$builder,
-          "::mlir::SmallVectorImpl<SmallVector<::mlir::Value>>&"
+          "::mlir::SmallVectorImpl<::mlir::SmallVector<::mlir::Value>>&"
           :$reifiedReturnShapes),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >
   ];
 }
 
 // Convenience class grouping together type and shaped type op interfaces for

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

 // class, as well as the name of the base effect class.
 class EffectOpInterfaceBase<string name, string baseEffect>
     : OpInterface<name> {
   let methods = [
     InterfaceMethod<[{
         Collects all of the operation's effects into `effects`.
       }],
       "void", "getEffects",
-         (ins "SmallVectorImpl<::mlir::SideEffects::EffectInstance<"
+         (ins "::mlir::SmallVectorImpl<::mlir::SideEffects::EffectInstance<"
               # baseEffect # ">> &":$effects)
     >,
   ];
 
   let extraClassDeclaration = [{
     /// Collect all of the effect instances that correspond to the given
     /// `Effect` and place them in 'effects'.
     template <typename Effect> void getEffects(

mlir/include/mlir/Interfaces/VectorInterfaces.td

def VectorUnrollOpInterface : OpInterface<"VectorUnrollOpInterface"> {
 
   let methods = [
     InterfaceMethod<
       /*desc=*/[{
         Return the shape ratio of unrolling to the target vector shape
         `targetShape`. Return `None` if the op cannot be unrolled to the target
         vector shape.
       }],
-      /*retTy=*/"Optional<SmallVector<int64_t, 4>>",
+      /*retTy=*/"::mlir::Optional<::mlir::SmallVector<int64_t, 4>>",
       /*methodName=*/"getShapeForUnroll",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op->getNumResults() == 1);
         auto vt = $_op.getResult().getType().
-          template dyn_cast<VectorType>();
+          template dyn_cast<::mlir::VectorType>();
         if (!vt)
-          return None;
-        SmallVector<int64_t, 4> res(vt.getShape().begin(), vt.getShape().end());
+          return ::mlir::None;
+        ::mlir::SmallVector<int64_t, 4> res(vt.getShape().begin(), vt.getShape().end());
         return res;
       }]
     >,
   ];
 }
 
 def VectorTransferOpInterface : OpInterface<"VectorTransferOpInterface"> {
   let description = [{
     Encodes properties of a transfer read or write operation.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     StaticInterfaceMethod<
       /*desc=*/"Return the `in_bounds` attribute name.",
-      /*retTy=*/"StringRef",
+      /*retTy=*/"::mlir::StringRef",
       /*methodName=*/"getInBoundsAttrName",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/ [{ return "in_bounds"; }]
     >,
     StaticInterfaceMethod<
       /*desc=*/"Return the `permutation_map` attribute name.",
-      /*retTy=*/"StringRef",
+      /*retTy=*/"::mlir::StringRef",
       /*methodName=*/"getPermutationMapAttrName",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/ [{ return "permutation_map"; }]
     >,
     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<ArrayAttr>()[dim]
-                                    .template cast<BoolAttr>().getValue());
+                && $_op.in_bounds()->template cast<::mlir::ArrayAttr>()[dim]
+                                    .template cast<::mlir::BoolAttr>().getValue());
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the memref or ranked tensor operand.",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"source",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.source();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the vector operand or result.",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"vector",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.vector();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the indices operands.",
-      /*retTy=*/"ValueRange",
+      /*retTy=*/"::mlir::ValueRange",
       /*methodName=*/"indices",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.indices();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the permutation map.",
-      /*retTy=*/"AffineMap",
+      /*retTy=*/"::mlir::AffineMap",
       /*methodName=*/"permutation_map",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.permutation_map();"
       /*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);
-        return expr.template isa<AffineConstantExpr>() &&
-               expr.template dyn_cast<AffineConstantExpr>().getValue() == 0;
+        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; i < $_op.permutation_map().getNumResults(); ++i) {
           if ($_op.isBroadcastDim(i))
             return true;
         }
         return false;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the `in_bounds` boolean ArrayAttr.",
-      /*retTy=*/"Optional<ArrayAttr>",
+      /*retTy=*/"::mlir::Optional<::mlir::ArrayAttr>",
       /*methodName=*/"in_bounds",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.in_bounds();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the ShapedType.",
-      /*retTy=*/"ShapedType",
+      /*retTy=*/"::mlir::ShapedType",
       /*methodName=*/"getShapedType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/
-        "return $_op.source().getType().template cast<ShapedType>();"
+        "return $_op.source().getType().template cast<::mlir::ShapedType>();"
     >,
     InterfaceMethod<
       /*desc=*/"Return the VectorType.",
-      /*retTy=*/"VectorType",
+      /*retTy=*/"::mlir::VectorType",
       /*methodName=*/"getVectorType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return $_op.vector().getType().template dyn_cast<VectorType>();
+        return $_op.vector().getType().template dyn_cast<::mlir::VectorType>();
         }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the mask type if the op has a mask.",
-      /*retTy=*/"VectorType",
+      /*retTy=*/"::mlir::VectorType",
       /*methodName=*/"getMaskType",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.mask()
-            ? mlir::vector::detail::transferMaskType(
+            ? ::mlir::vector::detail::transferMaskType(
                 $_op.getVectorType(), $_op.permutation_map())
-            : VectorType();
+            : ::mlir::VectorType();
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Return the number of dimensions that participate in the
                   permutation map.}],
       /*retTy=*/"unsigned",
       /*methodName=*/"getTransferRank",
       /*args=*/(ins),
InterfaceMethod<
            memref<?x?x?x?xf32>, vector<2x4xf32>
       ```
       with `permutation_map = (d0, d1, d2, d3) -> (d2, d3)`.
       Provide a zip function to coiterate on 2 running indices: `resultIdx` and
       `indicesIdx` which accounts for this misalignment.
       }],
       /*retTy=*/"void",
       /*methodName=*/"zipResultAndIndexing",
-      /*args=*/(ins "llvm::function_ref<void(int64_t, int64_t)>":$fun),
+      /*args=*/(ins "::llvm::function_ref<void(int64_t, int64_t)>":$fun),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         for (int64_t resultIdx = 0,
                    indicesIdx = $_op.getLeadingShapedRank(),
                    eResult = $_op.getTransferRank();
            resultIdx < eResult;
            ++resultIdx, ++indicesIdx)
         fun(resultIdx, indicesIdx);
       }]
     >,
   ];
 }
 
 #endif // MLIR_INTERFACES_VECTORINTERFACES

mlir/include/mlir/Interfaces/ViewLikeInterface.td

let methods = [
     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 "OffsetSizeAndStrideOpInterface":$other,
-                   "llvm::function_ref<bool(OpFoldResult, OpFoldResult)>":$cmp),
+      /*args=*/(ins "::mlir::OffsetSizeAndStrideOpInterface":$other,
+                   "::llvm::function_ref<bool(::mlir::OpFoldResult, ::mlir::OpFoldResult)>":$cmp),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return detail::sameOffsetsSizesAndStrides(
+        return ::mlir::detail::sameOffsetsSizesAndStrides(
           ::mlir::cast<::mlir::OffsetSizeAndStrideOpInterface>(
             $_op.getOperation()), other, cmp);
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Return true if all strides are guaranteed to be 1. }],
       /*retTy=*/"bool",
       /*methodName=*/"hasUnitStride",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::llvm::all_of(getMixedStrides(), [](OpFoldResult ofr) {
+        return ::llvm::all_of(getMixedStrides(), [](::mlir::OpFoldResult ofr) {
           return ::mlir::getConstantIntValue(ofr) == static_cast<int64_t>(1);
         });
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Return true if all offsets are guaranteed to be 0. }],
       /*retTy=*/"bool",
       /*methodName=*/"hasZeroOffset",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::llvm::all_of(getMixedOffsets(), [](OpFoldResult ofr) {
+        return ::llvm::all_of(getMixedOffsets(), [](::mlir::OpFoldResult ofr) {
           return ::mlir::getConstantIntValue(ofr) == static_cast<int64_t>(0);
         });
       }]
     >,
   ];
 
   let extraClassDeclaration = [{
     static unsigned getOffsetOperandGroupPosition() { return 0; }