[mlir][NFC] Use fully qualified C++ namespaces in .td files.

[vinograd47]

Summary

Add missing llvm:: and mlir:: namespaces qualifiers to some auto-generated code.

[ftynse]

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td

475–477

Nit: we prefer global fully qualified names, ::mlir::foo here in case the code is being emitted inside something like namespace myproject::mlir.

[vinograd47]

@ftynse Fixed.

[ftynse]

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

64

Also ::llvm here :)

[vinograd47]

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

64

As I can see, in all other places in this file llvm namespace is used without leading ::. So I decided to keep consistency :)

[ftynse]

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

64

I'd suggest updating those too.

mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.td

let methods = [
           that are executed multiple times. This is described in more detail in
           documentation of One-Shot Analysis.
         }],
         /*retType=*/"bool",
         /*methodName=*/"isRepetitiveRegion",
         /*args=*/(ins "unsigned":$index),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
-          return mlir::bufferization::detail::defaultIsRepetitiveRegion(
+          return ::mlir::bufferization::detail::defaultIsRepetitiveRegion(
               cast<BufferizableOpInterface>($_op.getOperation()), index);
         }]
       >
   ];
 
   let extraClassDeclaration = [{
     /// Resolve out-of-place tensor OpOperands with explicit allocations in the
     /// form of `bufferization.alloc_tensor` ops.
-    LogicalResult resolveTensorOpOperandConflicts(
-        RewriterBase &rewriter, const AnalysisState &state);
+    ::mlir::LogicalResult resolveTensorOpOperandConflicts(
+        ::mlir::RewriterBase &rewriter,
+        const ::mlir::bufferization::AnalysisState &state);
 
     /// Return `true` if the given OpOperand creates an alias but does neither
     /// read nor write. This implies that `bufferizesToMemoryRead` and
     /// `bufferizesToMemoryWrite` must return `false`. This method will never
     /// be called on OpOperands that do not have a tensor type.
     ///
     /// Examples of such ops are `tensor.extract_slice` and `tensor.cast`.
-    bool bufferizesToAliasOnly(OpOperand &opOperand,
-                               const AnalysisState &state) {
+    bool bufferizesToAliasOnly(
+        ::mlir::OpOperand &opOperand,
+        const ::mlir::bufferization::AnalysisState &state) {
       auto bufferizableOp =
-          cast<BufferizableOpInterface>(getOperation());
+          cast<::mlir::bufferization::BufferizableOpInterface>(getOperation());
       return !bufferizableOp.bufferizesToMemoryRead(opOperand, state)
           && !bufferizableOp.bufferizesToMemoryWrite(opOperand, state)
           && !bufferizableOp.getAliasingOpResults(opOperand, state).empty();
     }
   }];
 }
 
 #endif  // BUFFERIZABLE_OP_INTERFACE

mlir/include/mlir/Interfaces/DestinationStyleOpInterface.td

InterfaceMethod<
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         auto [start, end] = $_op.getDpsInitsPositionRange();
         return end - start;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the init operands.",
-      /*retTy=*/"OpOperandVector",
+      /*retTy=*/"::mlir::OpOperandVector",
       /*methodName=*/"getDpsInitOperands",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         auto [start, end] = $_op.getDpsInitsPositionRange();
 
-        OpOperandVector result;
+        ::mlir::OpOperandVector result;
         result.reserve(end - start);
         for (int i = start; i < end; ++i)
           result.push_back(&$_op->getOpOperand(i));
         return result;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the `i`-th init operand.",
-      /*retTy=*/"OpOperand *",
+      /*retTy=*/"::mlir::OpOperand *",
       /*methodName=*/"getDpsInitOperand",
       /*args=*/(ins "int64_t":$i),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(i >= 0 && i < $_op.getNumDpsInits());
         auto [start, end] = $_op.getDpsInitsPositionRange();
         return &$_op->getOpOperand(start + i);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Set the `i`-th init operand.",
       /*retTy=*/"void",
       /*methodName=*/"setDpsInitOperand",
-      /*args=*/(ins "int64_t":$i, "Value":$value),
+      /*args=*/(ins "int64_t":$i, "::mlir::Value":$value),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(i >= 0 && i < $_op.getNumDpsInits());
         auto [start, end] = $_op.getDpsInitsPositionRange();
         $_op->setOperand(start + i, value);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the number of inputs.",
       /*retTy=*/"int64_t",
       /*methodName=*/"getNumDpsInputs",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op.getNumOperands() - $_op.getNumDpsInits();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the input operands.",
