mlir/{SPIRV,Bufferization}: use std::optional in .td files (NFC)

[artagnon]

Summary

This is part of an effort to migrate from llvm::Optional to
std::optional. 22426110c5ef changed the way mlir-tblgen generates .inc
files, emitting std::optional when an Optional attribute is specified in
a .td file. It also changed several .td files hard-coding llvm::Optional
to use std::optional. However, the patch excluded a few .td files in
SPIRV and Bufferization hard-coding llvm::Optional. This patch fixes
that defect, and after this patch, references to llvm::Optional in .cpp
and .h files can be replaced mechanically.

See also: https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716

Signed-off-by: Ramkumar Ramachandra <[e-mail]>

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

def AllocationOpInterface : OpInterface<"AllocationOpInterface"> {
   let methods = [
     StaticInterfaceMethod<[{
         Builds a deallocation operation using the provided builder and the
         current allocation value (which refers to the current Op implementing
         this interface). The allocation value is a result of the current
         operation implementing this interface. If there is no compatible
         deallocation operation, this method can return ::std::nullopt.
       }],
-      "::mlir::Optional<::mlir::Operation*>", "buildDealloc",
+      "::std::optional<::mlir::Operation*>", "buildDealloc",
       (ins "::mlir::OpBuilder&":$builder, "::mlir::Value":$alloc), [{}],
       /*defaultImplementation=*/[{ return std::nullopt; }]
     >,
     StaticInterfaceMethod<[{
         Builds a clone operation using the provided builder and the current
         allocation value (which refers to the current Op implementing this
         interface). The allocation value is a result of the current operation
         implementing this interface. If there is no compatible clone operation,
         this method can return ::std::nullopt.
       }],
-      "::mlir::Optional<::mlir::Value>", "buildClone",
+      "::std::optional<::mlir::Value>", "buildClone",
       (ins "::mlir::OpBuilder&":$builder, "::mlir::Value":$alloc), [{}],
       /*defaultImplementation=*/[{ return std::nullopt; }]
     >
   ];
 }
 
 #endif  // ALLOCATION_OP_INTERFACE

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.h

 class InterfaceVarABIAttr
     : public Attribute::AttrBase<InterfaceVarABIAttr, Attribute,
                                  detail::InterfaceVarABIAttributeStorage> {
 public:
   using Base::Base;
 
   /// Gets a InterfaceVarABIAttr.
   static InterfaceVarABIAttr get(uint32_t descriptorSet, uint32_t binding,
-                                 Optional<StorageClass> storageClass,
+                                 std::optional<StorageClass> storageClass,
                                  MLIRContext *context);
   static InterfaceVarABIAttr get(IntegerAttr descriptorSet, IntegerAttr binding,
                                  IntegerAttr storageClass);
 
   /// Returns the attribute kind's name (without the 'spirv.' prefix).
   static StringRef getKindName();
 
   /// Returns descriptor set.
   uint32_t getDescriptorSet();
 
   /// Returns binding.
   uint32_t getBinding();
 
   /// Returns `spirv::StorageClass`.
-  Optional<StorageClass> getStorageClass();
+  std::optional<StorageClass> getStorageClass();
 
   static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
                               IntegerAttr descriptorSet, IntegerAttr binding,
                               IntegerAttr storageClass);
 };
 
 /// An attribute that specifies the SPIR-V (version, capabilities, extensions)
 /// triple.

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAttributes.td

 
 // For entry functions, this attribute specifies information related to entry
 // points in the generated SPIR-V module:
 // 1) [optional] Requested workgroup size.
 // 2) [optional] Requested subgroup size.
 def SPIRV_EntryPointABIAttr : SPIRV_Attr<"EntryPointABI", "entry_point_abi"> {
   let parameters = (ins
     OptionalParameter<"DenseI32ArrayAttr">:$workgroup_size,
-    OptionalParameter<"llvm::Optional<int>">:$subgroup_size
+    OptionalParameter<"std::optional<int>">:$subgroup_size
   );
   let assemblyFormat = "`<` struct(params) `>`";
 }
 
 def SPIRV_ExtensionArrayAttr : TypedArrayAttrBase<
     SPIRV_ExtensionAttr, "SPIR-V extension array attribute">;
 
 def SPIRV_CapabilityArrayAttr : TypedArrayAttrBase<
DefaultValuedParameter<
       "ArrayAttr",
       "$_builder.getI32ArrayAttr({128, 128, 64})"
     >:$max_compute_workgroup_size,
 
     // The default number of invocations in each subgroup.
     DefaultValuedParameter<"int", "32">:$subgroup_size,
 
     // The minimum supported size if the subgroup size is controllable.
-    OptionalParameter<"mlir::Optional<int>">:$min_subgroup_size,
+    OptionalParameter<"std::optional<int>">:$min_subgroup_size,
     // The maximum supported size if the subgroup size is controllable.
-    OptionalParameter<"mlir::Optional<int>">:$max_subgroup_size,
+    OptionalParameter<"std::optional<int>">:$max_subgroup_size,
 
     // The configurations of cooperative matrix operations
     // supported. Default is an empty list.
     DefaultValuedParameter<
       "ArrayAttr",
       "nullptr"
     >:$cooperative_matrix_properties_nv
   );
   let assemblyFormat = "`<` struct(params) `>`";
 }
 
 #endif // MLIR_DIALECT_SPIRV_IR_TARGET_AND_ABI

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVAvailability.td

