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

[vinograd47]

Summary

Some extra cases that were not covered in 6da0184b.

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

let methods = [
         /*retType=*/"bool",
         /*methodName=*/"resultBufferizesToMemoryWrite",
         /*args=*/(ins "::mlir::OpResult":$opResult,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           assert(opResult.getDefiningOp() == $_op.getOperation() &&
                  "invalid OpResult");
-          return bufferization::detail::defaultResultBufferizesToMemoryWrite(
+          return ::mlir::bufferization::detail::defaultResultBufferizesToMemoryWrite(
               opResult, state);
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the given OpOperand must bufferize in-place. Alias
           sets and inplace attributes will be set up accordingly before making
           any other bufferization decisions. This method will never be called on
           OpOperands that do not have a tensor type.
 
           Note: Unranked tensor OpOperands always bufferize in-place. This could
           be extended in the future. Unranked tensors are used with external
           functions only.
         }],
         /*retType=*/"bool",
         /*methodName=*/"mustBufferizeInPlace",
         /*args=*/(ins "::mlir::OpOperand &":$opOperand,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
-          return opOperand.get().getType().isa<UnrankedTensorType>();
+          return opOperand.get().getType().isa<::mlir::UnrankedTensorType>();
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return the OpResults that may alias with a given OpOperand when
           bufferized in-place. This method will never be called on OpOperands
           that do not have a tensor type.
 
let methods = [
         }],
         /*retType=*/"::mlir::bufferization::AliasingOpResultList",
         /*methodName=*/"getAliasingOpResults",
         /*args=*/(ins "::mlir::OpOperand &":$opOperand,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           // Does not have to be implemented for ops without tensor OpOperands.
-          assert(opOperand.get().getType().isa<TensorType>() &&
+          assert(opOperand.get().getType().isa<::mlir::TensorType>() &&
                  "expected OpOperand with tensor type");
           llvm_unreachable("getAliasingOpResults not implemented");
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return the OpOperands that alias with a given OpResult when
           bufferized in-place. This method will never be called on OpResults
let methods = [
           %r = te
         }],
         /*retType=*/"::mlir::bufferization::AliasingOpOperandList",
         /*methodName=*/"getAliasingOpOperands",
         /*args=*/(ins "::mlir::OpResult":$opResult,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
-          assert(opResult.getType().isa<TensorType>() &&
+          assert(opResult.getType().isa<::mlir::TensorType>() &&
                  "expected OpResult with tensor type");
           return ::mlir::bufferization::detail::defaultGetAliasingOpOperands(
               opResult, state);
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return the buffer relation between the given OpResult and its aliasing
let methods = [
         }],
         /*retType=*/"::mlir::LogicalResult",
         /*methodName=*/"resolveConflicts",
         /*args=*/(ins "::mlir::RewriterBase &":$rewriter,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           auto bufferizableOp =
-              cast<BufferizableOpInterface>($_op.getOperation());
+              ::llvm::cast<BufferizableOpInterface>($_op.getOperation());
           return bufferizableOp.resolveTensorOpOperandConflicts(
               rewriter, state);
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Bufferize this op, i.e., rewrite it into a memref-based equivalent.
           Buffers of tensor SSA values can be retrieved via `getBuffer`.
let methods = [
         }],
         /*retType=*/"::mlir::LogicalResult",
         /*methodName=*/"bufferize",
         /*args=*/(ins "::mlir::RewriterBase &":$rewriter,
                       "const ::mlir::bufferization::BufferizationOptions &":$options),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           llvm_unreachable("bufferize not implemented");
-          return failure();
+          return ::mlir::failure();
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the given Value can be written to in-place. Value is
           either an OpResult of this operation or a BlockArgument of a block of
           this operation.
 
           Most OpResult buffers can be written to, but some ops such as
           ConstantOp may bufferize to non-writable (read-only) memory locations.
           Therefore, by default, this method returns `true` for OpResults. This
           method will never be called on OpResults that do not have a tensor
           type.
 
           Whether a BlockArgument can be written to or not depends on the
           operation. This method conservatively returns `false`. This method
           will never be called on BlockArguments that do not have a tensor type.
         }],
         /*retType=*/"bool",
         /*methodName=*/"isWritable",
         /*args=*/(ins "::mlir::Value":$value,
                       "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
-          return value.isa<OpResult>();
+          return value.isa<::mlir::OpResult>();
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the `uRead` and `uWrite` do not constitute a RaW
           conflict. If they are conflicting or if it is unknown whether they are
           conflicting, return `false`. This method will never be called with
           OpOperands that do not have a tensor type. At least one of the two
let methods = [
           This method can be used to check expected invariants and limitations
           of the current bufferization implementation.
         }],
         /*retType=*/"::mlir::LogicalResult",
         /*methodName=*/"verifyAnalysis",
         /*args=*/(ins "const ::mlir::bufferization::AnalysisState &":$state),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
-          return success();
+          return ::mlir::success();
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return the bufferized type of the given tensor value (without
           bufferizing the IR). The value is either a BlockArgument of a block
           that belongs to this op or an OpResult of the given op.
 
           This method is useful when the bufferized type of value must be
           predicted before modifying any IR.
         }],
         /*retType=*/"::mlir::FailureOr<::mlir::BaseMemRefType>",
         /*methodName=*/"getBufferType",
         /*args=*/(ins "::mlir::Value":$value,
                       "const ::mlir::bufferization::BufferizationOptions &":$options,
                       "const ::mlir::DenseMap<::mlir::Value, ::mlir::BaseMemRefType>":$fixedTypes),
         /*methodBody=*/"",
         /*defaultImplementation=*/[{
           assert(getOwnerOfValue(value) == $_op.getOperation() &&
                  "expected that value belongs to this op");
-          return bufferization::detail::defaultGetBufferType(
+          return ::mlir::bufferization::detail::defaultGetBufferType(
               value, options, fixedTypes);
         }]
       >,
       InterfaceMethod<
         /*desc=*/[{
           Return `true` if the given region of this op is repetitive. By default
           this information is queried from the `RegionBranchOpInterface`. Ops
           that do not implement this inferface can override this method to
           declare regions as repetitive.
 
           The RaW conflict detection of One-Shot Analysis is more strict inside
           repetitive regions: Op dominance cannot always be used to rule out
           certain potential conflicts (e.g., a conflicting write happening after
           a read), because there may not be a meaningful ordering of certain ops
           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(
-              cast<BufferizableOpInterface>($_op.getOperation()), index);
+              ::llvm::cast<BufferizableOpInterface>($_op.getOperation()), index);
         }]
       >
   ];
 
   let extraClassDeclaration = [{
     /// Resolve out-of-place tensor OpOperands with explicit allocations in the
     /// form of `bufferization.alloc_tensor` ops.
     ::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(
         ::mlir::OpOperand &opOperand,
         const ::mlir::bufferization::AnalysisState &state) {
       auto bufferizableOp =
-          cast<::mlir::bufferization::BufferizableOpInterface>(getOperation());
+          ::llvm::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/SideEffectInterfaceBase.td

let extraClassDeclaration = [{
     }
 
     /// Returns true if this operation only has the given effect.
     template <typename Effect> bool onlyHasEffect() {
       ::llvm::SmallVector<::mlir::SideEffects::EffectInstance<
                                             }] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       return !effects.empty() && ::llvm::all_of(effects, [](const auto &it) {
-        return isa<Effect>(it.getEffect());
+        return ::llvm::isa<Effect>(it.getEffect());
       });
     }
 
     /// Returns true if this operation has no effects.
     bool hasNoEffect() {
       ::llvm::SmallVector<::mlir::SideEffects::EffectInstance<
                                             }] # baseEffect # [{>, 4> effects;
       getEffects(effects);
let extraClassDeclaration = [{
     /// 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<
               }] # baseEffect # [{>, 4> effects;
       getEffects(effects);
       auto it = ::llvm::find_if(effects, [&](auto &it) {
-        return isa<Effect>(it.getEffect()) && it.getValue() == value;
+        return ::llvm::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'.