-      /*retTy=*/"OpOperandVector",
+      /*retTy=*/"::mlir::OpOperandVector",
       /*methodName=*/"getDpsInputOperands",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         auto [start, end] = $_op.getDpsInitsPositionRange();
         int64_t numInits = end - start;
         int64_t numOperands = $_op.getNumOperands();
 
-        OpOperandVector result;
+        ::mlir::OpOperandVector result;
         result.reserve(numOperands - numInits);
         for (int i = 0; i < start; ++i)
           result.push_back(&$_op->getOpOperand(i));
         for (int i = end; i < numOperands; ++i)
           result.push_back(&$_op->getOpOperand(end + i));
 
         return result;
       }]
     >,
     InterfaceMethod<
       /*desc=*/[{ Return the `i`-th input operand.  }],
-      /*retTy=*/"OpOperand *",
+      /*retTy=*/"::mlir::OpOperand *",
       /*methodName=*/"getDpsInputOperand",
       /*args=*/(ins "int64_t":$i),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(i >= 0 && i < getNumDpsInputs());
         auto [start, end] = $_op.getDpsInitsPositionRange();
         return &$_op->getOpOperand(i < start ? i : i + end - start) ;
       }]
     >,
     //===------------------------------------------------------------------===//
     // Input and DpsInit arguments handling.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
       /*desc=*/"Return true if `opOperand` is an input.",
       /*retTy=*/"bool",
       /*methodName=*/"isDpsInput",
-      /*args=*/(ins "OpOperand *":$opOperand),
+      /*args=*/(ins "::mlir::OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         auto [start, end] = $_op.getDpsInitsPositionRange();
         auto operandNumber = opOperand->getOperandNumber();
         return operandNumber < start || operandNumber >= end;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if `opOperand` is an init.",
       /*retTy=*/"bool",
       /*methodName=*/"isDpsInit",
-      /*args=*/(ins "OpOperand *":$opOperand),
+      /*args=*/(ins "::mlir::OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         auto [start, end] = $_op.getDpsInitsPositionRange();
         auto operandNumber = opOperand->getOperandNumber();
         return operandNumber >= start && operandNumber < end;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return true if the `opOperand` is a scalar value.",
       /*retTy=*/"bool",
       /*methodName=*/"isScalar",
-      /*args=*/(ins "OpOperand *":$opOperand),
+      /*args=*/(ins "::mlir::OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == $_op.getOperation());
         return !opOperand->get().getType().template isa<ShapedType>();
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the OpResult that is tied to the given OpOperand.",
-      /*retTy=*/"OpResult",
+      /*retTy=*/"::mlir::OpResult",
       /*methodName=*/"getTiedOpResult",
-      /*args=*/(ins "OpOperand *":$opOperand),
+      /*args=*/(ins "::mlir::OpOperand *":$opOperand),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opOperand->getOwner() == $_op.getOperation());
 
         auto [start, end] = $_op.getDpsInitsPositionRange();
         int64_t resultIndex = opOperand->getOperandNumber() - start;
         assert(resultIndex >= 0 &&
                resultIndex < $_op->getNumResults() );
         return $_op->getResult(resultIndex);
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the OpOperand that is tied to the given OpResult.",
-      /*retTy=*/"OpOperand *",
+      /*retTy=*/"::mlir::OpOperand *",
       /*methodName=*/"getTiedOpOperand",
-      /*args=*/(ins "OpResult":$opResult),
+      /*args=*/(ins "::mlir::OpResult":$opResult),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert(opResult.getDefiningOp() == $_op.getOperation());
         return $_op.getDpsInitOperand(opResult.getResultNumber());
       }]
     >,
     //===------------------------------------------------------------------===//
     // Other interface methods.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
       /*desc=*/"Return whether the op has only ranked MemRef input/inits.",
       /*retTy=*/"bool",
       /*methodName=*/"hasBufferSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return $_op->getNumResults() == 0 &&
-          llvm::all_of($_op->getOpOperands(),
-            [&](OpOperand &opOperand) {
+          ::llvm::all_of($_op->getOpOperands(),
+            [&](::mlir::OpOperand &opOperand) {
               return isScalar(&opOperand) ||
-                     opOperand.get().getType().template isa<MemRefType>();
+                     opOperand.get().getType().template isa<::mlir::MemRefType>();
             });
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return whether the op has only ranked tensor inputs/inits.",
       /*retTy=*/"bool",
       /*methodName=*/"hasTensorSemantics",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return llvm::all_of($_op->getOpOperands(),
-          [&](OpOperand &opOperand) {
+        return ::llvm::all_of($_op->getOpOperands(),
+          [&](::mlir::OpOperand &opOperand) {
             return isScalar(&opOperand) ||
-                   opOperand.get().getType().template isa<RankedTensorType>();
+                   opOperand.get().getType().template isa<::mlir::RankedTensorType>();
           });
       }]
     >
   ];
 
   let verify = [{ return detail::verifyDestinationStyleOpInterface($_op); }];
   let verifyWithRegions = 1;
 }
 
 
 #endif // MLIR_DESTINATIONSTYLEOPINTERFACE

