mlir/DialectConversion: use std::optional (NFC)

[artagnon]

Summary

This is part of an effort to migrate from llvm::Optional to
std::optional. This patch touches DialectConversion, and modifies
existing conversions and tests appropriately.

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

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

[artagnon]

Attempt to fix flang build.

[rriddle]

mlir/include/mlir/Transforms/DialectConversion.h

104–105

flang/lib/Optimizer/CodeGen/TypeConverter.h

LLVMTypeConverter(mlir::ModuleOp module)
     // FIXME: https://reviews.llvm.org/D82831 introduced an automatic
     // materialization of conversion around function calls that is not working
     // well with fir lowering to llvm (incorrect llvm.mlir.cast are inserted).
     // Workaround until better analysis: register a handler that does not insert
     // any conversions.
     addSourceMaterialization(
         [&](mlir::OpBuilder &builder, mlir::Type resultType,
             mlir::ValueRange inputs,
-            mlir::Location loc) -> llvm::Optional<mlir::Value> {
+            mlir::Location loc) -> std::optional<mlir::Value> {
           if (inputs.size() != 1)
             return std::nullopt;
           return inputs[0];
         });
     // Similar FIXME workaround here (needed for compare.fir/select-type.fir
     // tests).
     addTargetMaterialization(
         [&](mlir::OpBuilder &builder, mlir::Type resultType,
             mlir::ValueRange inputs,
-            mlir::Location loc) -> llvm::Optional<mlir::Value> {
+            mlir::Location loc) -> std::optional<mlir::Value> {
           if (inputs.size() != 1)
             return std::nullopt;
           return inputs[0];
         });
   }
 
   // i32 is used here because LLVM wants i32 constants when indexing into struct
   // types. Indexing into other aggregate types is more flexible.
   mlir::Type offsetType() { return mlir::IntegerType::get(&getContext(), 32); }
 
   // i64 can be used to index into aggregates like arrays
   mlir::Type indexType() { return mlir::IntegerType::get(&getContext(), 64); }
 
   // fir.type<name(p : TY'...){f : TY...}>  -->  llvm<"%name = { ty... }">
-  llvm::Optional<mlir::LogicalResult>
+  std::optional<mlir::LogicalResult>
   convertRecordType(fir::RecordType derived,
                     llvm::SmallVectorImpl<mlir::Type> &results,
                     llvm::ArrayRef<mlir::Type> callStack) {
     auto name = derived.getName();
     auto st = mlir::LLVM::LLVMStructType::getIdentified(&getContext(), name);
     if (llvm::count(callStack, derived) > 1) {
       results.push_back(st);
       return mlir::success();

mlir/include/mlir/Conversion/MemRefToSPIRV/MemRefToSPIRV.h

 #include <memory>
 
 namespace mlir {
 class SPIRVTypeConverter;
 
 namespace spirv {
 /// Mapping from numeric MemRef memory spaces into SPIR-V symbolic ones.
 using MemorySpaceToStorageClassMap =
-    std::function<Optional<spirv::StorageClass>(Attribute)>;
+    std::function<std::optional<spirv::StorageClass>(Attribute)>;
 
 /// Maps MemRef memory spaces to storage classes for Vulkan-flavored SPIR-V
 /// using the default rule. Returns std::nullopt if the memory space is unknown.
-Optional<spirv::StorageClass> mapMemorySpaceToVulkanStorageClass(Attribute);
+std::optional<spirv::StorageClass>
+    mapMemorySpaceToVulkanStorageClass(Attribute);
 /// Maps storage classes for Vulkan-flavored SPIR-V to MemRef memory spaces
 /// using the default rule. Returns std::nullopt if the storage class is
 /// unsupported.
-Optional<unsigned> mapVulkanStorageClassToMemorySpace(spirv::StorageClass);
+std::optional<unsigned> mapVulkanStorageClassToMemorySpace(spirv::StorageClass);
 
 /// Maps MemRef memory spaces to storage classes for OpenCL-flavored SPIR-V
 /// using the default rule. Returns std::nullopt if the memory space is unknown.
-Optional<spirv::StorageClass> mapMemorySpaceToOpenCLStorageClass(Attribute);
+std::optional<spirv::StorageClass>
+    mapMemorySpaceToOpenCLStorageClass(Attribute);
 /// Maps storage classes for OpenCL-flavored SPIR-V to MemRef memory spaces
 /// using the default rule. Returns std::nullopt if the storage class is
 /// unsupported.
-Optional<unsigned> mapOpenCLStorageClassToMemorySpace(spirv::StorageClass);
+std::optional<unsigned> mapOpenCLStorageClassToMemorySpace(spirv::StorageClass);
 
 /// Type converter for converting numeric MemRef memory spaces into SPIR-V
 /// symbolic ones.
 class MemorySpaceToStorageClassConverter : public TypeConverter {
 public:
   explicit MemorySpaceToStorageClassConverter(
       const MemorySpaceToStorageClassMap &memorySpaceMap);
 

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

public:
   /// ((Extension::A OR Extension::B) AND (Extension::C OR Extension::D))
   /// convention.
   using ExtensionArrayRefVector = SmallVectorImpl<ArrayRef<Extension>>;
 
   /// Appends to `extensions` the extensions needed for this type to appear in
   /// the given `storage` class. This method does not guarantee the uniqueness
   /// of extensions; the same extension may be appended multiple times.
   void getExtensions(ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
 
   /// The capability requirements for each type are following the
   /// ((Capability::A OR Extension::B) AND (Capability::C OR Capability::D))
   /// convention.
   using CapabilityArrayRefVector = SmallVectorImpl<ArrayRef<Capability>>;
 
   /// Appends to `capabilities` the capabilities needed for this type to appear
   /// in the given `storage` class. This method does not guarantee the
   /// uniqueness of capabilities; the same capability may be appended multiple
   /// times.
   void getCapabilities(CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 
   /// Returns the size in bytes for each type. If no size can be calculated,
   /// returns `std::nullopt`. Note that if the type has explicit layout, it is
   /// also taken into account in calculation.
-  Optional<int64_t> getSizeInBytes();
+  std::optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V scalar type: bool type, integer type, floating point type.
 class ScalarType : public SPIRVType {
 public:
   using SPIRVType::SPIRVType;
 
   static bool classof(Type type);
 
   /// Returns true if the given integer type is valid for the SPIR-V dialect.
   static bool isValid(FloatType);
   /// Returns true if the given float type is valid for the SPIR-V dialect.
   static bool isValid(IntegerType);
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 
-  Optional<int64_t> getSizeInBytes();
+  std::optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V composite type: VectorType, SPIR-V ArrayType, or SPIR-V StructType.
 class CompositeType : public SPIRVType {
 public:
   using SPIRVType::SPIRVType;
 
   static bool classof(Type type);
 
   /// Returns true if the given vector type is valid for the SPIR-V dialect.
   static bool isValid(VectorType);
 
   /// Return the number of elements of the type. This should only be called if
   /// hasCompileTimeKnownNumElements is true.
   unsigned getNumElements() const;
 
   Type getElementType(unsigned) const;
 
   /// Return true if the number of elements is known at compile time and is not
   /// implementation dependent.
   bool hasCompileTimeKnownNumElements() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 
-  Optional<int64_t> getSizeInBytes();
+  std::optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V array type
 class ArrayType : public Type::TypeBase<ArrayType, CompositeType,
                                         detail::ArrayTypeStorage> {
 public:
   using Base::Base;
 
   static ArrayType get(Type elementType, unsigned elementCount);
 
   /// Returns an array type with the given stride in bytes.
   static ArrayType get(Type elementType, unsigned elementCount,
                        unsigned stride);
 
   unsigned getNumElements() const;
 
   Type getElementType() const;
 
   /// Returns the array stride in bytes. 0 means no stride decorated on this
   /// type.
   unsigned getArrayStride() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 
   /// Returns the array size in bytes. Since array type may have an explicit
   /// stride declaration (in bytes), we also include it in the calculation.
-  Optional<int64_t> getSizeInBytes();
+  std::optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V image type
 class ImageType
     : public Type::TypeBase<ImageType, SPIRVType, detail::ImageTypeStorage> {
 public:
   using Base::Base;
 
public:
   ImageDepthInfo getDepthInfo() const;
   ImageArrayedInfo getArrayedInfo() const;
   ImageSamplingInfo getSamplingInfo() const;
   ImageSamplerUseInfo getSamplerUseInfo() const;
   ImageFormat getImageFormat() const;
   // TODO: Add support for Access qualifier
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 };
 
 // SPIR-V pointer type
 class PointerType : public Type::TypeBase<PointerType, SPIRVType,
                                           detail::PointerTypeStorage> {
 public:
   using Base::Base;
 
   static PointerType get(Type pointeeType, StorageClass storageClass);
 
   Type getPointeeType() const;
 
   StorageClass getStorageClass() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 };
 
 // SPIR-V run-time array type
 class RuntimeArrayType
     : public Type::TypeBase<RuntimeArrayType, SPIRVType,
                             detail::RuntimeArrayTypeStorage> {
 public:
   using Base::Base;
 
   static RuntimeArrayType get(Type elementType);
 
   /// Returns a runtime array type with the given stride in bytes.
   static RuntimeArrayType get(Type elementType, unsigned stride);
 
   Type getElementType() const;
 
   /// Returns the array stride in bytes. 0 means no stride decorated on this
   /// type.
   unsigned getArrayStride() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 };
 
 // SPIR-V sampled image type
 class SampledImageType
     : public Type::TypeBase<SampledImageType, SPIRVType,
                             detail::SampledImageTypeStorage> {
 public:
   using Base::Base;
 
   static SampledImageType get(Type imageType);
 
   static SampledImageType
   getChecked(function_ref<InFlightDiagnostic()> emitError, Type imageType);
 
   static LogicalResult verify(function_ref<InFlightDiagnostic()> emitError,
                               Type imageType);
 
   Type getImageType() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = std::nullopt);
-  void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = std::nullopt);
+                     std::optional<spirv::StorageClass> storage = std::nullopt);
+  void
+  getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
+                  std::optional<spirv::StorageClass> storage = std::nullopt);
 };
 
 /// SPIR-V struct type. Two kinds of struct types are supported:
 /// - Literal: a literal struct type is uniqued by its fields (types + offset
 /// info + decoration info).
 /// - Identified: an indentified struct type is uniqued by its string identifier
 /// (name). This is useful in representing recursive structs. For example, the
 /// following C struct:
public:
   /// Sets the contents of an incomplete identified StructType. This method must
   /// be called only for identified StructTypes and it must be called only once
   /// per instance. Otherwise, failure() is returned.
   LogicalResult
   trySetBody(ArrayRef<Type> memberTypes, ArrayRef<OffsetInfo> offsetInfo = {},
              ArrayRef<MemberDecorationInfo> memberDecorations = {});
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 };
 
 llvm::hash_code
 hash_value(const StructType::MemberDecorationInfo &memberDecorationInfo);
 
 // SPIR-V cooperative matrix type
 class CooperativeMatrixNVType
     : public Type::TypeBase<CooperativeMatrixNVType, CompositeType,
                             detail::CooperativeMatrixTypeStorage> {
 public:
   using Base::Base;
 
   static CooperativeMatrixNVType get(Type elementType, Scope scope,
                                      unsigned rows, unsigned columns);
   Type getElementType() const;
 
   /// Return the scope of the cooperative matrix.
   Scope getScope() const;
   /// return the number of rows of the matrix.
   unsigned getRows() const;
   /// return the number of columns of the matrix.
   unsigned getColumns() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 };
 
 // SPIR-V joint matrix type
 class JointMatrixINTELType
     : public Type::TypeBase<JointMatrixINTELType, CompositeType,
                             detail::JointMatrixTypeStorage> {
 public:
   using Base::Base;
 
   static JointMatrixINTELType get(Type elementType, Scope scope, unsigned rows,
                                   unsigned columns, MatrixLayout matrixLayout);
   Type getElementType() const;
 
   /// Return the scope of the joint matrix.
   Scope getScope() const;
   /// return the number of rows of the matrix.
   unsigned getRows() const;
   /// return the number of columns of the matrix.
   unsigned getColumns() const;
 
   /// return the layout of the matrix
   MatrixLayout getMatrixLayout() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 };
 
 // SPIR-V matrix type
 class MatrixType : public Type::TypeBase<MatrixType, CompositeType,
                                          detail::MatrixTypeStorage> {
 public:
   using Base::Base;
 
public:
 
   /// Returns total number of elements (rows*columns).
   unsigned getNumElements() const;
 
   /// Returns the elements' type (i.e, single element type).
   Type getElementType() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<StorageClass> storage = std::nullopt);
+                     std::optional<StorageClass> storage = std::nullopt);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<StorageClass> storage = std::nullopt);
+                       std::optional<StorageClass> storage = std::nullopt);
 };
 
 } // namespace spirv
 } // namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_IR_SPIRVTYPES_H_