class Availability {
   // The availability requirement carried by a concrete instance.
   string instance = ?;
 }
 
 class MinVersionBase<string name, EnumAttr scheme, I32EnumAttrCase min>
     : Availability {
   let interfaceName = name;
 
-  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
+  let queryFnRetType = "std::optional<" # scheme.returnType # ">";
   let queryFnName = "getMinVersion";
 
   let mergeAction = "{ "
     "if ($overall) { "
       "$overall = static_cast<" # scheme.returnType # ">("
                   "std::max(*$overall, $instance)); "
     "} else { $overall = $instance; }}";
   let initializer = "::std::nullopt";
   let instanceType = scheme.cppNamespace # "::" # scheme.enum.className;
 
   let instance = scheme.cppNamespace # "::" # scheme.enum.className # "::" #
                  min.symbol;
 }
 
 class MaxVersionBase<string name, EnumAttr scheme, I32EnumAttrCase max>
     : Availability {
   let interfaceName = name;
 
-  let queryFnRetType = "llvm::Optional<" # scheme.returnType # ">";
+  let queryFnRetType = "std::optional<" # scheme.returnType # ">";
   let queryFnName = "getMaxVersion";
 
   let mergeAction = "{ "
     "if ($overall) { "
       "$overall = static_cast<" # scheme.returnType # ">("
                   "std::min(*$overall, $instance)); "
     "} else { $overall = $instance; }}";
   let initializer = "::std::nullopt";
   let instanceType = scheme.cppNamespace # "::" # scheme.enum.className;
 
   let instance = scheme.cppNamespace # "::" # scheme.enum.className # "::" #
                  max.symbol;
 }
 
 #endif // MLIR_DIALECT_SPIRV_IR_AVAILABILITY

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVBase.td

 
 class SPIRVOpInterface<string name> : OpInterface<name> {
   let cppNamespace = "::mlir::spirv";
 }
 // TODO: the following interfaces definitions are duplicating with the above.
 // Remove them once we are able to support dialect-specific contents in ODS.
 def QueryMinVersionInterface : SPIRVOpInterface<"QueryMinVersionInterface"> {
   let methods = [InterfaceMethod<
-    "", "::llvm::Optional<::mlir::spirv::Version>", "getMinVersion">];
+    "", "::std::optional<::mlir::spirv::Version>", "getMinVersion">];
 }
 def QueryMaxVersionInterface : SPIRVOpInterface<"QueryMaxVersionInterface"> {
   let methods = [InterfaceMethod<
-    "", "::llvm::Optional<::mlir::spirv::Version>", "getMaxVersion">];
+    "", "::std::optional<::mlir::spirv::Version>", "getMaxVersion">];
 }
 def QueryExtensionInterface : SPIRVOpInterface<"QueryExtensionInterface"> {
   let methods = [InterfaceMethod<
     "",
     "::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1>",
     "getExtensions">];
 }
 def QueryCapabilityInterface : SPIRVOpInterface<"QueryCapabilityInterface"> {

mlir/include/mlir/Dialect/SPIRV/IR/TargetAndABI.h

private:
   llvm::SmallSet<Extension, 4> givenExtensions;    /// Allowed extensions
   llvm::SmallSet<Capability, 8> givenCapabilities; /// Allowed capabilities
 };
 
 /// Returns the attribute name for specifying argument ABI information.
 StringRef getInterfaceVarABIAttrName();
 
 /// Gets the InterfaceVarABIAttr given its fields.
-InterfaceVarABIAttr getInterfaceVarABIAttr(unsigned descriptorSet,
-                                           unsigned binding,
-                                           Optional<StorageClass> storageClass,
-                                           MLIRContext *context);
+InterfaceVarABIAttr
+getInterfaceVarABIAttr(unsigned descriptorSet, unsigned binding,
+                       std::optional<StorageClass> storageClass,
 
 /// Returns whether the given SPIR-V target (described by TargetEnvAttr) needs
 /// ABI attributes for interface variables (spirv.interface_var_abi).
 bool needsInterfaceVarABIAttrs(TargetEnvAttr targetAttr);
 
 /// Returns the attribute name for specifying entry point information.
 StringRef getEntryPointABIAttrName();
 
 /// Gets the EntryPointABIAttr given its fields.
 EntryPointABIAttr getEntryPointABIAttr(MLIRContext *context,
                                        ArrayRef<int32_t> workgroupSize = {},
-                                       llvm::Optional<int> subgroupSize = {});
+                                       std::optional<int> subgroupSize = {});
 
 /// Queries the entry point ABI on the nearest function-like op containing the
 /// given `op`. Returns null attribute if not found.
 EntryPointABIAttr lookupEntryPointABI(Operation *op);
 
 /// Queries the local workgroup size from entry point ABI on the nearest
 /// function-like op containing the given `op`. Returns null attribute if not
 /// found.

mlir/include/mlir/IR/DialectImplementation.h

if (parser.parseString(&value))
       return failure();
     return value;
   }
 };
 
 /// Parse an Optional integer.
 template <typename IntT>
 struct FieldParser<