mlir/include/mlir/Interfaces/SideEffectInterfaceBase.td

InterfaceMethod<[{
               # 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(
-      SmallVectorImpl<::mlir::SideEffects::EffectInstance<
+      ::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
                                               }] # baseEffect # [{>> &effects) {
       getEffects(effects);
-      llvm::erase_if(effects, [&](auto &it) {
-        return !llvm::isa<Effect>(it.getEffect());
+      ::llvm::erase_if(effects, [&](auto &it) {
+        return !::llvm::isa<Effect>(it.getEffect());
       });
     }
 
     /// Returns true if this operation exhibits the given effect.
     template <typename Effect> bool hasEffect() {
-      SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
+      ::llvm::SmallVector<::mlir::SideEffects::EffectInstance<
+                                            }] # baseEffect # [{>, 4> effects;
       getEffects(effects);
-      return llvm::any_of(effects, [](const auto &it) {
-        return llvm::isa<Effect>(it.getEffect());
+      return ::llvm::any_of(effects, [](const auto &it) {
+        return ::llvm::isa<Effect>(it.getEffect());
       });
     }
 
     /// Returns true if this operation only has the given effect.
     template <typename Effect> bool onlyHasEffect() {
-      SmallVector<SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
+      ::llvm::SmallVector<::mlir::SideEffects::EffectInstance<
+                                            }] # baseEffect # [{>, 4> effects;
       getEffects(effects);
-      return !effects.empty() && llvm::all_of(effects, [](const auto &it) {
+      return !effects.empty() && ::llvm::all_of(effects, [](const auto &it) {
         return isa<Effect>(it.getEffect());
       });
     }
 
     /// Returns true if this operation has no effects.
     bool hasNoEffect() {
-      SmallVector<::mlir::SideEffects::EffectInstance<}] # baseEffect # [{>, 4> effects;
+      ::llvm::SmallVector<::mlir::SideEffects::EffectInstance<
+                                            }] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       return effects.empty();
     }
 
     /// Collect all of the effect instances that operate on the provided value
     /// and place them in 'effects'.
     void getEffectsOnValue(::mlir::Value value,
-              llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
+              ::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
               }] # baseEffect # [{>> & effects) {
       getEffects(effects);
-      llvm::erase_if(effects, [&](auto &it) { return it.getValue() != value; });
+      ::llvm::erase_if(effects, [&](auto &it) { return it.getValue() != value; });
     }
 
     /// Return the effect of the given type `Effect` that is applied to the
     /// given value, or std::nullopt if no effect exists.
     template <typename Effect>
     ::std::optional<::mlir::SideEffects::EffectInstance<}] # baseEffect # [{>>
     getEffectOnValue(::mlir::Value value) {
-      llvm::SmallVector<::mlir::SideEffects::EffectInstance<
+      ::llvm::SmallVector<::mlir::SideEffects::EffectInstance<
               }] # baseEffect # [{>, 4> effects;
       getEffects(effects);
-      auto it = llvm::find_if(effects, [&](auto &it) {
+      auto it = ::llvm::find_if(effects, [&](auto &it) {
         return isa<Effect>(it.getEffect()) && it.getValue() == value;
       });
       if (it == effects.end())
         return std::nullopt;
       return *it;
     }
 
     /// Collect all of the effect instances that operate on the provided symbol
     /// reference and place them in 'effects'.
     void getEffectsOnSymbol(::mlir::SymbolRefAttr value,
-              llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
+              ::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
               }] # baseEffect # [{>> & effects) {
       getEffects(effects);
-      llvm::erase_if(effects, [&](auto &it) {
+      ::llvm::erase_if(effects, [&](auto &it) {
         return it.getSymbolRef() != value;
       });
     }
 
     /// Collect all of the effect instances that operate on the provided
     /// resource and place them in 'effects'.
     void getEffectsOnResource(::mlir::SideEffects::Resource *resource,
-              llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
+              ::llvm::SmallVectorImpl<::mlir::SideEffects::EffectInstance<
               }] # baseEffect # [{>> & effects) {
       getEffects(effects);
-      llvm::erase_if(effects, [&](auto &it) {
+      ::llvm::erase_if(effects, [&](auto &it) {
         return it.getResource() != resource;
       });
     }
   }];
 
   // The base effect name of this interface.
   string baseEffectName = baseEffect;
 }