mlir/include/mlir/Transforms/DialectConversion.h

struct InputMapping {
       size_t inputNo, size;
       Value replacementValue;
     };
 
     /// Return the argument types for the new signature.
     ArrayRef<Type> getConvertedTypes() const { return argTypes; }
 
     /// Get the input mapping for the given argument.
-    Optional<InputMapping> getInputMapping(unsigned input) const {
+    std::optional<InputMapping> getInputMapping(unsigned input) const {
       return remappedInputs[input];
     }
 
     //===------------------------------------------------------------------===//
     // Conversion Hooks
     //===------------------------------------------------------------------===//
 
     /// Remap an input of the original signature with a new set of types. The
public:
 
   private:
     /// Remap an input of the original signature with a range of types in the
     /// new signature.
     void remapInput(unsigned origInputNo, unsigned newInputNo,
                     unsigned newInputCount = 1);
 
     /// The remapping information for each of the original arguments.
-    SmallVector<Optional<InputMapping>, 4> remappedInputs;
+    SmallVector<std::optional<InputMapping>, 4> remappedInputs;
 
     /// The set of new argument types.
     SmallVector<Type, 4> argTypes;
   };
 
   /// Register a conversion function. A conversion function must be convertible
   /// to any of the following forms(where `T` is a class derived from `Type`:
-  ///   * Optional<Type>(T)
+  ///   * std::optional<Type>(T)
   ///     - This form represents a 1-1 type conversion. It should return nullptr
   ///       or `std::nullopt` to signify failure. If `std::nullopt` is returned,
   ///       the converter is allowed to try another conversion function to
   ///       perform the conversion.
-  ///   * Optional<LogicalResult>(T, SmallVectorImpl<Type> &)
+  ///   * std::optional<LogicalResult>(T, SmallVectorImpl<Type> &)
   ///     - This form represents a 1-N type conversion. It should return
   ///       `failure` or `std::nullopt` to signify a failed conversion. If the
   ///       new set of types is empty, the type is removed and any usages of the
   ///       existing value are expected to be removed during conversion. If
   ///       `std::nullopt` is returned, the converter is allowed to try another
   ///       conversion function to perform the conversion.
-  ///   * Optional<LogicalResult>(T, SmallVectorImpl<Type> &, ArrayRef<Type>)
+  ///   * std::optional<LogicalResult>(T, SmallVectorImpl<Type> &,
+  ///   ArrayRef<Type>)
   ///     - This form represents a 1-N type conversion supporting recursive
   ///       types. The first two arguments and the return value are the same as
   ///       for the regular 1-N form. The third argument is contains is the
   ///       "call stack" of the recursive conversion: it contains the list of
   ///       types currently being converted, with the current type being the
   ///       last one. If it is present more than once in the list, the
   ///       conversion concerns a recursive type.
   /// Note: When attempting to convert a type, e.g. via 'convertType', the
   ///       mostly recently added conversions will be invoked first.
   template <typename FnT, typename T = typename llvm::function_traits<
                               std::decay_t<FnT>>::template arg_t<0>>
   void addConversion(FnT &&callback) {
     registerConversion(wrapCallback<T>(std::forward<FnT>(callback)));
   }
 
   /// Register a materialization function, which must be convertible to the
   /// following form:
-  ///   `Optional<Value>(OpBuilder &, T, ValueRange, Location)`,
+  ///   `std::optional<Value>(OpBuilder &, T, ValueRange, Location)`,
   /// where `T` is any subclass of `Type`. This function is responsible for
   /// creating an operation, using the OpBuilder and Location provided, that
   /// "casts" a range of values into a single value of the given type `T`. It
   /// must return a Value of the converted type on success, an `std::nullopt` if
   /// it failed but other materialization can be attempted, and `nullptr` on
   /// unrecoverable failure. It will only be called for (sub)types of `T`.
   /// Materialization functions must be provided when a type conversion may
   /// persist after the conversion has finished.
LogicalResult convertSignatureArg(unsigned inputNo, Type type,
                                     SignatureConversion &result);
   LogicalResult convertSignatureArgs(TypeRange types,
                                      SignatureConversion &result,
                                      unsigned origInputOffset = 0);
 
   /// This function converts the type signature of the given block, by invoking
   /// 'convertSignatureArg' for each argument. This function should return a
   /// valid conversion for the signature on success, std::nullopt otherwise.
