[mlir][NFC] Use proper c++ namespaces in .td files

[lipracer]

Summary

td files:
mlir::ArrayRef => llvm::ArrayRef
mlir::Optional=>llvm::Optional
mlir::SmallVector => llvm::SmallVector

[rriddle]

Can you improve the commit title/description? Right now it isn't super clear, e.g. maybe just: [mlir][NFC] Use proper c++ namespaces in .td files?

[lipracer]

done.

[lipracer]

I don't have permission to commit.Can you help to commit this?

mlir/include/mlir/Interfaces/CallInterfaces.td

InterfaceMethod<[{
         function.
       }],
       "::mlir::Region *", "getCallableRegion"
     >,
     InterfaceMethod<[{
         Returns the results types that the callable region produces when
         executed.
       }],
-      "::mlir::ArrayRef<::mlir::Type>", "getCallableResults"
+      "::llvm::ArrayRef<::mlir::Type>", "getCallableResults"
     >,
   ];
 }
 
 #endif // MLIR_INTERFACES_CALLINTERFACES

mlir/include/mlir/Interfaces/ControlFlowInterfaces.td

InterfaceMethod<[{
       "::mlir::SuccessorOperands", "getSuccessorOperands",
       (ins "unsigned":$index)
     >,
     InterfaceMethod<[{
         Returns the `BlockArgument` corresponding to operand `operandIndex` in
         some successor, or None if `operandIndex` isn't a successor operand
         index.
       }],
-      "::mlir::Optional<::mlir::BlockArgument>", "getSuccessorBlockArgument",
+      "::llvm::Optional<::mlir::BlockArgument>", "getSuccessorBlockArgument",
       (ins "unsigned":$operandIndex), [{
         ::mlir::Operation *opaqueOp = $_op;
         for (unsigned i = 0, e = opaqueOp->getNumSuccessors(); i != e; ++i) {
-          if (::mlir::Optional<::mlir::BlockArgument> arg = ::mlir::detail::getBranchSuccessorArgument(
+          if (::llvm::Optional<::mlir::BlockArgument> arg = ::mlir::detail::getBranchSuccessorArgument(
                 $_op.getSuccessorOperands(i), operandIndex,
                 opaqueOp->getSuccessor(i)))
             return arg;
         }
         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.
       }],
       "::mlir::Block *", "getSuccessorForOperands",
-      (ins "::mlir::ArrayRef<::mlir::Attribute>":$operands), [{}],
+      (ins "::llvm::ArrayRef<::mlir::Attribute>":$operands), [{}],
       /*defaultImplementation=*/[{ return nullptr; }]
     >,
     InterfaceMethod<[{
         This method is called to compare types along control-flow edges. By
         default, the types are checked as equal.
       }],
       "bool", "areTypesCompatible",
       (ins "::mlir::Type":$lhs, "::mlir::Type":$rhs), [{}],
InterfaceMethod<[{
         valid, `operands` corresponds to the entry 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 "::mlir::Optional<unsigned>":$index,
-           "::mlir::ArrayRef<::mlir::Attribute>":$operands,
+      (ins "::llvm::Optional<unsigned>":$index,
+           "::llvm::ArrayRef<::mlir::Attribute>":$operands,
            "::llvm::SmallVectorImpl<::mlir::RegionSuccessor> &":$regions)
     >,
     InterfaceMethod<[{
         Populates `invocationBounds` with the minimum and maximum 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).
         The minimum number of invocations is at least 0. If the maximum number
         of invocations cannot be statically determined, then it will not have a
         value (i.e., it is set to `llvm::None`).
 
         `operands` is a set of optional attributes that either correspond to
         constant values for each operand of this operation or null if that
         operand is not a constant.
 
         This method may be called speculatively on operations where the provided
         operands are not necessarily the same as the operation's current
         operands. This may occur in analyses that wish to determine "what would
         be the region invocations if these were the operands?"
       }],
       "void", "getRegionInvocationBounds",
-      (ins "::mlir::ArrayRef<::mlir::Attribute>":$operands,
+      (ins "::llvm::ArrayRef<::mlir::Attribute>":$operands,
            "::llvm::SmallVectorImpl<::mlir::InvocationBounds> &"
              :$invocationBounds), [{}],
        [{ invocationBounds.append($_op->getNumRegions(),
                                   ::mlir::InvocationBounds::getUnknown()); }]
     >,
     InterfaceMethod<[{
         This method is called to compare types along control-flow edges. By
         default, the types are checked as equal.
def RegionBranchTerminatorOpInterface :
   let methods = [
     InterfaceMethod<[{
         Returns a mutable range of operands that are semantically "returned" by
         passing them to the region successor given by `index`.  If `index` is
         None, this function returns the operands that are passed as a result to
         the parent operation.
       }],
       "::mlir::MutableOperandRange", "getMutableSuccessorOperands",
-      (ins "::mlir::Optional<unsigned>":$index)
+      (ins "::llvm::Optional<unsigned>":$index)
     >,
     InterfaceMethod<[{
         Returns a range of operands that are semantically "returned" by passing
         them to the region successor given by `index`.  If `index` is None, this
         function returns the operands that are passed as a result to the parent
         operation.
       }],
       "::mlir::OperandRange", "getSuccessorOperands",
-      (ins "::mlir::Optional<unsigned>":$index), [{}],
+      (ins "::llvm::Optional<unsigned>":$index), [{}],
       /*defaultImplementation=*/[{
         return $_op.getMutableSuccessorOperands(index);
       }]
     >
   ];
 
   let verify = [{
     static_assert(ConcreteOp::template hasTrait<OpTrait::IsTerminator>(),

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

StaticInterfaceMethod<
 
       Unknown (e.g., unranked) shape and nullptrs for element type and attribute
       may be returned by this function while returning success. E.g., partial
       population of components is not error condition.
       }],
       /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"inferReturnTypeComponents",
       /*args=*/(ins "::mlir::MLIRContext*":$context,
-                    "::mlir::Optional<::mlir::Location>":$location,
+                    "::llvm::Optional<::mlir::Location>":$location,
                     "::mlir::ValueShapeRange":$operands,
                     "::mlir::DictionaryAttr":$attributes,
                     "::mlir::RegionRange":$regions,
                     "::llvm::SmallVectorImpl<::mlir::ShapedTypeComponents>&":
                       $inferredReturnShapes),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >,

mlir/include/mlir/Interfaces/LoopLikeInterface.td

InterfaceMethod<[{
       (ins "::mlir::Operation *":$op), [{}], [{
         op->moveBefore($_op);
       }]
     >,
     InterfaceMethod<[{
         If there is a single induction variable return it, otherwise return
         llvm::None.
       }],
-      /*retTy=*/"::mlir::Optional<::mlir::Value>",
+      /*retTy=*/"::llvm::Optional<::mlir::Value>",
       /*methodName=*/"getSingleInductionVar",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return llvm::None;
       }]
     >,
     InterfaceMethod<[{
         Return the single lower bound value or attribute if it exists, otherwise
         return llvm::None.
       }],
-      /*retTy=*/"::mlir::Optional<::mlir::OpFoldResult>",
+      /*retTy=*/"::llvm::Optional<::mlir::OpFoldResult>",
       /*methodName=*/"getSingleLowerBound",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return llvm::None;
       }]
     >,
     InterfaceMethod<[{
         Return the single step value or attribute if it exists, otherwise
         return llvm::None.
       }],
-      /*retTy=*/"::mlir::Optional<::mlir::OpFoldResult>",
+      /*retTy=*/"::llvm::Optional<::mlir::OpFoldResult>",
       /*methodName=*/"getSingleStep",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return llvm::None;
       }]
     >,
     InterfaceMethod<[{
         Return the single upper bound value or attribute if it exists, otherwise
         return llvm::None.
       }],
-      /*retTy=*/"::mlir::Optional<::mlir::OpFoldResult>",
+      /*retTy=*/"::llvm::Optional<::mlir::OpFoldResult>",
       /*methodName=*/"getSingleUpperBound",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         return llvm::None;
       }]
     >,
   ];
 }
 
 #endif // MLIR_INTERFACES_LOOPLIKEINTERFACE

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=*/"::mlir::Optional<::llvm::SmallVector<int64_t, 4>>",
+      /*retTy=*/"::llvm::Optional<::llvm::SmallVector<int64_t, 4>>",
       /*methodName=*/"getShapeForUnroll",
       /*args=*/(ins),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
         assert($_op->getNumResults() == 1);
         auto vt = $_op.getResult().getType().
           template dyn_cast<::mlir::VectorType>();
         if (!vt)
InterfaceMethod<
           if ($_op.isBroadcastDim(i))
             return true;
         }
         return false;
       }]
     >,
     InterfaceMethod<
       /*desc=*/"Return the `in_bounds` boolean ArrayAttr.",
-      /*retTy=*/"::mlir::Optional<::mlir::ArrayAttr>",
+      /*retTy=*/"::llvm::Optional<::mlir::ArrayAttr>",
       /*methodName=*/"in_bounds",
       /*args=*/(ins),
       /*methodBody=*/"return $_op.getInBounds();"
       /*defaultImplementation=*/
     >,
     InterfaceMethod<
       /*desc=*/"Return the ShapedType.",
       /*retTy=*/"::mlir::ShapedType",