-    llvm::Optional<IntT>,
-    std::enable_if_t<std::is_integral<IntT>::value, Optional<IntT>>> {
-  static FailureOr<Optional<IntT>> parse(AsmParser &parser) {
+    std::optional<IntT>,
+    std::enable_if_t<std::is_integral<IntT>::value, std::optional<IntT>>> {
+  static FailureOr<std::optional<IntT>> parse(AsmParser &parser) {
     IntT value;
     OptionalParseResult result = parser.parseOptionalInteger(value);
     if (result.has_value()) {
       if (succeeded(*result))
-        return {Optional<IntT>(value)};
+        return {std::optional<IntT>(value)};
       return failure();
     }
     return {std::nullopt};
   }
 };
 
 /// Parse any container that supports back insertion as a list.
 template <typename ContainerT>

mlir/include/mlir/IR/SymbolInterfaces.td

InterfaceMethod<"Sets the visibility of this symbol to be public.",
         setVisibility(mlir::SymbolTable::Visibility::Public);
       }]
     >,
     InterfaceMethod<[{
         Get all of the uses of the current symbol that are nested within the
         given operation 'from'.
         Note: See mlir::SymbolTable::getSymbolUses for more details.
       }],
-      "::llvm::Optional<::mlir::SymbolTable::UseRange>", "getSymbolUses",
+      "::std::optional<::mlir::SymbolTable::UseRange>", "getSymbolUses",
       (ins "::mlir::Operation *":$from), [{}],
       /*defaultImplementation=*/[{
         return ::mlir::SymbolTable::getSymbolUses(this->getOperation(), from);
       }]
     >,
     InterfaceMethod<[{
         Return if the current symbol is known to have no uses that are nested
         within the given operation 'from'.

mlir/include/mlir/IR/SymbolTable.h

public:
   private:
     std::vector<SymbolUse> uses;
   };
 
   /// Get an iterator range for all of the uses, for any symbol, that are nested
   /// within the given operation 'from'. This does not traverse into any nested
   /// symbol tables. This function returns std::nullopt if there are any unknown
   /// operations that may potentially be symbol tables.
-  static Optional<UseRange> getSymbolUses(Operation *from);
-  static Optional<UseRange> getSymbolUses(Region *from);
+  static std::optional<UseRange> getSymbolUses(Operation *from);
+  static std::optional<UseRange> getSymbolUses(Region *from);
 
   /// Get all of the uses of the given symbol that are nested within the given
   /// operation 'from'. This does not traverse into any nested symbol tables.
   /// This function returns std::nullopt if there are any unknown operations
   /// that may potentially be symbol tables.
-  static Optional<UseRange> getSymbolUses(StringAttr symbol, Operation *from);
-  static Optional<UseRange> getSymbolUses(Operation *symbol, Operation *from);
-  static Optional<UseRange> getSymbolUses(StringAttr symbol, Region *from);
-  static Optional<UseRange> getSymbolUses(Operation *symbol, Region *from);
+  static std::optional<UseRange> getSymbolUses(StringAttr symbol,
+                                               Operation *from);
+  static std::optional<UseRange> getSymbolUses(Operation *symbol,
+                                               Operation *from);
+  static std::optional<UseRange> getSymbolUses(StringAttr symbol, Region *from);
+  static std::optional<UseRange> getSymbolUses(Operation *symbol, Region *from);
 
   /// Return if the given symbol is known to have no uses that are nested
   /// within the given operation 'from'. This does not traverse into any nested
   /// symbol tables. This function will also return false if there are any
   /// unknown operations that may potentially be symbol tables. This doesn't
   /// necessarily mean that there are no uses, we just can't conservatively
   /// prove it.
   static bool symbolKnownUseEmpty(StringAttr symbol, Operation *from);

mlir/lib/Analysis/DataFlow/DeadCodeAnalysis.cpp

for (auto callable : symbolTableBlock->getOps<CallableOpInterface>()) {
       foundSymbolCallable = true;
     }
 
     // Exit early if no eligible symbol callables were found in the table.
     if (!foundSymbolCallable)
       return;
 
     // Walk the symbol table to check for non-call uses of symbols.
-    Optional<SymbolTable::UseRange> uses =
+    std::optional<SymbolTable::UseRange> uses =
         SymbolTable::getSymbolUses(&symbolTableRegion);
     if (!uses) {
       // If we couldn't gather the symbol uses, conservatively assume that
       // we can't track information for any nested symbols.
       return top->walk([&](CallableOpInterface callable) {
         auto *state = getOrCreate<PredecessorState>(callable);
         propagateIfChanged(state, state->setHasUnknownPredecessors());
       });

mlir/lib/Conversion/GPUToSPIRV/GPUToSPIRV.cpp

if (!spirv::needsInterfaceVarABIAttrs(targetEnv))
     return success();
 
   for (auto argIndex : llvm::seq<unsigned>(0, funcOp.getNumArguments())) {
     if (funcOp.getArgAttrOfType<spirv::InterfaceVarABIAttr>(
             argIndex, spirv::getInterfaceVarABIAttrName()))
       return failure();
     // Vulkan's interface variable requirements needs scalars to be wrapped in a
     // struct. The struct held in storage buffer.
-    Optional<spirv::StorageClass> sc;
+    std::optional<spirv::StorageClass> sc;
     if (funcOp.getArgument(argIndex).getType().isIntOrIndexOrFloat())
       sc = spirv::StorageClass::StorageBuffer;
     argABI.push_back(spirv::getInterfaceVarABIAttr(0, argIndex, sc, context));
   }
   return success();
 }
 
 LogicalResult GPUFuncOpConversion::matchAndRewrite(

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

LogicalResult ToMemrefOp::bufferize(RewriterBase &rewriter,
                                     const BufferizationOptions &options) {
   // Fold to_memref(to_tensor(x)) to x. Insert a cast if necessary.
   (void)foldToMemrefToTensorPair(rewriter, *this);
   // Note: The return value of `bufferize` indicates whether there was an error
   // or not. (And not whether the pattern matched or not.)
   return success();
 }
 
-Optional<Operation *> CloneOp::buildDealloc(OpBuilder &builder, Value alloc) {
+std::optional<Operation *> CloneOp::buildDealloc(OpBuilder &builder,
+                                                 Value alloc) {
   return builder.create<memref::DeallocOp>(alloc.getLoc(), alloc)
       .getOperation();
 }
 
-Optional<Value> CloneOp::buildClone(OpBuilder &builder, Value alloc) {
+std::optional<Value> CloneOp::buildClone(OpBuilder &builder, Value alloc) {
   return builder.create<CloneOp>(alloc.getLoc(), alloc).getResult();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Bufferization/IR/BufferizationOps.cpp.inc"

mlir/lib/Dialect/Bufferization/Transforms/BufferDeallocation.cpp

 
 //===----------------------------------------------------------------------===//
 // BufferDeallocationPass
 //===----------------------------------------------------------------------===//
 
 struct DefaultAllocationInterface
     : public bufferization::AllocationOpInterface::ExternalModel<
           DefaultAllocationInterface, memref::AllocOp> {
-  static Optional<Operation *> buildDealloc(OpBuilder &builder, Value alloc) {
+  static std::optional<Operation *> buildDealloc(OpBuilder &builder,
+                                                 Value alloc) {
     return builder.create<memref::DeallocOp>(alloc.getLoc(), alloc)
         .getOperation();
   }
-  static Optional<Value> buildClone(OpBuilder &builder, Value alloc) {
+  static std::optional<Value> buildClone(OpBuilder &builder, Value alloc) {
     return builder.create<bufferization::CloneOp>(alloc.getLoc(), alloc)
         .getResult();
   }
 };
 
 /// The actual buffer deallocation pass that inserts and moves dealloc nodes
 /// into the right positions. Furthermore, it inserts additional clones if
 /// necessary. It uses the algorithm described at the top of the file.

mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp

gpu::GPUModuleOp createKernelModule(gpu::GPUFuncOp kernelFunc,
     if (dataLayoutSpec)
       kernelModule->setAttr(DLTIDialect::kDataLayoutAttrName, dataLayoutSpec);
 
     SymbolTable symbolTable(kernelModule);
     symbolTable.insert(kernelFunc);
 
     SmallVector<Operation *, 8> symbolDefWorklist = {kernelFunc};
     while (!symbolDefWorklist.empty()) {
-      if (Optional<SymbolTable::UseRange> symbolUses =
+      if (std::optional<SymbolTable::UseRange> symbolUses =
               SymbolTable::getSymbolUses(symbolDefWorklist.pop_back_val())) {
         for (SymbolTable::SymbolUse symbolUse : *symbolUses) {
           StringRef symbolName =
               symbolUse.getSymbolRef().cast<FlatSymbolRefAttr>().getValue();
           if (symbolTable.lookup(symbolName))
             continue;
 
           Operation *symbolDefClone =

mlir/lib/Dialect/MemRef/Transforms/NormalizeMemRefs.cpp

void NormalizeMemRefs::setCalleesAndCallersNonNormalizable(
   if (!normalizableFuncs.contains(funcOp))
     return;
 
   LLVM_DEBUG(
       llvm::dbgs() << "@" << funcOp.getName()
                    << " calls or is called by non-normalizable function\n");
   normalizableFuncs.erase(funcOp);
   // Caller of the function.
-  Optional<SymbolTable::UseRange> symbolUses = funcOp.getSymbolUses(moduleOp);
+  std::optional<SymbolTable::UseRange> symbolUses =
+      funcOp.getSymbolUses(moduleOp);
   for (SymbolTable::SymbolUse symbolUse : *symbolUses) {
     // TODO: Extend this for ops that are FunctionOpInterface. This would
     // require creating an OpInterface for FunctionOpInterface ops.
     func::FuncOp parentFuncOp =
         symbolUse.getUser()->getParentOfType<func::FuncOp>();
     for (func::FuncOp &funcOp : normalizableFuncs) {
       if (parentFuncOp == funcOp) {
         setCalleesAndCallersNonNormalizable(funcOp, moduleOp,
void NormalizeMemRefs::updateFunctionSignature(func::FuncOp funcOp,
   // Since we update the function signature, it might affect the result types at
   // the caller site. Since this result might even be used by the caller
   // function in ReturnOps, the caller function's signature will also change.
   // Hence we record the caller function in 'funcOpsToUpdate' to update their
   // signature as well.
   llvm::SmallDenseSet<func::FuncOp, 8> funcOpsToUpdate;
   // We iterate over all symbolic uses of the function and update the return
   // type at the caller site.
-  Optional<SymbolTable::UseRange> symbolUses = funcOp.getSymbolUses(moduleOp);
+  std::optional<SymbolTable::UseRange> symbolUses =
+      funcOp.getSymbolUses(moduleOp);
   for (SymbolTable::SymbolUse symbolUse : *symbolUses) {
     Operation *userOp = symbolUse.getUser();
     OpBuilder builder(userOp);
     // When `userOp` can not be casted to `CallOp`, it is skipped. This assumes
     // that the non-CallOp has no memrefs to be replaced.
     // TODO: Handle cases where a non-CallOp symbol use of a function deals with
     // memrefs.
     auto callOp = dyn_cast<func::CallOp>(userOp);

mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp

 } // namespace mlir
 
 //===----------------------------------------------------------------------===//
 // InterfaceVarABIAttr
 //===----------------------------------------------------------------------===//
 
 spirv::InterfaceVarABIAttr
 spirv::InterfaceVarABIAttr::get(uint32_t descriptorSet, uint32_t binding,
-                                Optional<spirv::StorageClass> storageClass,
+                                std::optional<spirv::StorageClass> storageClass,
                                 MLIRContext *context) {
   Builder b(context);
   auto descriptorSetAttr = b.getI32IntegerAttr(descriptorSet);
   auto bindingAttr = b.getI32IntegerAttr(binding);
   auto storageClassAttr =
       storageClass ? b.getI32IntegerAttr(static_cast<uint32_t>(*storageClass))
                    : IntegerAttr();
   return get(descriptorSetAttr, bindingAttr, storageClassAttr);

 uint32_t spirv::InterfaceVarABIAttr::getBinding() {
   return getImpl()->binding.cast<IntegerAttr>().getInt();
 }
 
 uint32_t spirv::InterfaceVarABIAttr::getDescriptorSet() {
   return getImpl()->descriptorSet.cast<IntegerAttr>().getInt();
 }
 
-Optional<spirv::StorageClass> spirv::InterfaceVarABIAttr::getStorageClass() {
+std::optional<spirv::StorageClass>
+spirv::InterfaceVarABIAttr::getStorageClass() {
   if (getImpl()->storageClass)
     return static_cast<spirv::StorageClass>(
         getImpl()->storageClass.cast<IntegerAttr>().getValue().getZExtValue());
   return std::nullopt;
 }
 
 LogicalResult spirv::InterfaceVarABIAttr::verify(
     function_ref<InFlightDiagnostic()> emitError, IntegerAttr descriptorSet,

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

if (factorBitWidth > resultBitWidth)
     return op->emitOpError(
         llvm::formatv("result type has insufficient bit-width ({0} bits) "
                       "for the specified vector operand type ({1} bits)",
                       resultBitWidth, factorBitWidth));
 
   return success();
 }
 
-static Optional<spirv::Version> getIntegerDotProductMinVersion() {
+static std::optional<spirv::Version> getIntegerDotProductMinVersion() {
   return spirv::Version::V_1_0; // Available in SPIR-V >= 1.0.
 }
 
-static Optional<spirv::Version> getIntegerDotProductMaxVersion() {
+static std::optional<spirv::Version> getIntegerDotProductMaxVersion() {
   return spirv::Version::V_1_6; // Available in SPIR-V <= 1.6.
 }
 
 static SmallVector<ArrayRef<spirv::Extension>, 1>
 getIntegerDotProductExtensions() {
   // Requires the SPV_KHR_integer_dot_product extension, specified either
   // explicitly or implied by target env's SPIR-V version >= 1.6.
   static const auto extension = spirv::Extension::SPV_KHR_integer_dot_product;

 #define SPIRV_IMPL_INTEGER_DOT_PRODUCT_OP(OpName)                              \
   LogicalResult OpName::verify() { return verifyIntegerDotProduct(*this); }    \
   SmallVector<ArrayRef<spirv::Extension>, 1> OpName::getExtensions() {         \
     return getIntegerDotProductExtensions();                                   \
   }                                                                            \
   SmallVector<ArrayRef<spirv::Capability>, 1> OpName::getCapabilities() {      \
     return getIntegerDotProductCapabilities(*this);                            \
   }                                                                            \
-  Optional<spirv::Version> OpName::getMinVersion() {                           \
+  std::optional<spirv::Version> OpName::getMinVersion() {                      \
     return getIntegerDotProductMinVersion();                                   \
   }                                                                            \
-  Optional<spirv::Version> OpName::getMaxVersion() {                           \
+  std::optional<spirv::Version> OpName::getMaxVersion() {                      \
     return getIntegerDotProductMaxVersion();                                   \
   }
 
 SPIRV_IMPL_INTEGER_DOT_PRODUCT_OP(spirv::SDotOp)
 SPIRV_IMPL_INTEGER_DOT_PRODUCT_OP(spirv::SUDotOp)
 SPIRV_IMPL_INTEGER_DOT_PRODUCT_OP(spirv::UDotOp)
 SPIRV_IMPL_INTEGER_DOT_PRODUCT_OP(spirv::SDotAccSatOp)
 SPIRV_IMPL_INTEGER_DOT_PRODUCT_OP(spirv::SUDotAccSatOp)

mlir/lib/Dialect/SPIRV/IR/TargetAndABI.cpp

 //===----------------------------------------------------------------------===//
 
 StringRef spirv::getInterfaceVarABIAttrName() {
   return "spirv.interface_var_abi";
 }
 
 spirv::InterfaceVarABIAttr
 spirv::getInterfaceVarABIAttr(unsigned descriptorSet, unsigned binding,
-                              Optional<spirv::StorageClass> storageClass,
+                              std::optional<spirv::StorageClass> storageClass,
                               MLIRContext *context) {
   return spirv::InterfaceVarABIAttr::get(descriptorSet, binding, storageClass,
                                          context);
 }
 
 bool spirv::needsInterfaceVarABIAttrs(spirv::TargetEnvAttr targetAttr) {
   for (spirv::Capability cap : targetAttr.getCapabilities()) {
     if (cap == spirv::Capability::Kernel)
       return false;
     if (cap == spirv::Capability::Shader)
       return true;
   }
   return false;
 }
 
 StringRef spirv::getEntryPointABIAttrName() { return "spirv.entry_point_abi"; }
 
 spirv::EntryPointABIAttr
 spirv::getEntryPointABIAttr(MLIRContext *context,
                             ArrayRef<int32_t> workgroupSize,
-                            llvm::Optional<int> subgroupSize) {
+                            std::optional<int> subgroupSize) {
   DenseI32ArrayAttr workgroupSizeAttr;
   if (!workgroupSize.empty()) {
     assert(workgroupSize.size() == 3);
     workgroupSizeAttr = DenseI32ArrayAttr::get(context, workgroupSize);
   }
   return spirv::EntryPointABIAttr::get(context, workgroupSizeAttr,
                                        subgroupSize);
 }

mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp

if (!caps || targetEnv.allows(*caps)) {
                                              spirv::ExecutionMode::LocalSize,
                                              workgroupSizeAttr.asArrayRef());
       // Erase workgroup size.
       entryPointAttr = spirv::EntryPointABIAttr::get(
           entryPointAttr.getContext(), DenseI32ArrayAttr(),
           entryPointAttr.getSubgroupSize());
     }
   }
-  if (Optional<int> subgroupSize = entryPointAttr.getSubgroupSize()) {
+  if (std::optional<int> subgroupSize = entryPointAttr.getSubgroupSize()) {
     std::optional<ArrayRef<spirv::Capability>> caps =
         spirv::getCapabilities(spirv::ExecutionMode::SubgroupSize);
     if (!caps || targetEnv.allows(*caps)) {
       builder.create<spirv::ExecutionModeOp>(funcOp.getLoc(), funcOp,
                                              spirv::ExecutionMode::SubgroupSize,
                                              *subgroupSize);
       // Erase subgroup size.
       entryPointAttr = spirv::EntryPointABIAttr::get(

mlir/lib/Dialect/SPIRV/Transforms/SPIRVConversion.cpp

 SPIRVConversionTarget::SPIRVConversionTarget(spirv::TargetEnvAttr targetAttr)
     : ConversionTarget(*targetAttr.getContext()), targetEnv(targetAttr) {}
 
 bool SPIRVConversionTarget::isLegalOp(Operation *op) {
   // Make sure this op is available at the given version. Ops not implementing
   // QueryMinVersionInterface/QueryMaxVersionInterface are available to all
   // SPIR-V versions.
   if (auto minVersionIfx = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
-    Optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
+    std::optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
     if (minVersion && *minVersion > this->targetEnv.getVersion()) {
       LLVM_DEBUG(llvm::dbgs()
                  << op->getName() << " illegal: requiring min version "
                  << spirv::stringifyVersion(*minVersion) << "\n");
       return false;
     }
   }
   if (auto maxVersionIfx = dyn_cast<spirv::QueryMaxVersionInterface>(op)) {
-    Optional<spirv::Version> maxVersion = maxVersionIfx.getMaxVersion();
+    std::optional<spirv::Version> maxVersion = maxVersionIfx.getMaxVersion();
     if (maxVersion && *maxVersion < this->targetEnv.getVersion()) {
       LLVM_DEBUG(llvm::dbgs()
                  << op->getName() << " illegal: requiring max version "
                  << spirv::stringifyVersion(*maxVersion) << "\n");
       return false;
     }
   }
 

mlir/lib/Dialect/SPIRV/Transforms/UpdateVCEPass.cpp

void UpdateVCEPass::runOnOperation() {
   SetVector<spirv::Extension> deducedExtensions;
   SetVector<spirv::Capability> deducedCapabilities;
 
   // Walk each SPIR-V op to deduce the minimal version/extension/capability
   // requirements.
   WalkResult walkResult = module.walk([&](Operation *op) -> WalkResult {
     // Op min version requirements
     if (auto minVersionIfx = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
-      Optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
+      std::optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
       if (minVersion) {
         deducedVersion = std::max(deducedVersion, *minVersion);
         if (deducedVersion > allowedVersion) {
           return op->emitError("'")
                  << op->getName() << "' requires min version "
                  << spirv::stringifyVersion(deducedVersion)
                  << " but target environment allows up to "
                  << spirv::stringifyVersion(allowedVersion);

mlir/lib/IR/SymbolTable.cpp

return subRefLeafs.size() < refLeafs.size() &&
          subRefLeafs == refLeafs.take_front(subRefLeafs.size());
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTable::getSymbolUses
 
 /// The implementation of SymbolTable::getSymbolUses below.
 template <typename FromT>
-static Optional<SymbolTable::UseRange> getSymbolUsesImpl(FromT from) {
+static std::optional<SymbolTable::UseRange> getSymbolUsesImpl(FromT from) {
   std::vector<SymbolTable::SymbolUse> uses;
   auto walkFn = [&](SymbolTable::SymbolUse symbolUse) {
     uses.push_back(symbolUse);
     return WalkResult::advance();
   };
   auto result = walkSymbolUses(from, walkFn);
-  return result ? Optional<SymbolTable::UseRange>(std::move(uses))
+  return result ? std::optional<SymbolTable::UseRange>(std::move(uses))
                 : std::nullopt;
 }
 
 /// Get an iterator range for all of the uses, for any symbol, that are nested
 /// within the given operation 'from'. This does not traverse into any nested
 /// symbol tables, and will also only return uses on 'from' if it does not
 /// also define a symbol table. This is because we treat the region as the
 /// boundary of the symbol table, and not the op itself. This function returns
 /// std::nullopt if there are any unknown operations that may potentially be
 /// symbol tables.
-auto SymbolTable::getSymbolUses(Operation *from) -> Optional<UseRange> {
+auto SymbolTable::getSymbolUses(Operation *from) -> std::optional<UseRange> {
   return getSymbolUsesImpl(from);
 }
-auto SymbolTable::getSymbolUses(Region *from) -> Optional<UseRange> {
+auto SymbolTable::getSymbolUses(Region *from) -> std::optional<UseRange> {
   return getSymbolUsesImpl(MutableArrayRef<Region>(*from));
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTable::getSymbolUses
 
 /// The implementation of SymbolTable::getSymbolUses below.
 template <typename SymbolT, typename IRUnitT>
-static Optional<SymbolTable::UseRange> getSymbolUsesImpl(SymbolT symbol,
+static std::optional<SymbolTable::UseRange> getSymbolUsesImpl(SymbolT symbol,
                                                               IRUnitT *limit) {
   std::vector<SymbolTable::SymbolUse> uses;
   for (SymbolScope &scope : collectSymbolScopes(symbol, limit)) {
     if (!scope.walk([&](SymbolTable::SymbolUse symbolUse) {
           if (isReferencePrefixOf(scope.symbol, symbolUse.getSymbolRef()))
             uses.push_back(symbolUse);
         }))
       return std::nullopt;
   }
   return SymbolTable::UseRange(std::move(uses));
 }
 
 /// Get all of the uses of the given symbol that are nested within the given
 /// operation 'from', invoking the provided callback for each. This does not
 /// traverse into any nested symbol tables. This function returns std::nullopt
 /// if there are any unknown operations that may potentially be symbol tables.
 auto SymbolTable::getSymbolUses(StringAttr symbol, Operation *from)
-    -> Optional<UseRange> {
+    -> std::optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
 auto SymbolTable::getSymbolUses(Operation *symbol, Operation *from)
-    -> Optional<UseRange> {
+    -> std::optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
 auto SymbolTable::getSymbolUses(StringAttr symbol, Region *from)
-    -> Optional<UseRange> {
+    -> std::optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
 auto SymbolTable::getSymbolUses(Operation *symbol, Region *from)
-    -> Optional<UseRange> {
+    -> std::optional<UseRange> {
   return getSymbolUsesImpl(symbol, from);
 }
 
 //===----------------------------------------------------------------------===//
 // SymbolTable::symbolKnownUseEmpty
 
 /// The implementation of SymbolTable::symbolKnownUseEmpty below.
 template <typename SymbolT, typename IRUnitT>

mlir/lib/Transforms/SymbolDCE.cpp

if (op->hasTrait<OpTrait::SymbolTable>()) {
       // symbol, or if it is a private symbol.
       SymbolOpInterface symbol = dyn_cast<SymbolOpInterface>(op);
       bool symIsHidden = symbolTableIsHidden || !symbol || symbol.isPrivate();
       if (failed(computeLiveness(op, symbolTable, symIsHidden, liveSymbols)))
         return failure();
     }
 
     // Collect the uses held by this operation.
-    Optional<SymbolTable::UseRange> uses = SymbolTable::getSymbolUses(op);
+    std::optional<SymbolTable::UseRange> uses = SymbolTable::getSymbolUses(op);
     if (!uses) {
       return op->emitError()
              << "operation contains potentially unknown symbol table, "
                 "meaning that we can't reliable compute symbol uses";
     }
 
     SmallVector<Operation *, 4> resolvedSymbols;
     for (const SymbolTable::SymbolUse &use : *uses) {

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

void PrintOpAvailability::runOnOperation() {
   f->walk([&](Operation *op) {
     if (op->getDialect() != spirvDialect)
       return WalkResult::advance();
 
     auto opName = op->getName();
     auto &os = llvm::outs();
 
     if (auto minVersionIfx = dyn_cast<spirv::QueryMinVersionInterface>(op)) {
-      Optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
+      std::optional<spirv::Version> minVersion = minVersionIfx.getMinVersion();
       os << opName << " min version: ";
       if (minVersion)
         os << spirv::stringifyVersion(*minVersion) << "\n";
       else
         os << "None\n";
     }
 
     if (auto maxVersionIfx = dyn_cast<spirv::QueryMaxVersionInterface>(op)) {
-      Optional<spirv::Version> maxVersion = maxVersionIfx.getMaxVersion();
+      std::optional<spirv::Version> maxVersion = maxVersionIfx.getMaxVersion();
       os << opName << " max version: ";
       if (maxVersion)
         os << spirv::stringifyVersion(*maxVersion) << "\n";
       else
         os << "None\n";
     }
 
     if (auto extension = dyn_cast<spirv::QueryExtensionInterface>(op)) {

mlir/test/lib/Dialect/Test/TestAttrDefs.td

def TestAttrWithFormat : Test_Attr<"TestAttrWithFormat"> {
   let assemblyFormat = [{
     `<` $one `:` struct($two, $four) `:` $three `:` $five `,`
     `[` `` $arrayOfAttrWithTypeBuilderAttr `]` `>`
   }];
   let genVerifyDecl = 1;
 }
 
 def TestAttrWithOptionalSigned : Test_Attr<"TestAttrWithOptionalSigned"> {
-  let parameters = (ins OptionalParameter<"mlir::Optional<int64_t>">:$value);
+  let parameters = (ins OptionalParameter<"std::optional<int64_t>">:$value);
   let assemblyFormat = "`<` $value `>`";
   let mnemonic = "attr_with_optional_signed";
 }
 
 def TestAttrWithOptionalUnsigned : Test_Attr<"TestAttrWithOptionalUnsigned"> {
-  let parameters = (ins OptionalParameter<"mlir::Optional<uint64_t>">:$value);
+  let parameters = (ins OptionalParameter<"std::optional<uint64_t>">:$value);
   let assemblyFormat = "`<` $value `>`";
   let mnemonic = "attr_with_optional_unsigned";
 }
 
 def TestAttrUgly : Test_Attr<"TestAttrUgly"> {
   let parameters = (ins "::mlir::Attribute":$attr);
 
   let mnemonic = "attr_ugly";

 def TestSimpleEnumAttr : EnumAttr<Test_Dialect, TestSimpleEnum, "simple_enum"> {
   let assemblyFormat = "`` $value";
 }
 def TestArrayOfEnums : ArrayOfAttr<Test_Dialect, "ArrayOfEnums",
     "array_of_enums", "SimpleEnumAttr">;
 
 // Test custom directive as optional group anchor.
 def TestCustomAnchor : Test_Attr<"TestCustomAnchor"> {
-  let parameters = (ins "int":$a, OptionalParameter<"mlir::Optional<int>">:$b);
+  let parameters = (ins "int":$a, OptionalParameter<"std::optional<int>">:$b);
   let mnemonic = "custom_anchor";
   let assemblyFormat = "`<` $a (`>`) : (`,` custom<TrueFalse>($b)^ `>`)?";
 }
 
 def Test_IteratorTypeEnum
     : EnumAttr<Test_Dialect, IteratorType, "iterator_type"> {
   let assemblyFormat = "`<` $value `>`";
 }
 
 def Test_IteratorTypeArrayAttr
     : TypedArrayAttrBase<Test_IteratorTypeEnum,
   "Iterator type should be an enum.">;
 
 
 #endif // TEST_ATTRDEFS

mlir/test/lib/Dialect/Test/TestAttributes.cpp

ArrayRef<uint64_t> TestExtern1DI64ElementsAttr::getElements() const {
   return std::nullopt;
 }
 
 //===----------------------------------------------------------------------===//
 // TestCustomAnchorAttr
 //===----------------------------------------------------------------------===//
 
 static ParseResult parseTrueFalse(AsmParser &p,
-                                  FailureOr<Optional<int>> &result) {
+                                  FailureOr<std::optional<int>> &result) {
   bool b;
   if (p.parseInteger(b))
     return failure();
-  result = Optional<int>(b);
+  result = std::optional<int>(b);
   return success();
 }
 
-static void printTrueFalse(AsmPrinter &p, Optional<int> result) {
+static void printTrueFalse(AsmPrinter &p, std::optional<int> result) {
   p << (*result ? "true" : "false");
 }
 
 //===----------------------------------------------------------------------===//
 // Tablegen Generated Definitions
 //===----------------------------------------------------------------------===//
 
 #include "TestAttrInterfaces.cpp.inc"

mlir/test/lib/IR/TestSymbolUses.cpp

struct SymbolUsesPass
 
   StringRef getArgument() const final { return "test-symbol-uses"; }
   StringRef getDescription() const final {
     return "Test detection of symbol uses";
   }
   WalkResult operateOnSymbol(Operation *symbol, ModuleOp module,
                              SmallVectorImpl<func::FuncOp> &deadFunctions) {
     // Test computing uses on a non symboltable op.
-    Optional<SymbolTable::UseRange> symbolUses =
+    std::optional<SymbolTable::UseRange> symbolUses =
         SymbolTable::getSymbolUses(symbol);
 
     // Test the conservative failure case.
     if (!symbolUses) {
       symbol->emitRemark()
           << "symbol contains an unknown nested operation that "
              "'may' define a new symbol table";
       return WalkResult::interrupt();