-  Optional<SignatureConversion> convertBlockSignature(Block *block);
+  std::optional<SignatureConversion> convertBlockSignature(Block *block);
 
   /// Materialize a conversion from a set of types into one result type by
   /// generating a cast sequence of some kind. See the respective
   /// `add*Materialization` for more information on the context for these
   /// methods.
   Value materializeArgumentConversion(OpBuilder &builder, Location loc,
                                       Type resultType, ValueRange inputs) {
     return materializeConversion(argumentMaterializations, builder, loc,
Value materializeTargetConversion(OpBuilder &builder, Location loc,
     return materializeConversion(targetMaterializations, builder, loc,
                                  resultType, inputs);
   }
 
 private:
   /// The signature of the callback used to convert a type. If the new set of
   /// types is empty, the type is removed and any usages of the existing value
   /// are expected to be removed during conversion.
-  using ConversionCallbackFn = std::function<Optional<LogicalResult>(
+  using ConversionCallbackFn = std::function<std::optional<LogicalResult>(
       Type, SmallVectorImpl<Type> &, ArrayRef<Type>)>;
 
   /// The signature of the callback used to materialize a conversion.
-  using MaterializationCallbackFn =
-      std::function<Optional<Value>(OpBuilder &, Type, ValueRange, Location)>;
+  using MaterializationCallbackFn = std::function<std::optional<Value>(
+      OpBuilder &, Type, ValueRange, Location)>;
 
   /// Attempt to materialize a conversion using one of the provided
   /// materialization functions.
   Value materializeConversion(
       MutableArrayRef<MaterializationCallbackFn> materializations,
       OpBuilder &builder, Location loc, Type resultType, ValueRange inputs);
 
   /// Generate a wrapper for the given callback. This allows for accepting
   /// different callback forms, that all compose into a single version.
-  /// With callback of form: `Optional<Type>(T)`
+  /// With callback of form: `std::optional<Type>(T)`
   template <typename T, typename FnT>
   std::enable_if_t<std::is_invocable_v<FnT, T>, ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return wrapCallback<T>(
         [callback = std::forward<FnT>(callback)](
             T type, SmallVectorImpl<Type> &results, ArrayRef<Type>) {
-          if (Optional<Type> resultOpt = callback(type)) {
+          if (std::optional<Type> resultOpt = callback(type)) {
             bool wasSuccess = static_cast<bool>(*resultOpt);
             if (wasSuccess)
               results.push_back(*resultOpt);
-            return Optional<LogicalResult>(success(wasSuccess));
+            return std::optional<LogicalResult>(success(wasSuccess));
           }
-          return Optional<LogicalResult>();
+          return std::optional<LogicalResult>();
         });
   }
-  /// With callback of form: `Optional<LogicalResult>(T, SmallVectorImpl<Type>
+  /// With callback of form: `std::optional<LogicalResult>(T,
+  /// SmallVectorImpl<Type>
   /// &)`
   template <typename T, typename FnT>
   std::enable_if_t<std::is_invocable_v<FnT, T, SmallVectorImpl<Type> &>,
                    ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return wrapCallback<T>(
         [callback = std::forward<FnT>(callback)](
             T type, SmallVectorImpl<Type> &results, ArrayRef<Type>) {
           return callback(type, results);
         });
   }
-  /// With callback of form: `Optional<LogicalResult>(T, SmallVectorImpl<Type>
+  /// With callback of form: `std::optional<LogicalResult>(T,
+  /// SmallVectorImpl<Type>
   /// &, ArrayRef<Type>)`.
   template <typename T, typename FnT>
   std::enable_if_t<
       std::is_invocable_v<FnT, T, SmallVectorImpl<Type> &, ArrayRef<Type>>,
       ConversionCallbackFn>
   wrapCallback(FnT &&callback) {
     return [callback = std::forward<FnT>(callback)](
                Type type, SmallVectorImpl<Type> &results,
-               ArrayRef<Type> callStack) -> Optional<LogicalResult> {
+               ArrayRef<Type> callStack) -> std::optional<LogicalResult> {
       T derivedType = type.dyn_cast<T>();
       if (!derivedType)
         return std::nullopt;
       return callback(derivedType, results, callStack);
     };
   }
 
   /// Register a type conversion.
   void registerConversion(ConversionCallbackFn callback) {
     conversions.emplace_back(std::move(callback));
     cachedDirectConversions.clear();
     cachedMultiConversions.clear();
   }
 
   /// Generate a wrapper for the given materialization callback. The callback
   /// may take any subclass of `Type` and the wrapper will check for the target
   /// type to be of the expected class before calling the callback.
   template <typename T, typename FnT>
   MaterializationCallbackFn wrapMaterialization(FnT &&callback) {
     return [callback = std::forward<FnT>(callback)](
                OpBuilder &builder, Type resultType, ValueRange inputs,
-               Location loc) -> Optional<Value> {
+               Location loc) -> std::optional<Value> {
       if (T derivedType = resultType.dyn_cast<T>())
         return callback(builder, derivedType, inputs, loc);
       return std::nullopt;
     };
   }
 
   /// The set of registered conversion functions.
   SmallVector<ConversionCallbackFn, 4> conversions;
struct LegalOpDetails {
     /// A flag that indicates if this operation is 'recursively' legal. This
     /// means that if an operation is legal, either statically or dynamically,
     /// all of the operations nested within are also considered legal.
     bool isRecursivelyLegal = false;
   };
 
   /// The signature of the callback used to determine if an operation is
   /// dynamically legal on the target.
-  using DynamicLegalityCallbackFn = std::function<Optional<bool>(Operation *)>;
+  using DynamicLegalityCallbackFn =
+      std::function<std::optional<bool>(Operation *)>;
 
   ConversionTarget(MLIRContext &ctx) : ctx(ctx) {}
   virtual ~ConversionTarget() = default;
 
   //===--------------------------------------------------------------------===//
   // Legality Registration
   //===--------------------------------------------------------------------===//
 
void addIllegalDialect() {
     setDialectAction(dialectNames, LegalizationAction::Illegal);
   }
 
   //===--------------------------------------------------------------------===//
   // Legality Querying
   //===--------------------------------------------------------------------===//
 
   /// Get the legality action for the given operation.
-  Optional<LegalizationAction> getOpAction(OperationName op) const;
+  std::optional<LegalizationAction> getOpAction(OperationName op) const;
 
   /// If the given operation instance is legal on this target, a structure
   /// containing legality information is returned. If the operation is not
   /// legal, std::nullopt is returned. Also returns std::nullopt if operation
   /// legality wasn't registered by user or dynamic legality callbacks returned
   /// None.
   ///
   /// Note: Legality is actually a 4-state: Legal(recursive=true),
   /// Legal(recursive=false), Illegal or Unknown, where Unknown is treated
   /// either as Legal or Illegal depending on context.
-  Optional<LegalOpDetails> isLegal(Operation *op) const;
+  std::optional<LegalOpDetails> isLegal(Operation *op) const;
 
   /// Returns true is operation instance is illegal on this target. Returns
   /// false if operation is legal, operation legality wasn't registered by user
   /// or dynamic legality callbacks returned None.
   bool isIllegal(Operation *op) const;
 
 private:
   /// Set the dynamic legality callback for the given operation.
struct LegalizationInfo {
     /// If some legal instances of this operation may also be recursively legal.
     bool isRecursivelyLegal = false;
 
     /// The legality callback if this operation is dynamically legal.
     DynamicLegalityCallbackFn legalityFn;
   };
 
   /// Get the legalization information for the given operation.
-  Optional<LegalizationInfo> getOpInfo(OperationName op) const;
+  std::optional<LegalizationInfo> getOpInfo(OperationName op) const;
 
   /// A deterministic mapping of operation name and its respective legality
   /// information.
   llvm::MapVector<OperationName, LegalizationInfo> legalOperations;
 
   /// A set of legality callbacks for given operation names that are used to
   /// check if an operation instance is recursively legal.
   DenseMap<OperationName, DynamicLegalityCallbackFn> opRecursiveLegalityFns;

mlir/lib/Conversion/ArithToSPIRV/ArithToSPIRV.cpp

void runOnOperation() override {
     options.enableFastMathMode = this->enableFastMath;
     SPIRVTypeConverter typeConverter(targetAttr, options);
 
     // Use UnrealizedConversionCast as the bridge so that we don't need to pull
     // in patterns for other dialects.
     auto addUnrealizedCast = [](OpBuilder &builder, Type type,
                                 ValueRange inputs, Location loc) {
       auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);
-      return Optional<Value>(cast.getResult(0));
+      return std::optional<Value>(cast.getResult(0));
     };
     typeConverter.addSourceMaterialization(addUnrealizedCast);
     typeConverter.addTargetMaterialization(addUnrealizedCast);
     target->addLegalOp<UnrealizedConversionCastOp>();
 
     // Fail hard when there are any remaining 'arith' ops.
     target->addIllegalDialect<arith::ArithDialect>();
 

mlir/lib/Conversion/AsyncToLLVM/AsyncToLLVM.cpp

AsyncRuntimeTypeConverter() {
     addConversion([](Type type) { return type; });
     addConversion(convertAsyncTypes);
 
     // Use UnrealizedConversionCast as the bridge so that we don't need to pull
     // in patterns for other dialects.
     auto addUnrealizedCast = [](OpBuilder &builder, Type type,
                                 ValueRange inputs, Location loc) {
       auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);
-      return Optional<Value>(cast.getResult(0));
+      return std::optional<Value>(cast.getResult(0));
     };
 
     addSourceMaterialization(addUnrealizedCast);
     addTargetMaterialization(addUnrealizedCast);
   }
 
-  static Optional<Type> convertAsyncTypes(Type type) {
+  static std::optional<Type> convertAsyncTypes(Type type) {
     if (type.isa<TokenType, GroupType, ValueType>())
       return AsyncAPI::opaquePointerType(type.getContext());
 
     if (type.isa<CoroIdType, CoroStateType>())
       return AsyncAPI::tokenType(type.getContext());
     if (type.isa<CoroHandleType>())
       return AsyncAPI::opaquePointerType(type.getContext());
 

mlir/lib/Conversion/GPUToNVVM/LowerGpuOpsToNVVMOps.cpp

void runOnOperation() override {
     if (indexBitwidth != kDeriveIndexBitwidthFromDataLayout)
       options.overrideIndexBitwidth(indexBitwidth);
 
     // MemRef conversion for GPU to NVVM lowering. The GPU dialect uses memory
     // space 5 for private memory attributions, but NVVM represents private
     // memory allocations as local `alloca`s in the default address space. This
     // converter drops the private memory space to support the use case above.
     LLVMTypeConverter converter(m.getContext(), options);
-    converter.addConversion([&](MemRefType type) -> Optional<Type> {
+    converter.addConversion([&](MemRefType type) -> std::optional<Type> {
       if (type.getMemorySpaceAsInt() !=
           gpu::GPUDialect::getPrivateAddressSpace())
         return std::nullopt;
       return converter.convertType(MemRefType::Builder(type).setMemorySpace(
           IntegerAttr::get(IntegerType::get(m.getContext(), 64), 0)));
     });
     // Lowering for MMAMatrixType.
     converter.addConversion([&](gpu::MMAMatrixType type) -> Type {

mlir/lib/Conversion/LLVMCommon/TypeConverter.cpp

LLVMTypeConverter::LLVMTypeConverter(MLIRContext *ctx,
   addConversion(
       [&](UnrankedMemRefType type) { return convertUnrankedMemRefType(type); });
   addConversion([&](VectorType type) { return convertVectorType(type); });
 
   // LLVM-compatible types are legal, so add a pass-through conversion. Do this
   // before the conversions below since conversions are attempted in reverse
   // order and those should take priority.
   addConversion([](Type type) {
-    return LLVM::isCompatibleType(type) ? llvm::Optional<Type>(type)
+    return LLVM::isCompatibleType(type) ? std::optional<Type>(type)
                                         : std::nullopt;
   });
 
   // LLVM container types may (recursively) contain other types that must be
   // converted even when the outer type is compatible.
-  addConversion([&](LLVM::LLVMPointerType type) -> llvm::Optional<Type> {
+  addConversion([&](LLVM::LLVMPointerType type) -> std::optional<Type> {
     if (type.isOpaque())
       return type;
     if (auto pointee = convertType(type.getElementType()))
       return LLVM::LLVMPointerType::get(pointee, type.getAddressSpace());
     return std::nullopt;
   });
   addConversion([&](LLVM::LLVMStructType type, SmallVectorImpl<Type> &results,
-                    ArrayRef<Type> callStack) -> llvm::Optional<LogicalResult> {
+                    ArrayRef<Type> callStack) -> std::optional<LogicalResult> {
     // Fastpath for types that won't be converted by this callback anyway.
     if (LLVM::isCompatibleType(type)) {
       results.push_back(type);
       return success();
     }
 
     if (type.isIdentified()) {
       auto convertedType = LLVM::LLVMStructType::getIdentified(
addConversion([&](LLVM::LLVMStructType type, SmallVectorImpl<Type> &results,
     convertedSubtypes.reserve(type.getBody().size());
     if (failed(convertTypes(type.getBody(), convertedSubtypes)))
       return std::nullopt;
 
     results.push_back(LLVM::LLVMStructType::getLiteral(
         type.getContext(), convertedSubtypes, type.isPacked()));
     return success();
   });
-  addConversion([&](LLVM::LLVMArrayType type) -> llvm::Optional<Type> {
+  addConversion([&](LLVM::LLVMArrayType type) -> std::optional<Type> {
     if (auto element = convertType(type.getElementType()))
       return LLVM::LLVMArrayType::get(element, type.getNumElements());
     return std::nullopt;
   });
-  addConversion([&](LLVM::LLVMFunctionType type) -> llvm::Optional<Type> {
+  addConversion([&](LLVM::LLVMFunctionType type) -> std::optional<Type> {
     Type convertedResType = convertType(type.getReturnType());
     if (!convertedResType)
       return std::nullopt;
 
     SmallVector<Type> convertedArgTypes;
     convertedArgTypes.reserve(type.getNumParams());
     if (failed(convertTypes(type.getParams(), convertedArgTypes)))
       return std::nullopt;
 
     return LLVM::LLVMFunctionType::get(convertedResType, convertedArgTypes,
                                        type.isVarArg());
   });
 
   // Materialization for memrefs creates descriptor structs from individual
   // values constituting them, when descriptors are used, i.e. more than one
   // value represents a memref.
   addArgumentMaterialization(
       [&](OpBuilder &builder, UnrankedMemRefType resultType, ValueRange inputs,
-          Location loc) -> Optional<Value> {
+          Location loc) -> std::optional<Value> {
         if (inputs.size() == 1)
           return std::nullopt;
         return UnrankedMemRefDescriptor::pack(builder, loc, *this, resultType,
                                               inputs);
       });
   addArgumentMaterialization([&](OpBuilder &builder, MemRefType resultType,
                                  ValueRange inputs,
-                                 Location loc) -> Optional<Value> {
+                                 Location loc) -> std::optional<Value> {
     // TODO: bare ptr conversion could be handled here but we would need a way
     // to distinguish between FuncOp and other regions.
     if (inputs.size() == 1)
       return std::nullopt;
     return MemRefDescriptor::pack(builder, loc, *this, resultType, inputs);
   });
   // Add generic source and target materializations to handle cases where
   // non-LLVM types persist after an LLVM conversion.
   addSourceMaterialization([&](OpBuilder &builder, Type resultType,
                                ValueRange inputs,
-                               Location loc) -> Optional<Value> {
+                               Location loc) -> std::optional<Value> {
     if (inputs.size() != 1)
       return std::nullopt;
 
     return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs)
         .getResult(0);
   });
   addTargetMaterialization([&](OpBuilder &builder, Type resultType,
                                ValueRange inputs,
-                               Location loc) -> Optional<Value> {
+                               Location loc) -> std::optional<Value> {
     if (inputs.size() != 1)
       return std::nullopt;
 
     return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs)
         .getResult(0);
   });
 }
 

mlir/lib/Conversion/MathToSPIRV/MathToSPIRVPass.cpp

void ConvertMathToSPIRVPass::runOnOperation() {
 
   SPIRVTypeConverter typeConverter(targetAttr);
 
   // Use UnrealizedConversionCast as the bridge so that we don't need to pull
   // in patterns for other dialects.
   auto addUnrealizedCast = [](OpBuilder &builder, Type type, ValueRange inputs,
                               Location loc) {
     auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);
-    return Optional<Value>(cast.getResult(0));
+    return std::optional<Value>(cast.getResult(0));
   };
   typeConverter.addSourceMaterialization(addUnrealizedCast);
   typeConverter.addTargetMaterialization(addUnrealizedCast);
   target->addLegalOp<UnrealizedConversionCastOp>();
 
   RewritePatternSet patterns(context);
   populateMathToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(op, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<>> mlir::createConvertMathToSPIRVPass() {
   return std::make_unique<ConvertMathToSPIRVPass>();
 }

mlir/lib/Conversion/MemRefToSPIRV/MapMemRefStorageClassPass.cpp

#define VULKAN_STORAGE_SPACE_MAP_LIST(MAP_FN)                                  \
   MAP_FN(spirv::StorageClass::Uniform, 4)                                      \
   MAP_FN(spirv::StorageClass::Private, 5)                                      \
   MAP_FN(spirv::StorageClass::Function, 6)                                     \
   MAP_FN(spirv::StorageClass::PushConstant, 7)                                 \
   MAP_FN(spirv::StorageClass::UniformConstant, 8)                              \
   MAP_FN(spirv::StorageClass::Input, 9)                                        \
   MAP_FN(spirv::StorageClass::Output, 10)
 
-Optional<spirv::StorageClass>
+std::optional<spirv::StorageClass>
 spirv::mapMemorySpaceToVulkanStorageClass(Attribute memorySpaceAttr) {
   // Handle null memory space attribute specially.
   if (!memorySpaceAttr)
     return spirv::StorageClass::StorageBuffer;
 
   // Unknown dialect custom attributes are not supported by default.
   // Downstream callers should plug in more specialized ones.
   auto intAttr = memorySpaceAttr.dyn_cast<IntegerAttr>();
#define STORAGE_SPACE_MAP_FN(storage, space)                                   \
   default:
     break;
   }
   return std::nullopt;
 
 #undef STORAGE_SPACE_MAP_FN
 }
 
-Optional<unsigned>
+std::optional<unsigned>
 spirv::mapVulkanStorageClassToMemorySpace(spirv::StorageClass storageClass) {
 #define STORAGE_SPACE_MAP_FN(storage, space)                                   \
   case storage:                                                                \
     return space;
 
   switch (storageClass) {
     VULKAN_STORAGE_SPACE_MAP_LIST(STORAGE_SPACE_MAP_FN)
   default:
#define OPENCL_STORAGE_SPACE_MAP_LIST(MAP_FN)                                  \
   MAP_FN(spirv::StorageClass::CrossWorkgroup, 0)                               \
   MAP_FN(spirv::StorageClass::Generic, 1)                                      \
   MAP_FN(spirv::StorageClass::Workgroup, 3)                                    \
   MAP_FN(spirv::StorageClass::UniformConstant, 4)                              \
   MAP_FN(spirv::StorageClass::Private, 5)                                      \
   MAP_FN(spirv::StorageClass::Function, 6)                                     \
   MAP_FN(spirv::StorageClass::Image, 7)
 
-Optional<spirv::StorageClass>
+std::optional<spirv::StorageClass>
 spirv::mapMemorySpaceToOpenCLStorageClass(Attribute memorySpaceAttr) {
   // Handle null memory space attribute specially.
   if (!memorySpaceAttr)
     return spirv::StorageClass::CrossWorkgroup;
 
   // Unknown dialect custom attributes are not supported by default.
   // Downstream callers should plug in more specialized ones.
   auto intAttr = memorySpaceAttr.dyn_cast<IntegerAttr>();
#define STORAGE_SPACE_MAP_FN(storage, space)                                   \
   default:
     break;
   }
   return std::nullopt;
 
 #undef STORAGE_SPACE_MAP_FN
 }
 
-Optional<unsigned>
+std::optional<unsigned>
 spirv::mapOpenCLStorageClassToMemorySpace(spirv::StorageClass storageClass) {
 #define STORAGE_SPACE_MAP_FN(storage, space)                                   \
   case storage:                                                                \
     return space;
 
   switch (storageClass) {
     OPENCL_STORAGE_SPACE_MAP_LIST(STORAGE_SPACE_MAP_FN)
   default:

 //===----------------------------------------------------------------------===//
 
 spirv::MemorySpaceToStorageClassConverter::MemorySpaceToStorageClassConverter(
     const spirv::MemorySpaceToStorageClassMap &memorySpaceMap)
     : memorySpaceMap(memorySpaceMap) {
   // Pass through for all other types.
   addConversion([](Type type) { return type; });
 
-  addConversion([this](BaseMemRefType memRefType) -> Optional<Type> {
-    Optional<spirv::StorageClass> storage =
+  addConversion([this](BaseMemRefType memRefType) -> std::optional<Type> {
+    std::optional<spirv::StorageClass> storage =
         this->memorySpaceMap(memRefType.getMemorySpace());
     if (!storage) {
       LLVM_DEBUG(llvm::dbgs()
                  << "cannot convert " << memRefType
                  << " due to being unable to find memory space in map\n");
       return std::nullopt;
     }
 

mlir/lib/Conversion/MemRefToSPIRV/MemRefToSPIRVPass.cpp

void ConvertMemRefToSPIRVPass::runOnOperation() {
   options.boolNumBits = this->boolNumBits;
   SPIRVTypeConverter typeConverter(targetAttr, options);
 
   // Use UnrealizedConversionCast as the bridge so that we don't need to pull in
   // patterns for other dialects.
   auto addUnrealizedCast = [](OpBuilder &builder, Type type, ValueRange inputs,
                               Location loc) {
     auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);
-    return Optional<Value>(cast.getResult(0));
+    return std::optional<Value>(cast.getResult(0));
   };
   typeConverter.addSourceMaterialization(addUnrealizedCast);
   typeConverter.addTargetMaterialization(addUnrealizedCast);
   target->addLegalOp<UnrealizedConversionCastOp>();
 
   RewritePatternSet patterns(context);
   populateMemRefToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(op, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<>> mlir::createConvertMemRefToSPIRVPass() {
   return std::make_unique<ConvertMemRefToSPIRVPass>();
 }

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

static Value processCountOrOffset(Location loc, Value value, Type srcType,
                                   ConversionPatternRewriter &rewriter) {
   Value broadcasted =
       optionallyBroadcast(loc, value, srcType, converter, rewriter);
   return optionallyTruncateOrExtend(loc, broadcasted, dstType, rewriter);
 }
 
 /// Converts SPIR-V struct with a regular (according to `VulkanLayoutUtils`)
 /// offset to LLVM struct. Otherwise, the conversion is not supported.
-static Optional<Type>
+static std::optional<Type>
 convertStructTypeWithOffset(spirv::StructType type,
                             LLVMTypeConverter &converter) {
   if (type != VulkanLayoutUtils::decorateType(type))
     return std::nullopt;
 
   auto elementsVector = llvm::to_vector<8>(
       llvm::map_range(type.getElementTypes(), [&](Type elementType) {
         return converter.convertType(elementType);

 
 //===----------------------------------------------------------------------===//
 // Type conversion
 //===----------------------------------------------------------------------===//
 
 /// Converts SPIR-V array type to LLVM array. Natural stride (according to
 /// `VulkanLayoutUtils`) is also mapped to LLVM array. This has to be respected
 /// when converting ops that manipulate array types.
-static Optional<Type> convertArrayType(spirv::ArrayType type,
+static std::optional<Type> convertArrayType(spirv::ArrayType type,
                                             TypeConverter &converter) {
   unsigned stride = type.getArrayStride();
   Type elementType = type.getElementType();
   auto sizeInBytes = elementType.cast<spirv::SPIRVType>().getSizeInBytes();
   if (stride != 0 && (!sizeInBytes || *sizeInBytes != stride))
     return std::nullopt;
 
   auto llvmElementType = converter.convertType(elementType);
   unsigned numElements = type.getNumElements();
   return LLVM::LLVMArrayType::get(llvmElementType, numElements);
 }
 
 /// Converts SPIR-V pointer type to LLVM pointer. Pointer's storage class is not
 /// modelled at the moment.
 static Type convertPointerType(spirv::PointerType type,
                                TypeConverter &converter) {
   auto pointeeType = converter.convertType(type.getPointeeType());
   return LLVM::LLVMPointerType::get(pointeeType);
 }
 
 /// Converts SPIR-V runtime array to LLVM array. Since LLVM allows indexing over
 /// the bounds, the runtime array is converted to a 0-sized LLVM array. There is
 /// no modelling of array stride at the moment.
-static Optional<Type> convertRuntimeArrayType(spirv::RuntimeArrayType type,
+static std::optional<Type> convertRuntimeArrayType(spirv::RuntimeArrayType type,
                                                    TypeConverter &converter) {
   if (type.getArrayStride() != 0)
     return std::nullopt;
   auto elementType = converter.convertType(type.getElementType());
   return LLVM::LLVMArrayType::get(elementType, 0);
 }
 
 /// Converts SPIR-V struct to LLVM struct. There is no support of structs with
 /// member decorations. Also, only natural offset is supported.
-static Optional<Type> convertStructType(spirv::StructType type,
+static std::optional<Type> convertStructType(spirv::StructType type,
                                              LLVMTypeConverter &converter) {
   SmallVector<spirv::StructType::MemberDecorationInfo, 4> memberDecorations;
   type.getMemberDecorations(memberDecorations);
   if (!memberDecorations.empty())
     return std::nullopt;
   if (type.hasOffset())
     return convertStructTypeWithOffset(type, converter);
   return convertStructTypePacked(type, converter);
 }

mlir/lib/Conversion/VectorToSPIRV/VectorToSPIRVPass.cpp

void ConvertVectorToSPIRVPass::runOnOperation() {
 
   SPIRVTypeConverter typeConverter(targetAttr);
 
   // Use UnrealizedConversionCast as the bridge so that we don't need to pull in
   // patterns for other dialects.
   auto addUnrealizedCast = [](OpBuilder &builder, Type type, ValueRange inputs,
                               Location loc) {
     auto cast = builder.create<UnrealizedConversionCastOp>(loc, type, inputs);
-    return Optional<Value>(cast.getResult(0));
+    return std::optional<Value>(cast.getResult(0));
   };
   typeConverter.addSourceMaterialization(addUnrealizedCast);
   typeConverter.addTargetMaterialization(addUnrealizedCast);
   target->addLegalOp<UnrealizedConversionCastOp>();
 
   RewritePatternSet patterns(context);
   populateVectorToSPIRVPatterns(typeConverter, patterns);
 
   if (failed(applyPartialConversion(op, *target, std::move(patterns))))
     return signalPassFailure();
 }
 
 std::unique_ptr<OperationPass<>> mlir::createConvertVectorToSPIRVPass() {
   return std::make_unique<ConvertVectorToSPIRVPass>();
 }

mlir/lib/Dialect/Arith/Transforms/EmulateWideInt.cpp

 arith::WideIntEmulationConverter::WideIntEmulationConverter(
     unsigned widestIntSupportedByTarget)
     : maxIntWidth(widestIntSupportedByTarget) {
   assert(llvm::isPowerOf2_32(widestIntSupportedByTarget) &&
          "Only power-of-two integers with are supported");
   assert(widestIntSupportedByTarget >= 2 && "Integer type too narrow");
 
   // Allow unknown types.
-  addConversion([](Type ty) -> Optional<Type> { return ty; });
+  addConversion([](Type ty) -> std::optional<Type> { return ty; });
 
   // Scalar case.
-  addConversion([this](IntegerType ty) -> Optional<Type> {
+  addConversion([this](IntegerType ty) -> std::optional<Type> {
     unsigned width = ty.getWidth();
     if (width <= maxIntWidth)
       return ty;
 
     // i2N --> vector<2xiN>
     if (width == 2 * maxIntWidth)
       return VectorType::get(2, IntegerType::get(ty.getContext(), maxIntWidth));
 
     return std::nullopt;
   });
 
   // Vector case.
-  addConversion([this](VectorType ty) -> Optional<Type> {
+  addConversion([this](VectorType ty) -> std::optional<Type> {
     auto intTy = ty.getElementType().dyn_cast<IntegerType>();
     if (!intTy)
       return ty;
 
     unsigned width = intTy.getWidth();
     if (width <= maxIntWidth)
       return ty;
 
     // vector<...xi2N> --> vector<...x2xiN>
     if (width == 2 * maxIntWidth) {
       auto newShape = to_vector(ty.getShape());
       newShape.push_back(2);
       return VectorType::get(newShape,
                              IntegerType::get(ty.getContext(), maxIntWidth));
     }
 
     return std::nullopt;
   });
 
   // Function case.
-  addConversion([this](FunctionType ty) -> Optional<Type> {
+  addConversion([this](FunctionType ty) -> std::optional<Type> {
     // Convert inputs and results, e.g.:
     //   (i2N, i2N) -> i2N --> (vector<2xiN>, vector<2xiN>) -> vector<2xiN>
     SmallVector<Type> inputs;
     if (failed(convertTypes(ty.getInputs(), inputs)))
       return std::nullopt;
 
     SmallVector<Type> results;
     if (failed(convertTypes(ty.getResults(), results)))

mlir/lib/Dialect/Arith/Transforms/UnsignedWhenEquivalent.cpp

void runOnOperation() override {
     if (failed(solver.initializeAndRun(op)))
       return signalPassFailure();
 
     ConversionTarget target(*ctx);
     target.addLegalDialect<ArithDialect>();
     target
         .addDynamicallyLegalOp<DivSIOp, CeilDivSIOp, CeilDivUIOp, FloorDivSIOp,
                                RemSIOp, MinSIOp, MaxSIOp, ExtSIOp>(
-            [&solver](Operation *op) -> Optional<bool> {
+            [&solver](Operation *op) -> std::optional<bool> {
               return failed(staticallyNonNegative(solver, op));
             });
     target.addDynamicallyLegalOp<CmpIOp>(
-        [&solver](CmpIOp op) -> Optional<bool> {
+        [&solver](CmpIOp op) -> std::optional<bool> {
           return failed(isCmpIConvertable(solver, op));
         });
 
     RewritePatternSet patterns(ctx);
     patterns.add<ConvertOpToUnsigned<DivSIOp, DivUIOp>,
                  ConvertOpToUnsigned<CeilDivSIOp, CeilDivUIOp>,
                  ConvertOpToUnsigned<FloorDivSIOp, DivUIOp>,
                  ConvertOpToUnsigned<RemSIOp, RemUIOp>,

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

void memref::populateMemRefWideIntEmulationPatterns(
   // Populate `memref.*` conversion patterns.
   patterns.add<ConvertMemRefAlloc, ConvertMemRefLoad, ConvertMemRefStore>(
       typeConverter, patterns.getContext());
 }
 
 void memref::populateMemRefWideIntEmulationConversions(
     arith::WideIntEmulationConverter &typeConverter) {
   typeConverter.addConversion(
-      [&typeConverter](MemRefType ty) -> Optional<Type> {
+      [&typeConverter](MemRefType ty) -> std::optional<Type> {
         auto intTy = ty.getElementType().dyn_cast<IntegerType>();
         if (!intTy)
           return ty;
 
         if (intTy.getIntOrFloatBitWidth() <=
             typeConverter.getMaxTargetIntBitWidth())
           return ty;
 
         Type newElemTy = typeConverter.convertType(intTy);
         if (!newElemTy)
           return std::nullopt;
 
         return ty.cloneWith(std::nullopt, newElemTy);
       });
 }

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

 
 unsigned ArrayType::getNumElements() const { return getImpl()->elementCount; }
 
 Type ArrayType::getElementType() const { return getImpl()->elementType; }
 
 unsigned ArrayType::getArrayStride() const { return getImpl()->stride; }
 
 void ArrayType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                              Optional<StorageClass> storage) {
+                              std::optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
 }
 
 void ArrayType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
 }
 
-Optional<int64_t> ArrayType::getSizeInBytes() {
+std::optional<int64_t> ArrayType::getSizeInBytes() {
   auto elementType = getElementType().cast<SPIRVType>();
-  Optional<int64_t> size = elementType.getSizeInBytes();
+  std::optional<int64_t> size = elementType.getSizeInBytes();
   if (!size)
     return std::nullopt;
   return (*size + getArrayStride()) * getNumElements();
 }
 
 //===----------------------------------------------------------------------===//
 // CompositeType
 //===----------------------------------------------------------------------===//

 
 bool CompositeType::hasCompileTimeKnownNumElements() const {
   return !isa<CooperativeMatrixNVType, JointMatrixINTELType,
               RuntimeArrayType>();
 }
 
 void CompositeType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   TypeSwitch<Type>(*this)
       .Case<ArrayType, CooperativeMatrixNVType, JointMatrixINTELType,
             MatrixType, RuntimeArrayType, StructType>(
           [&](auto type) { type.getExtensions(extensions, storage); })
       .Case<VectorType>([&](VectorType type) {
         return type.getElementType().cast<ScalarType>().getExtensions(
             extensions, storage);
       })
       .Default([](Type) { llvm_unreachable("invalid composite type"); });
 }
 
 void CompositeType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   TypeSwitch<Type>(*this)
       .Case<ArrayType, CooperativeMatrixNVType, JointMatrixINTELType,
             MatrixType, RuntimeArrayType, StructType>(
           [&](auto type) { type.getCapabilities(capabilities, storage); })
       .Case<VectorType>([&](VectorType type) {
         auto vecSize = getNumElements();
         if (vecSize == 8 || vecSize == 16) {
           static const Capability caps[] = {Capability::Vector16};
           ArrayRef<Capability> ref(caps, std::size(caps));
           capabilities.push_back(ref);
         }
         return type.getElementType().cast<ScalarType>().getCapabilities(
             capabilities, storage);
       })
       .Default([](Type) { llvm_unreachable("invalid composite type"); });
 }
 
-Optional<int64_t> CompositeType::getSizeInBytes() {
+std::optional<int64_t> CompositeType::getSizeInBytes() {
   if (auto arrayType = dyn_cast<ArrayType>())
     return arrayType.getSizeInBytes();
   if (auto structType = dyn_cast<StructType>())
     return structType.getSizeInBytes();
   if (auto vectorType = dyn_cast<VectorType>()) {
-    Optional<int64_t> elementSize =
+    std::optional<int64_t> elementSize =
         vectorType.getElementType().cast<ScalarType>().getSizeInBytes();
     if (!elementSize)
       return std::nullopt;
     return *elementSize * vectorType.getNumElements();
   }
   return std::nullopt;
 }
 

 unsigned CooperativeMatrixNVType::getRows() const { return getImpl()->rows; }
 
 unsigned CooperativeMatrixNVType::getColumns() const {
   return getImpl()->columns;
 }
 
 void CooperativeMatrixNVType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
   static const Extension exts[] = {Extension::SPV_NV_cooperative_matrix};
   ArrayRef<Extension> ref(exts, std::size(exts));
   extensions.push_back(ref);
 }
 
 void CooperativeMatrixNVType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
   static const Capability caps[] = {Capability::CooperativeMatrixNV};
   ArrayRef<Capability> ref(caps, std::size(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // JointMatrixType

 unsigned JointMatrixINTELType::getColumns() const { return getImpl()->columns; }
 
 MatrixLayout JointMatrixINTELType::getMatrixLayout() const {
   return getImpl()->matrixLayout;
 }
 
 void JointMatrixINTELType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
   static const Extension exts[] = {Extension::SPV_INTEL_joint_matrix};
   ArrayRef<Extension> ref(exts, std::size(exts));
   extensions.push_back(ref);
 }
 
 void JointMatrixINTELType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
   static const Capability caps[] = {Capability::JointMatrixINTEL};
   ArrayRef<Capability> ref(caps, std::size(caps));
   capabilities.push_back(ref);
 }
 
 //===----------------------------------------------------------------------===//
 // ImageType

 
 ImageSamplerUseInfo ImageType::getSamplerUseInfo() const {
   return getImpl()->samplerUseInfo;
 }
 
 ImageFormat ImageType::getImageFormat() const { return getImpl()->format; }
 
 void ImageType::getExtensions(SPIRVType::ExtensionArrayRefVector &,
-                              Optional<StorageClass>) {
+                              std::optional<StorageClass>) {
   // Image types do not require extra extensions thus far.
 }
 
 void ImageType::getCapabilities(
-    SPIRVType::CapabilityArrayRefVector &capabilities, Optional<StorageClass>) {
+    SPIRVType::CapabilityArrayRefVector &capabilities,
+    std::optional<StorageClass>) {
   if (auto dimCaps = spirv::getCapabilities(getDim()))
     capabilities.push_back(*dimCaps);
 
   if (auto fmtCaps = spirv::getCapabilities(getImageFormat()))
     capabilities.push_back(*fmtCaps);
 }
 
 //===----------------------------------------------------------------------===//

 
 Type PointerType::getPointeeType() const { return getImpl()->pointeeType; }
 
 StorageClass PointerType::getStorageClass() const {
   return getImpl()->storageClass;
 }
 
 void PointerType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                                Optional<StorageClass> storage) {
+                                std::optional<StorageClass> storage) {
   // Use this pointer type's storage class because this pointer indicates we are
   // using the pointee type in that specific storage class.
   getPointeeType().cast<SPIRVType>().getExtensions(extensions,
                                                    getStorageClass());
 
   if (auto scExts = spirv::getExtensions(getStorageClass()))
     extensions.push_back(*scExts);
 }
 
 void PointerType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   // Use this pointer type's storage class because this pointer indicates we are
   // using the pointee type in that specific storage class.
   getPointeeType().cast<SPIRVType>().getCapabilities(capabilities,
                                                      getStorageClass());
 
   if (auto scCaps = spirv::getCapabilities(getStorageClass()))
     capabilities.push_back(*scCaps);
 }

 }
 
 Type RuntimeArrayType::getElementType() const { return getImpl()->elementType; }
 
 unsigned RuntimeArrayType::getArrayStride() const { return getImpl()->stride; }
 
 void RuntimeArrayType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getElementType().cast<SPIRVType>().getExtensions(extensions, storage);
 }
 
 void RuntimeArrayType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   {
     static const Capability caps[] = {Capability::Shader};
     ArrayRef<Capability> ref(caps, std::size(caps));
     capabilities.push_back(ref);
   }
   getElementType().cast<SPIRVType>().getCapabilities(capabilities, storage);
 }
 
bool ScalarType::isValid(IntegerType type) {
   case 64:
     return true;
   default:
     return false;
   }
 }
 
 void ScalarType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                               Optional<StorageClass> storage) {
+                               std::optional<StorageClass> storage) {
   // 8- or 16-bit integer/floating-point numbers will require extra extensions
   // to appear in interface storage classes. See SPV_KHR_16bit_storage and
   // SPV_KHR_8bit_storage for more details.
   if (!storage)
     return;
 
   switch (*storage) {
   case StorageClass::PushConstant:
case StorageClass::Output:
     break;
   default:
     break;
   }
 }
 
 void ScalarType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   unsigned bitwidth = getIntOrFloatBitWidth();
 
   // 8- or 16-bit integer/floating-point numbers will require extra capabilities
   // to appear in interface storage classes. See SPV_KHR_16bit_storage and
   // SPV_KHR_8bit_storage for more details.
 
 #define STORAGE_CASE(storage, cap8, cap16)                                     \
   case StorageClass::storage: {                                                \
if (auto intType = dyn_cast<IntegerType>()) {
     default:
       llvm_unreachable("invalid bitwidth to getCapabilities");
     }
   }
 
 #undef WIDTH_CASE
 }
 
-Optional<int64_t> ScalarType::getSizeInBytes() {
+std::optional<int64_t> ScalarType::getSizeInBytes() {
   auto bitWidth = getIntOrFloatBitWidth();
   // According to the SPIR-V spec:
   // "There is no physical size or bit pattern defined for values with boolean
   // type. If they are stored (in conjunction with OpVariable), they can only
   // be used with logical addressing operations, not physical, and only with
   // non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup,
   // Private, Function, Input, and Output."
   if (bitWidth == 1)
bool SPIRVType::classof(Type type) {
   return false;
 }
 
 bool SPIRVType::isScalarOrVector() {
   return isIntOrFloat() || isa<VectorType>();
 }
 
 void SPIRVType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                              Optional<StorageClass> storage) {
+                              std::optional<StorageClass> storage) {
   if (auto scalarType = dyn_cast<ScalarType>()) {
     scalarType.getExtensions(extensions, storage);
   } else if (auto compositeType = dyn_cast<CompositeType>()) {
     compositeType.getExtensions(extensions, storage);
   } else if (auto imageType = dyn_cast<ImageType>()) {
     imageType.getExtensions(extensions, storage);
   } else if (auto sampledImageType = dyn_cast<SampledImageType>()) {
     sampledImageType.getExtensions(extensions, storage);
   } else if (auto matrixType = dyn_cast<MatrixType>()) {
     matrixType.getExtensions(extensions, storage);
   } else if (auto ptrType = dyn_cast<PointerType>()) {
     ptrType.getExtensions(extensions, storage);
   } else {
     llvm_unreachable("invalid SPIR-V Type to getExtensions");
   }
 }
 
 void SPIRVType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   if (auto scalarType = dyn_cast<ScalarType>()) {
     scalarType.getCapabilities(capabilities, storage);
   } else if (auto compositeType = dyn_cast<CompositeType>()) {
     compositeType.getCapabilities(capabilities, storage);
   } else if (auto imageType = dyn_cast<ImageType>()) {
     imageType.getCapabilities(capabilities, storage);
   } else if (auto sampledImageType = dyn_cast<SampledImageType>()) {
     sampledImageType.getCapabilities(capabilities, storage);
   } else if (auto matrixType = dyn_cast<MatrixType>()) {
     matrixType.getCapabilities(capabilities, storage);
   } else if (auto ptrType = dyn_cast<PointerType>()) {
     ptrType.getCapabilities(capabilities, storage);
   } else {
     llvm_unreachable("invalid SPIR-V Type to getCapabilities");
   }
 }
 
-Optional<int64_t> SPIRVType::getSizeInBytes() {
+std::optional<int64_t> SPIRVType::getSizeInBytes() {
   if (auto scalarType = dyn_cast<ScalarType>())
     return scalarType.getSizeInBytes();
   if (auto compositeType = dyn_cast<CompositeType>())
     return compositeType.getSizeInBytes();
   return std::nullopt;
 }
 
 //===----------------------------------------------------------------------===//
SampledImageType::verify(function_ref<InFlightDiagnostic()> emitError,
   if (!imageType.isa<ImageType>())
     return emitError() << "expected image type";
 
   return success();
 }
 
 void SampledImageType::getExtensions(
     SPIRVType::ExtensionArrayRefVector &extensions,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getImageType().cast<ImageType>().getExtensions(extensions, storage);
 }
 
 void SampledImageType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   getImageType().cast<ImageType>().getCapabilities(capabilities, storage);
 }
 
 //===----------------------------------------------------------------------===//
 // StructType
 //===----------------------------------------------------------------------===//
 
 /// Type storage for SPIR-V structure types:

 LogicalResult
 StructType::trySetBody(ArrayRef<Type> memberTypes,
                        ArrayRef<OffsetInfo> offsetInfo,
                        ArrayRef<MemberDecorationInfo> memberDecorations) {
   return Base::mutate(memberTypes, offsetInfo, memberDecorations);
 }
 
 void StructType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                               Optional<StorageClass> storage) {
+                               std::optional<StorageClass> storage) {
   for (Type elementType : getElementTypes())
     elementType.cast<SPIRVType>().getExtensions(extensions, storage);
 }
 
 void StructType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   for (Type elementType : getElementTypes())
     elementType.cast<SPIRVType>().getCapabilities(capabilities, storage);
 }
 
 llvm::hash_code spirv::hash_value(
     const StructType::MemberDecorationInfo &memberDecorationInfo) {
   return llvm::hash_combine(memberDecorationInfo.memberIndex,
                             memberDecorationInfo.decoration);
unsigned MatrixType::getNumRows() const {
   return getImpl()->columnType.cast<VectorType>().getShape()[0];
 }
 
 unsigned MatrixType::getNumElements() const {
   return (getImpl()->columnCount) * getNumRows();
 }
 
 void MatrixType::getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                               Optional<StorageClass> storage) {
+                               std::optional<StorageClass> storage) {
   getColumnType().cast<SPIRVType>().getExtensions(extensions, storage);
 }
 
 void MatrixType::getCapabilities(
     SPIRVType::CapabilityArrayRefVector &capabilities,
-    Optional<StorageClass> storage) {
+    std::optional<StorageClass> storage) {
   {
     static const Capability caps[] = {Capability::Matrix};
     ArrayRef<Capability> ref(caps, std::size(caps));
     capabilities.push_back(ref);
   }
   // Add any capabilities associated with the underlying vectors (i.e., columns)
   getColumnType().cast<SPIRVType>().getCapabilities(capabilities, storage);
 }

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

 }
 
 bool SPIRVTypeConverter::allows(spirv::Capability capability) {
   return targetEnv.allows(capability);
 }
 
 // TODO: This is a utility function that should probably be exposed by the
 // SPIR-V dialect. Keeping it local till the use case arises.
-static Optional<int64_t> getTypeNumBytes(const SPIRVConversionOptions &options,
-                                         Type type) {
+static std::optional<int64_t>
+getTypeNumBytes(const SPIRVConversionOptions &options, Type type) {
   if (type.isa<spirv::ScalarType>()) {
     auto bitWidth = type.getIntOrFloatBitWidth();
     // According to the SPIR-V spec:
     // "There is no physical size or bit pattern defined for values with boolean
     // type. If they are stored (in conjunction with OpVariable), they can only
     // be used with logical addressing operations, not physical, and only with
     // non-externally visible shader Storage Classes: Workgroup, CrossWorkgroup,
     // Private, Function, Input, and Output."
if (auto tensorType = type.dyn_cast<TensorType>()) {
     return size;
   }
 
   // TODO: Add size computation for other types.
   return std::nullopt;
 }
 
 /// Converts a scalar `type` to a suitable type under the given `targetEnv`.
-static Type convertScalarType(const spirv::TargetEnv &targetEnv,
-                              const SPIRVConversionOptions &options,
-                              spirv::ScalarType type,
-                              Optional<spirv::StorageClass> storageClass = {}) {
+static Type
+convertScalarType(const spirv::TargetEnv &targetEnv,
+                  const SPIRVConversionOptions &options, spirv::ScalarType type,
+                  std::optional<spirv::StorageClass> storageClass = {}) {
   // Get extension and capability requirements for the given type.
   SmallVector<ArrayRef<spirv::Extension>, 1> extensions;
   SmallVector<ArrayRef<spirv::Capability>, 2> capabilities;
   type.getExtensions(extensions, storageClass);
   type.getCapabilities(capabilities, storageClass);
 
   // If all requirements are met, then we can accept this type as-is.
   if (succeeded(checkCapabilityRequirements(type, targetEnv, capabilities)) &&
convertScalarType(const spirv::TargetEnv &targetEnv,
 
   auto intType = type.cast<IntegerType>();
   LLVM_DEBUG(llvm::dbgs() << type << " converted to 32-bit for SPIR-V\n");
   return IntegerType::get(targetEnv.getContext(), /*width=*/32,
                           intType.getSignedness());
 }
 
 /// Converts a vector `type` to a suitable type under the given `targetEnv`.
-static Type convertVectorType(const spirv::TargetEnv &targetEnv,
-                              const SPIRVConversionOptions &options,
-                              VectorType type,
-                              Optional<spirv::StorageClass> storageClass = {}) {
+static Type
+convertVectorType(const spirv::TargetEnv &targetEnv,
+                  const SPIRVConversionOptions &options, VectorType type,
+                  std::optional<spirv::StorageClass> storageClass = {}) {
   auto scalarType = type.getElementType().cast<spirv::ScalarType>();
   if (type.getRank() <= 1 && type.getNumElements() == 1)
     return convertScalarType(targetEnv, options, scalarType, storageClass);
 
   if (!spirv::CompositeType::isValid(type)) {
     // TODO: Vector types with more than four elements can be translated into
     // array types.
     LLVM_DEBUG(llvm::dbgs() << type << " illegal: > 4-element unimplemented\n");
static Type convertTensorType(const spirv::TargetEnv &targetEnv,
 
   auto scalarType = type.getElementType().dyn_cast<spirv::ScalarType>();
   if (!scalarType) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: cannot convert non-scalar element type\n");
     return nullptr;
   }
 
-  Optional<int64_t> scalarSize = getTypeNumBytes(options, scalarType);
-  Optional<int64_t> tensorSize = getTypeNumBytes(options, type);
+  std::optional<int64_t> scalarSize = getTypeNumBytes(options, scalarType);
+  std::optional<int64_t> tensorSize = getTypeNumBytes(options, type);
   if (!scalarSize || !tensorSize) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: cannot deduce element count\n");
     return nullptr;
   }
 
   auto arrayElemCount = *tensorSize / *scalarSize;
   auto arrayElemType = convertScalarType(targetEnv, options, scalarType);
   if (!arrayElemType)
     return nullptr;
-  Optional<int64_t> arrayElemSize = getTypeNumBytes(options, arrayElemType);
+  std::optional<int64_t> arrayElemSize =
+      getTypeNumBytes(options, arrayElemType);
   if (!arrayElemSize) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: cannot deduce converted element size\n");
     return nullptr;
   }
 
   return spirv::ArrayType::get(arrayElemType, arrayElemCount);
 }
static Type convertBoolMemrefType(const spirv::TargetEnv &targetEnv,
   auto elementType = IntegerType::get(type.getContext(), numBoolBits)
                          .dyn_cast<spirv::ScalarType>();
   if (!elementType)
     return nullptr;
   Type arrayElemType =
       convertScalarType(targetEnv, options, elementType, storageClass);
   if (!arrayElemType)
     return nullptr;
-  Optional<int64_t> arrayElemSize = getTypeNumBytes(options, arrayElemType);
+  std::optional<int64_t> arrayElemSize =
+      getTypeNumBytes(options, arrayElemType);
   if (!arrayElemSize) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: cannot deduce converted element size\n");
     return nullptr;
   }
 
 
   if (!type.hasStaticShape()) {
LLVM_DEBUG(
         llvm::dbgs()
         << type
         << " unhandled: can only convert scalar or vector element type\n");
     return nullptr;
   }
   if (!arrayElemType)
     return nullptr;
 
-  Optional<int64_t> arrayElemSize = getTypeNumBytes(options, arrayElemType);
+  std::optional<int64_t> arrayElemSize =
+      getTypeNumBytes(options, arrayElemType);
   if (!arrayElemSize) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: cannot deduce converted element size\n");
     return nullptr;
   }
 
 
   if (!type.hasStaticShape()) {
     // For OpenCL Kernel, dynamic shaped memrefs convert into a pointer pointing
     // to the element.
     if (targetEnv.allows(spirv::Capability::Kernel))
       return spirv::PointerType::get(arrayElemType, storageClass);
     int64_t stride = needsExplicitLayout(storageClass) ? *arrayElemSize : 0;
     auto arrayType = spirv::RuntimeArrayType::get(arrayElemType, stride);
     // For Vulkan we need extra wrapping struct and array to satisfy interface
     // needs.
     return wrapInStructAndGetPointer(arrayType, storageClass);
   }
 
-  Optional<int64_t> memrefSize = getTypeNumBytes(options, type);
+  std::optional<int64_t> memrefSize = getTypeNumBytes(options, type);
   if (!memrefSize) {
     LLVM_DEBUG(llvm::dbgs()
                << type << " illegal: cannot deduce element count\n");
     return nullptr;
   }
 
   auto arrayElemCount = llvm::divideCeil(*memrefSize, *arrayElemSize);
   int64_t stride = needsExplicitLayout(storageClass) ? *arrayElemSize : 0;
SPIRVTypeConverter::SPIRVTypeConverter(spirv::TargetEnvAttr targetAttr,
   // TODO: this assumes that the SPIR-V types are valid to use in
   // the given target environment, which should be the case if the whole
   // pipeline is driven by the same target environment. Still, we probably still
   // want to validate and convert to be safe.
   addConversion([](spirv::SPIRVType type) { return type; });
 
   addConversion([this](IndexType /*indexType*/) { return getIndexType(); });
 
-  addConversion([this](IntegerType intType) -> Optional<Type> {
+  addConversion([this](IntegerType intType) -> std::optional<Type> {
     if (auto scalarType = intType.dyn_cast<spirv::ScalarType>())
       return convertScalarType(this->targetEnv, this->options, scalarType);
     return Type();
   });
 
-  addConversion([this](FloatType floatType) -> Optional<Type> {
+  addConversion([this](FloatType floatType) -> std::optional<Type> {
     if (auto scalarType = floatType.dyn_cast<spirv::ScalarType>())
       return convertScalarType(this->targetEnv, this->options, scalarType);
     return Type();
   });
 
   addConversion([this](VectorType vectorType) {
     return convertVectorType(this->targetEnv, this->options, vectorType);
   });

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

if (!rtArrayType)
     return {};
 
   return rtArrayType.getElementType();
 }
 
 /// Given a list of resource element `types`, returns the index of the canonical
 /// resource that all resources should be unified into. Returns std::nullopt if
 /// unable to unify.
-static Optional<int> deduceCanonicalResource(ArrayRef<spirv::SPIRVType> types) {
+static std::optional<int>
+deduceCanonicalResource(ArrayRef<spirv::SPIRVType> types) {
   // scalarNumBits: contains all resources' scalar types' bit counts.
   // vectorNumBits: only contains resources whose element types are vectors.
   // vectorIndices: each vector's original index in `types`.
   SmallVector<int> scalarNumBits, vectorNumBits, vectorIndices;
   scalarNumBits.reserve(types.size());
   vectorNumBits.reserve(types.size());
   vectorIndices.reserve(types.size());
 
   for (const auto &indexedTypes : llvm::enumerate(types)) {
     spirv::SPIRVType type = indexedTypes.value();
     assert(type.isScalarOrVector());
     if (auto vectorType = type.dyn_cast<VectorType>()) {
       if (vectorType.getNumElements() % 2 != 0)
         return std::nullopt; // Odd-sized vector has special layout
                              // requirements.
 
-      Optional<int64_t> numBytes = type.getSizeInBytes();
+      std::optional<int64_t> numBytes = type.getSizeInBytes();
       if (!numBytes)
         return std::nullopt;
 
       scalarNumBits.push_back(
           vectorType.getElementType().getIntOrFloatBitWidth());
       vectorNumBits.push_back(*numBytes * 8);
       vectorIndices.push_back(indexedTypes.index());
     } else {
for (spirv::GlobalVariableOp resource : resources) {
 
     auto type = elementType.cast<spirv::SPIRVType>();
     if (!type.isScalarOrVector())
       return; // Unexpected resource element type.
 
     elementTypes.push_back(type);
   }
 
-  Optional<int> index = deduceCanonicalResource(elementTypes);
+  std::optional<int> index = deduceCanonicalResource(elementTypes);
   if (!index)
     return;
 
   // Update internal data structures for later use.
   resourceMap[descriptor].assign(resources.begin(), resources.end());
   canonicalResourceMap[descriptor] = resources[*index];
   for (const auto &resource : llvm::enumerate(resources)) {
     descriptorMap[resource.value()] = descriptor;

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp

static void createPushback(OpBuilder &builder, Location loc,
   Value newField = builder.create<PushBackOp>(
       loc, field.getType(), desc.getMemSizesMemRef(), field,
       toType(builder, loc, value, etp), APInt(64, getFieldMemSizesIndex(fidx)),
       repeat);
   desc.setField(fidx, newField);
 }
 
 /// Maps a sparse tensor type to the appropriate compounded buffers.
-static Optional<LogicalResult>
+static std::optional<LogicalResult>
 convertSparseTensorType(Type type, SmallVectorImpl<Type> &fields) {
   auto enc = getSparseTensorEncoding(type);
   if (!enc)
     return std::nullopt;
 
   RankedTensorType rType = type.cast<RankedTensorType>();
   foreachFieldAndTypeInSparseTensor(
       rType,

 
 mlir::SparseTensorTypeToBufferConverter::SparseTensorTypeToBufferConverter() {
   addConversion([](Type type) { return type; });
   addConversion(convertSparseTensorType);
 
   // Required by scf.for 1:N type conversion.
   addSourceMaterialization([](OpBuilder &builder, RankedTensorType tp,
                               ValueRange inputs,
-                              Location loc) -> Optional<Value> {
+                              Location loc) -> std::optional<Value> {
     if (!getSparseTensorEncoding(tp))
       // Not a sparse tensor.
       return std::nullopt;
     // Sparse compiler knows how to cancel out these casts.
     return genTuple(builder, loc, tp, inputs);
   });
 }
 

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp

 
 namespace {
 
 //===----------------------------------------------------------------------===//
 // Helper methods.
 //===----------------------------------------------------------------------===//
 
 /// Maps each sparse tensor type to an opaque pointer.
-static Optional<Type> convertSparseTensorTypes(Type type) {
+static std::optional<Type> convertSparseTensorTypes(Type type) {
   if (getSparseTensorEncoding(type) != nullptr)
     return LLVM::LLVMPointerType::get(IntegerType::get(type.getContext(), 8));
   return std::nullopt;
 }
 
 /// Replaces the `op` with  a `CallOp` to the function reference returned
 /// by `getFunc()`.
 static func::CallOp replaceOpWithFuncCall(RewriterBase &rewriter, Operation *op,

mlir/lib/Transforms/Utils/DialectConversion.cpp

while (!worklist.empty()) {
     Block *block = worklist.pop_back_val();
 
     // Compute the conversion set of each of the nested operations.
     for (Operation &op : *block) {
       toConvert.emplace_back(&op);
 
       // Don't check this operation's children for conversion if the operation
       // is recursively legal.
-      auto legalityInfo = target ? target->isLegal(&op)
-                                 : Optional<ConversionTarget::LegalOpDetails>();
+      auto legalityInfo =
+          target ? target->isLegal(&op)
+                 : std::optional<ConversionTarget::LegalOpDetails>();
       if (legalityInfo && legalityInfo->isRecursivelyLegal)
         continue;
       for (auto &region : op.getRegions()) {
         if (failed(computeConversionSet(region.getBlocks(), region.getLoc(),
                                         toConvert, target)))
           return failure();
       }
     }
struct ConvertedBlockInfo {
     ConvertedBlockInfo(Block *origBlock, TypeConverter *converter)
         : origBlock(origBlock), converter(converter) {}
 
     /// The original block that was requested to have its signature converted.
     Block *origBlock;
 
     /// The conversion information for each of the arguments. The information is
     /// std::nullopt if the argument was dropped during conversion.
-    SmallVector<Optional<ConvertedArgInfo>, 1> argInfo;
+    SmallVector<std::optional<ConvertedArgInfo>, 1> argInfo;
 
     /// The type converter used to convert the arguments.
     TypeConverter *converter;
   };
 
   /// Return if the signature of the given block has already been converted.
   bool hasBeenConverted(Block *block) const {
     return conversionInfo.count(block) || convertedBlocks.count(block);

 
 void ArgConverter::applyRewrites(ConversionValueMapping &mapping) {
   for (auto &info : conversionInfo) {
     ConvertedBlockInfo &blockInfo = info.second;
     Block *origBlock = blockInfo.origBlock;
 
     // Process the remapping for each of the original arguments.
     for (unsigned i = 0, e = origBlock->getNumArguments(); i != e; ++i) {
-      Optional<ConvertedArgInfo> &argInfo = blockInfo.argInfo[i];
+      std::optional<ConvertedArgInfo> &argInfo = blockInfo.argInfo[i];
       BlockArgument origArg = origBlock->getArgument(i);
 
       // Handle the case of a 1->0 value mapping.
       if (!argInfo) {
         if (Value newArg = mapping.lookupOrNull(origArg, origArg.getType()))
           origArg.replaceAllUsesWith(newArg);
         continue;
       }
struct ConversionPatternRewriterImpl {
   /// Undo the block actions (motions, splits) one by one in reverse order until
   /// "numActionsToKeep" actions remains.
   void undoBlockActions(unsigned numActionsToKeep = 0);
 
   /// Remap the given values to those with potentially different types. Returns
   /// success if the values could be remapped, failure otherwise. `valueDiagTag`
   /// is the tag used when describing a value within a diagnostic, e.g.
   /// "operand".
-  LogicalResult remapValues(StringRef valueDiagTag, Optional<Location> inputLoc,
+  LogicalResult remapValues(StringRef valueDiagTag,
+                            std::optional<Location> inputLoc,
                             PatternRewriter &rewriter, ValueRange values,
                             SmallVectorImpl<Value> &remapped);
 
   /// Returns true if the given operation is ignored, and does not need to be
   /// converted.
   bool isOpIgnored(Operation *op) const;
 
   /// Recursively marks the nested operations under 'op' as ignored. This
case BlockActionKind::TypeConversion: {
       break;
     }
     }
   }
   blockActions.resize(numActionsToKeep);
 }
 
 LogicalResult ConversionPatternRewriterImpl::remapValues(
-    StringRef valueDiagTag, Optional<Location> inputLoc,
+    StringRef valueDiagTag, std::optional<Location> inputLoc,
     PatternRewriter &rewriter, ValueRange values,
     SmallVectorImpl<Value> &remapped) {
   remapped.reserve(llvm::size(values));
 
   SmallVector<Type, 1> legalTypes;
   for (const auto &it : llvm::enumerate(values)) {
     Value operand = it.value();
     Type origType = operand.getType();
if (!anyOpLegalizerPatterns.empty()) {
     return;
   }
 
   while (!patternWorklist.empty()) {
     auto *pattern = patternWorklist.pop_back_val();
 
     // Check to see if any of the generated operations are invalid.
     if (llvm::any_of(pattern->getGeneratedOps(), [&](OperationName op) {
-          Optional<LegalizationAction> action = target.getOpAction(op);
+          std::optional<LegalizationAction> action = target.getOpAction(op);
           return !legalizerPatterns.count(op) &&
                  (!action || action == LegalizationAction::Illegal);
         }))
       continue;
 
     // Otherwise, if all of the generated operation are valid, this op is now
     // legal so add all of the child patterns to the worklist.
     legalizerPatterns[*pattern->getRootKind()].push_back(pattern);
private:
   LogicalResult
   legalizeConvertedArgumentTypes(ConversionPatternRewriter &rewriter,
                                  ConversionPatternRewriterImpl &rewriterImpl);
 
   /// Legalize any unresolved type materializations.
   LogicalResult legalizeUnresolvedMaterializations(
       ConversionPatternRewriter &rewriter,
       ConversionPatternRewriterImpl &rewriterImpl,
-      Optional<DenseMap<Value, SmallVector<Value>>> &inverseMapping);
+      std::optional<DenseMap<Value, SmallVector<Value>>> &inverseMapping);
 
   /// Legalize an operation result that was marked as "erased".
   LogicalResult
   legalizeErasedResult(Operation *op, OpResult result,
                        ConversionPatternRewriterImpl &rewriterImpl);
 
   /// Legalize an operation result that was replaced with a value of a different
   /// type.
if (trackedOps)
       for (auto &repl : rewriterImpl.replacements)
         trackedOps->erase(repl.first);
   }
   return success();
 }
 
 LogicalResult
 OperationConverter::finalize(ConversionPatternRewriter &rewriter) {
-  Optional<DenseMap<Value, SmallVector<Value>>> inverseMapping;
+  std::optional<DenseMap<Value, SmallVector<Value>>> inverseMapping;
   ConversionPatternRewriterImpl &rewriterImpl = rewriter.getImpl();
   if (failed(legalizeUnresolvedMaterializations(rewriter, rewriterImpl,
                                                 inverseMapping)) ||
       failed(legalizeConvertedArgumentTypes(rewriter, rewriterImpl)))
     return failure();
 
   if (rewriterImpl.operationsWithChangedResults.empty())
     return success();
diag.attachNote(liveUser->getLoc())
         << "see existing live user here: " << *liveUser;
   }
   return failure();
 }
 
 LogicalResult OperationConverter::legalizeUnresolvedMaterializations(
     ConversionPatternRewriter &rewriter,
     ConversionPatternRewriterImpl &rewriterImpl,
-    Optional<DenseMap<Value, SmallVector<Value>>> &inverseMapping) {
+    std::optional<DenseMap<Value, SmallVector<Value>>> &inverseMapping) {
   if (rewriterImpl.unresolvedMaterializations.empty())
     return success();
   inverseMapping = rewriterImpl.mapping.getInverse();
 
   // As an initial step, compute all of the inserted materializations that we
   // expect to persist beyond the conversion process.
   DenseMap<Operation *, UnresolvedMaterialization *> materializationOps;
   SetVector<UnresolvedMaterialization *> necessaryMaterializations;
LogicalResult TypeConverter::convertType(Type t,
 
   // Walk the added converters in reverse order to apply the most recently
   // registered first.
   size_t currentCount = results.size();
   conversionCallStack.push_back(t);
   auto popConversionCallStack =
       llvm::make_scope_exit([this]() { conversionCallStack.pop_back(); });
   for (ConversionCallbackFn &converter : llvm::reverse(conversions)) {
-    if (Optional<LogicalResult> result =
+    if (std::optional<LogicalResult> result =
             converter(t, results, conversionCallStack)) {
       if (!succeeded(*result)) {
         cachedDirectConversions.try_emplace(t, nullptr);
         return failure();
       }
       auto newTypes = ArrayRef<Type>(results).drop_front(currentCount);
       if (newTypes.size() == 1)
         cachedDirectConversions.try_emplace(t, newTypes.front());
if (failed(convertSignatureArg(origInputOffset + i, types[i], result)))
       return failure();
   return success();
 }
 
 Value TypeConverter::materializeConversion(
     MutableArrayRef<MaterializationCallbackFn> materializations,
     OpBuilder &builder, Location loc, Type resultType, ValueRange inputs) {
   for (MaterializationCallbackFn &fn : llvm::reverse(materializations))
-    if (Optional<Value> result = fn(builder, resultType, inputs, loc))
+    if (std::optional<Value> result = fn(builder, resultType, inputs, loc))
       return *result;
   return nullptr;
 }
 
 auto TypeConverter::convertBlockSignature(Block *block)
-    -> Optional<SignatureConversion> {
+    -> std::optional<SignatureConversion> {
   SignatureConversion conversion(block->getNumArguments());
   if (failed(convertSignatureArgs(block->getArgumentTypes(), conversion)))
     return std::nullopt;
   return conversion;
 }
 
 //===----------------------------------------------------------------------===//
 // FunctionOpInterfaceSignatureConversion

 
 void ConversionTarget::setDialectAction(ArrayRef<StringRef> dialectNames,
                                         LegalizationAction action) {
   for (StringRef dialect : dialectNames)
     legalDialects[dialect] = action;
 }
 
 auto ConversionTarget::getOpAction(OperationName op) const
-    -> Optional<LegalizationAction> {
-  Optional<LegalizationInfo> info = getOpInfo(op);
-  return info ? info->action : Optional<LegalizationAction>();
+    -> std::optional<LegalizationAction> {
+  std::optional<LegalizationInfo> info = getOpInfo(op);
+  return info ? info->action : std::optional<LegalizationAction>();
 }
 
 auto ConversionTarget::isLegal(Operation *op) const
-    -> Optional<LegalOpDetails> {
-  Optional<LegalizationInfo> info = getOpInfo(op->getName());
+    -> std::optional<LegalOpDetails> {
+  std::optional<LegalizationInfo> info = getOpInfo(op->getName());
   if (!info)
     return std::nullopt;
 
   // Returns true if this operation instance is known to be legal.
   auto isOpLegal = [&] {
     // Handle dynamic legality either with the provided legality function.
     if (info->action == LegalizationAction::Dynamic) {
-      Optional<bool> result = info->legalityFn(op);
+      std::optional<bool> result = info->legalityFn(op);
       if (result)
         return *result;
     }
 
     // Otherwise, the operation is only legal if it was marked 'Legal'.
     return info->action == LegalizationAction::Legal;
   };
   if (!isOpLegal())
if (info->isRecursivelyLegal) {
     } else {
       legalityDetails.isRecursivelyLegal = true;
     }
   }
   return legalityDetails;
 }
 
 bool ConversionTarget::isIllegal(Operation *op) const {
-  Optional<LegalizationInfo> info = getOpInfo(op->getName());
+  std::optional<LegalizationInfo> info = getOpInfo(op->getName());
   if (!info)
     return false;
 
   if (info->action == LegalizationAction::Dynamic) {
-    Optional<bool> result = info->legalityFn(op);
+    std::optional<bool> result = info->legalityFn(op);
     if (!result)
       return false;
 
     return !(*result);
   }
 
   return info->action == LegalizationAction::Illegal;
 }
 
 static ConversionTarget::DynamicLegalityCallbackFn composeLegalityCallbacks(
     ConversionTarget::DynamicLegalityCallbackFn oldCallback,
     ConversionTarget::DynamicLegalityCallbackFn newCallback) {
   if (!oldCallback)
     return newCallback;
 
   auto chain = [oldCl = std::move(oldCallback), newCl = std::move(newCallback)](
-                   Operation *op) -> Optional<bool> {
-    if (Optional<bool> result = newCl(op))
+                   Operation *op) -> std::optional<bool> {
+    if (std::optional<bool> result = newCl(op))
       return *result;
 
     return oldCl(op);
   };
   return chain;
 }
 
 void ConversionTarget::setLegalityCallback(

 
 void ConversionTarget::setLegalityCallback(
     const DynamicLegalityCallbackFn &callback) {
   assert(callback && "expected valid legality callback");
   unknownLegalityFn = composeLegalityCallbacks(unknownLegalityFn, callback);
 }
 
 auto ConversionTarget::getOpInfo(OperationName op) const
-    -> Optional<LegalizationInfo> {
+    -> std::optional<LegalizationInfo> {
   // Check for info for this specific operation.
   auto it = legalOperations.find(op);
   if (it != legalOperations.end())
     return it->second;
   // Check for info for the parent dialect.
   auto dialectIt = legalDialects.find(op.getDialectNamespace());
   if (dialectIt != legalDialects.end()) {
     DynamicLegalityCallbackFn callback;

mlir/test/lib/Dialect/Arith/TestEmulateWideInt.cpp

void runOnOperation() override {
     MLIRContext *ctx = op.getContext();
     arith::WideIntEmulationConverter typeConverter(widestIntSupported);
 
     // Use `llvm.bitcast` as the bridge so that we can use preserve the
     // function argument and return types of the processed function.
     // TODO: Consider extending `arith.bitcast` to support scalar-to-1D-vector
     // casts (and vice versa) and using it insted of `llvm.bitcast`.
     auto addBitcast = [](OpBuilder &builder, Type type, ValueRange inputs,
-                         Location loc) -> Optional<Value> {
+                         Location loc) -> std::optional<Value> {
       auto cast = builder.create<LLVM::BitcastOp>(loc, type, inputs);
       return cast->getResult(0);
     };
     typeConverter.addSourceMaterialization(addBitcast);
     typeConverter.addTargetMaterialization(addBitcast);
 
     ConversionTarget target(*ctx);
     target

mlir/test/lib/Dialect/Func/TestDecomposeCallGraphTypes.cpp

decomposer.addDecomposeValueConversion([](OpBuilder &builder, Location loc,
             loc, resultType.getType(i), value, builder.getI32IntegerAttr(i));
         values.push_back(res);
       }
       return success();
     });
 
     typeConverter.addArgumentMaterialization(
         [](OpBuilder &builder, TupleType resultType, ValueRange inputs,
-           Location loc) -> Optional<Value> {
+           Location loc) -> std::optional<Value> {
           if (inputs.size() == 1)
             return std::nullopt;
           TupleType tuple = builder.getTupleType(inputs.getTypes());
           Value value = builder.create<test::MakeTupleOp>(loc, tuple, inputs);
           return value;
         });
 
     populateDecomposeCallGraphTypesPatterns(context, typeConverter, decomposer,

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

static LogicalResult convertType(Type t, SmallVectorImpl<Type> &results) {
 
     // Otherwise, convert the type directly.
     results.push_back(t);
     return success();
   }
 
   /// Hook for materializing a conversion. This is necessary because we generate
   /// 1->N type mappings.
-  static Optional<Value> materializeCast(OpBuilder &builder, Type resultType,
+  static std::optional<Value> materializeCast(OpBuilder &builder,
+                                              Type resultType,
                                               ValueRange inputs, Location loc) {
     return builder.create<TestCastOp>(loc, resultType, inputs).getResult();
   }
 };
 
 struct TestLegalizePatternDriver
     : public PassWrapper<TestLegalizePatternDriver, OperationPass<ModuleOp>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestLegalizePatternDriver)
 
void runOnOperation() override {
     converter.addConversion([](IntegerType type, SmallVectorImpl<Type> &) {
       // Drop all integer types.
       return success();
     });
     converter.addConversion(
         // Convert a recursive self-referring type into a non-self-referring
         // type named "outer_converted_type" that contains a SimpleAType.
         [&](test::TestRecursiveType type, SmallVectorImpl<Type> &results,
-            ArrayRef<Type> callStack) -> Optional<LogicalResult> {
+            ArrayRef<Type> callStack) -> std::optional<LogicalResult> {
           // If the type is already converted, return it to indicate that it is
           // legal.
           if (type.getName() == "outer_converted_type") {
             results.push_back(type);
             return success();
           }
 
           // If the type is on the call stack more than once (it is there at

mlir/test/lib/Transforms/TestDialectConversion.cpp

if (t.isSignlessInteger(64)) {
       return success();
     }
 
     // Otherwise, convert the type directly.
     results.push_back(t);
     return success();
   }
   /// Hook for materializing a conversion.
-  static Optional<Value> materializeCast(OpBuilder &builder, Type resultType,
+  static std::optional<Value> materializeCast(OpBuilder &builder,
+                                              Type resultType,
                                               ValueRange inputs, Location loc) {
     return builder.create<UnrealizedConversionCastOp>(loc, resultType, inputs)
         .getResult(0);
   }
 };
 
 struct TestDialectConversionPDLLPass
     : public PassWrapper<TestDialectConversionPDLLPass, OperationPass<>> {
   MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(TestDialectConversionPDLLPass)

mlir/unittests/Transforms/DialectConversion.cpp

TEST(DialectConversionTest, DynamicallyLegalOpCallbackOrder) {
   int index = 0;
   int callbackCalled1 = 0;
   target.addDynamicallyLegalOp<DummyOp>([&](Operation *) {
     callbackCalled1 = ++index;
     return true;
   });
 
   int callbackCalled2 = 0;
-  target.addDynamicallyLegalOp<DummyOp>([&](Operation *) -> Optional<bool> {
+  target.addDynamicallyLegalOp<DummyOp>(
+      [&](Operation *) -> std::optional<bool> {
         callbackCalled2 = ++index;
         return std::nullopt;
       });
 
   auto *op = createOp(&context);
   EXPECT_TRUE(target.isLegal(op));
   EXPECT_EQ(2, callbackCalled1);
   EXPECT_EQ(1, callbackCalled2);
   EXPECT_FALSE(target.isIllegal(op));
   EXPECT_EQ(4, callbackCalled1);
   EXPECT_EQ(3, callbackCalled2);
   op->destroy();
 }
 
 TEST(DialectConversionTest, DynamicallyLegalOpCallbackSkip) {
   MLIRContext context;
   ConversionTarget target(context);
 
   int index = 0;
   int callbackCalled = 0;
-  target.addDynamicallyLegalOp<DummyOp>([&](Operation *) -> Optional<bool> {
+  target.addDynamicallyLegalOp<DummyOp>(
+      [&](Operation *) -> std::optional<bool> {
         callbackCalled = ++index;
         return std::nullopt;
       });
 
   auto *op = createOp(&context);
   EXPECT_FALSE(target.isLegal(op));
   EXPECT_EQ(1, callbackCalled);
   EXPECT_FALSE(target.isIllegal(op));
   EXPECT_EQ(2, callbackCalled);
   op->destroy();
 }
 
 TEST(DialectConversionTest, DynamicallyLegalUnknownOpCallbackOrder) {
   MLIRContext context;
   ConversionTarget target(context);
 
   int index = 0;
   int callbackCalled1 = 0;
   target.markUnknownOpDynamicallyLegal([&](Operation *) {
     callbackCalled1 = ++index;
     return true;
   });
 
   int callbackCalled2 = 0;
-  target.markUnknownOpDynamicallyLegal([&](Operation *) -> Optional<bool> {
+  target.markUnknownOpDynamicallyLegal([&](Operation *) -> std::optional<bool> {
     callbackCalled2 = ++index;
     return std::nullopt;
   });
 
   auto *op = createOp(&context);
   EXPECT_TRUE(target.isLegal(op));
   EXPECT_EQ(2, callbackCalled1);
   EXPECT_EQ(1, callbackCalled2);
   EXPECT_FALSE(target.isIllegal(op));
   EXPECT_EQ(4, callbackCalled1);
   EXPECT_EQ(3, callbackCalled2);
   op->destroy();
 }
 
 TEST(DialectConversionTest, DynamicallyLegalReturnNone) {
   MLIRContext context;
   ConversionTarget target(context);
 
   target.addDynamicallyLegalOp<DummyOp>(
-      [&](Operation *) -> Optional<bool> { return std::nullopt; });
+      [&](Operation *) -> std::optional<bool> { return std::nullopt; });
 
   auto *op = createOp(&context);
   EXPECT_FALSE(target.isLegal(op));
   EXPECT_FALSE(target.isIllegal(op));
 
   EXPECT_TRUE(succeeded(applyPartialConversion(op, target, {})));
   EXPECT_TRUE(failed(applyFullConversion(op, target, {})));
 
   op->destroy();
 }
 
 TEST(DialectConversionTest, DynamicallyLegalUnknownReturnNone) {
   MLIRContext context;
   ConversionTarget target(context);
 
   target.markUnknownOpDynamicallyLegal(
-      [&](Operation *) -> Optional<bool> { return std::nullopt; });
+      [&](Operation *) -> std::optional<bool> { return std::nullopt; });
 
   auto *op = createOp(&context);
   EXPECT_FALSE(target.isLegal(op));
   EXPECT_FALSE(target.isIllegal(op));
 
   EXPECT_TRUE(succeeded(applyPartialConversion(op, target, {})));
   EXPECT_TRUE(failed(applyFullConversion(op, target, {})));
 
   op->destroy();
 }
 } // namespace