diff --git a/clang/include/clang/APINotes/Types.h b/clang/include/clang/APINotes/Types.h
index 8dfc3bf4f1e58a..af5f05bc0d365a 100644
--- a/clang/include/clang/APINotes/Types.h
+++ b/clang/include/clang/APINotes/Types.h
@@ -10,9 +10,9 @@
 #define LLVM_CLANG_APINOTES_TYPES_H
 
 #include "clang/Basic/Specifiers.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include <climits>
+#include <optional>
 #include <vector>
 
 namespace llvm {
@@ -74,12 +74,12 @@ class CommonEntityInfo {
       : Unavailable(0), UnavailableInSwift(0), SwiftPrivateSpecified(0),
         SwiftPrivate(0) {}
 
-  llvm::Optional<bool> isSwiftPrivate() const {
-    return SwiftPrivateSpecified ? llvm::Optional<bool>(SwiftPrivate)
+  std::optional<bool> isSwiftPrivate() const {
+    return SwiftPrivateSpecified ? std::optional<bool>(SwiftPrivate)
                                  : std::nullopt;
   }
 
-  void setSwiftPrivate(llvm::Optional<bool> Private) {
+  void setSwiftPrivate(std::optional<bool> Private) {
     SwiftPrivateSpecified = Private.has_value();
     SwiftPrivate = Private.value_or(0);
   }
@@ -131,38 +131,38 @@ class CommonTypeInfo : public CommonEntityInfo {
   /// The Swift type to which a given type is bridged.
   ///
   /// Reflects the swift_bridge attribute.
-  llvm::Optional<std::string> SwiftBridge;
+  std::optional<std::string> SwiftBridge;
 
   /// The NS error domain for this type.
-  llvm::Optional<std::string> NSErrorDomain;
+  std::optional<std::string> NSErrorDomain;
 
 public:
   CommonTypeInfo() {}
 
-  const llvm::Optional<std::string> &getSwiftBridge() const {
+  const std::optional<std::string> &getSwiftBridge() const {
     return SwiftBridge;
   }
 
-  void setSwiftBridge(const llvm::Optional<std::string> &SwiftType) {
+  void setSwiftBridge(const std::optional<std::string> &SwiftType) {
     SwiftBridge = SwiftType;
   }
 
-  void setSwiftBridge(const llvm::Optional<llvm::StringRef> &SwiftType) {
+  void setSwiftBridge(const std::optional<llvm::StringRef> &SwiftType) {
     SwiftBridge = SwiftType
-                      ? llvm::Optional<std::string>(std::string(*SwiftType))
+                      ? std::optional<std::string>(std::string(*SwiftType))
                       : std::nullopt;
   }
 
-  const llvm::Optional<std::string> &getNSErrorDomain() const {
+  const std::optional<std::string> &getNSErrorDomain() const {
     return NSErrorDomain;
   }
 
-  void setNSErrorDomain(const llvm::Optional<std::string> &Domain) {
+  void setNSErrorDomain(const std::optional<std::string> &Domain) {
     NSErrorDomain = Domain;
   }
 
-  void setNSErrorDomain(const llvm::Optional<llvm::StringRef> &Domain) {
-    NSErrorDomain = Domain ? llvm::Optional<std::string>(std::string(*Domain))
+  void setNSErrorDomain(const std::optional<llvm::StringRef> &Domain) {
+    NSErrorDomain = Domain ? std::optional<std::string>(std::string(*Domain))
                            : std::nullopt;
   }
 
@@ -221,9 +221,9 @@ class ObjCContextInfo : public CommonTypeInfo {
   ///
   /// Returns the default nullability, if implied, or std::nullopt if there is
   /// none.
-  llvm::Optional<NullabilityKind> getDefaultNullability() const {
+  std::optional<NullabilityKind> getDefaultNullability() const {
     return HasDefaultNullability
-               ? llvm::Optional<NullabilityKind>(
+               ? std::optional<NullabilityKind>(
                      static_cast<NullabilityKind>(DefaultNullability))
                : std::nullopt;
   }
@@ -237,21 +237,21 @@ class ObjCContextInfo : public CommonTypeInfo {
   bool hasDesignatedInits() const { return HasDesignatedInits; }
   void setHasDesignatedInits(bool Value) { HasDesignatedInits = Value; }
 
-  llvm::Optional<bool> getSwiftImportAsNonGeneric() const {
+  std::optional<bool> getSwiftImportAsNonGeneric() const {
     return SwiftImportAsNonGenericSpecified
-               ? llvm::Optional<bool>(SwiftImportAsNonGeneric)
+               ? std::optional<bool>(SwiftImportAsNonGeneric)
                : std::nullopt;
   }
-  void setSwiftImportAsNonGeneric(llvm::Optional<bool> Value) {
+  void setSwiftImportAsNonGeneric(std::optional<bool> Value) {
     SwiftImportAsNonGenericSpecified = Value.has_value();
     SwiftImportAsNonGeneric = Value.value_or(false);
   }
 
-  llvm::Optional<bool> getSwiftObjCMembers() const {
-    return SwiftObjCMembersSpecified ? llvm::Optional<bool>(SwiftObjCMembers)
+  std::optional<bool> getSwiftObjCMembers() const {
+    return SwiftObjCMembersSpecified ? std::optional<bool>(SwiftObjCMembers)
                                      : std::nullopt;
   }
-  void setSwiftObjCMembers(llvm::Optional<bool> Value) {
+  void setSwiftObjCMembers(std::optional<bool> Value) {
     SwiftObjCMembersSpecified = Value.has_value();
     SwiftObjCMembers = Value.value_or(false);
   }
@@ -315,8 +315,8 @@ class VariableInfo : public CommonEntityInfo {
 public:
   VariableInfo() : NullabilityAudited(false), Nullable(0) {}
 
-  llvm::Optional<NullabilityKind> getNullability() const {
-    return NullabilityAudited ? llvm::Optional<NullabilityKind>(
+  std::optional<NullabilityKind> getNullability() const {
+    return NullabilityAudited ? std::optional<NullabilityKind>(
                                     static_cast<NullabilityKind>(Nullable))
                               : std::nullopt;
   }
@@ -364,12 +364,12 @@ class ObjCPropertyInfo : public VariableInfo {
   ObjCPropertyInfo()
       : SwiftImportAsAccessorsSpecified(false), SwiftImportAsAccessors(false) {}
 
-  llvm::Optional<bool> getSwiftImportAsAccessors() const {
+  std::optional<bool> getSwiftImportAsAccessors() const {
     return SwiftImportAsAccessorsSpecified
-               ? llvm::Optional<bool>(SwiftImportAsAccessors)
+               ? std::optional<bool>(SwiftImportAsAccessors)
                : std::nullopt;
   }
-  void setSwiftImportAsAccessors(llvm::Optional<bool> Value) {
+  void setSwiftImportAsAccessors(std::optional<bool> Value) {
     SwiftImportAsAccessorsSpecified = Value.has_value();
     SwiftImportAsAccessors = Value.value_or(false);
   }
@@ -428,23 +428,23 @@ class ParamInfo : public VariableInfo {
   ParamInfo()
       : NoEscapeSpecified(false), NoEscape(false), RawRetainCountConvention() {}
 
-  llvm::Optional<bool> isNoEscape() const {
+  std::optional<bool> isNoEscape() const {
     if (!NoEscapeSpecified)
       return std::nullopt;
     return NoEscape;
   }
-  void setNoEscape(llvm::Optional<bool> Value) {
+  void setNoEscape(std::optional<bool> Value) {
     NoEscapeSpecified = Value.has_value();
     NoEscape = Value.value_or(false);
   }
 
-  llvm::Optional<RetainCountConventionKind> getRetainCountConvention() const {
+  std::optional<RetainCountConventionKind> getRetainCountConvention() const {
     if (!RawRetainCountConvention)
       return std::nullopt;
     return static_cast<RetainCountConventionKind>(RawRetainCountConvention - 1);
   }
   void
-  setRetainCountConvention(llvm::Optional<RetainCountConventionKind> Value) {
+  setRetainCountConvention(std::optional<RetainCountConventionKind> Value) {
     RawRetainCountConvention = Value ? static_cast<unsigned>(*Value) + 1 : 0;
     assert(getRetainCountConvention() == Value && "bitfield too small");
   }
@@ -556,13 +556,13 @@ class FunctionInfo : public CommonEntityInfo {
 
   NullabilityKind getReturnTypeInfo() const { return getTypeInfo(0); }
 
-  llvm::Optional<RetainCountConventionKind> getRetainCountConvention() const {
+  std::optional<RetainCountConventionKind> getRetainCountConvention() const {
     if (!RawRetainCountConvention)
       return std::nullopt;
     return static_cast<RetainCountConventionKind>(RawRetainCountConvention - 1);
   }
   void
-  setRetainCountConvention(llvm::Optional<RetainCountConventionKind> Value) {
+  setRetainCountConvention(std::optional<RetainCountConventionKind> Value) {
     RawRetainCountConvention = Value ? static_cast<unsigned>(*Value) + 1 : 0;
     assert(getRetainCountConvention() == Value && "bitfield too small");
   }
@@ -659,16 +659,16 @@ class TagInfo : public CommonTypeInfo {
   unsigned IsFlagEnum : 1;
 
 public:
-  llvm::Optional<EnumExtensibilityKind> EnumExtensibility;
+  std::optional<EnumExtensibilityKind> EnumExtensibility;
 
   TagInfo() : HasFlagEnum(0), IsFlagEnum(0) {}
 
-  llvm::Optional<bool> isFlagEnum() const {
+  std::optional<bool> isFlagEnum() const {
     if (HasFlagEnum)
       return IsFlagEnum;
     return std::nullopt;
   }
-  void setFlagEnum(llvm::Optional<bool> Value) {
+  void setFlagEnum(std::optional<bool> Value) {
     HasFlagEnum = Value.has_value();
     IsFlagEnum = Value.value_or(false);
   }
@@ -703,7 +703,7 @@ inline bool operator!=(const TagInfo &LHS, const TagInfo &RHS) {
 /// Describes API notes data for a typedef.
 class TypedefInfo : public CommonTypeInfo {
 public:
-  llvm::Optional<SwiftNewTypeKind> SwiftWrapper;
+  std::optional<SwiftNewTypeKind> SwiftWrapper;
 
   TypedefInfo() {}
 
diff --git a/clang/include/clang/Basic/CLWarnings.h b/clang/include/clang/Basic/CLWarnings.h
index e3351f430c4379..9b8be93bad3a6e 100644
--- a/clang/include/clang/Basic/CLWarnings.h
+++ b/clang/include/clang/Basic/CLWarnings.h
@@ -9,7 +9,7 @@
 #ifndef LLVM_CLANG_BASIC_CLWARNINGS_H
 #define LLVM_CLANG_BASIC_CLWARNINGS_H
 
-#include "llvm/ADT/Optional.h"
+#include <optional>
 
 namespace clang {
 
@@ -19,7 +19,7 @@ enum class Group;
 
 /// For cl.exe warning IDs that cleany map to clang diagnostic groups,
 /// returns the corresponding group. Else, returns an empty Optional.
-llvm::Optional<diag::Group> diagGroupFromCLWarningID(unsigned);
+std::optional<diag::Group> diagGroupFromCLWarningID(unsigned);
 
 } // end namespace clang
 
diff --git a/clang/include/clang/Basic/CustomizableOptional.h b/clang/include/clang/Basic/CustomizableOptional.h
index 52e761d449330a..7323a818b0b51f 100644
--- a/clang/include/clang/Basic/CustomizableOptional.h
+++ b/clang/include/clang/Basic/CustomizableOptional.h
@@ -10,11 +10,11 @@
 #define CLANG_BASIC_CUSTOMIZABLEOPTIONAL_H
 
 #include "llvm/ADT/Hashing.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
 #include <new>
+#include <optional>
 #include <utility>
 
 namespace clang {
@@ -46,9 +46,9 @@ template <typename T> class CustomizableOptional {
       : Storage(std::in_place, std::forward<ArgTypes>(Args)...) {}
 
   // Allow conversion from Optional<T>.
-  constexpr CustomizableOptional(const llvm::Optional<T> &y)
+  constexpr CustomizableOptional(const std::optional<T> &y)
       : CustomizableOptional(y ? *y : CustomizableOptional()) {}
-  constexpr CustomizableOptional(llvm::Optional<T> &&y)
+  constexpr CustomizableOptional(std::optional<T> &&y)
       : CustomizableOptional(y ? std::move(*y) : CustomizableOptional()) {}
 
   CustomizableOptional &operator=(T &&y) {
@@ -99,11 +99,11 @@ template <typename T> class CustomizableOptional {
   }
 
   // Allow conversion to Optional<T>.
-  explicit operator llvm::Optional<T> &() const & {
-    return *this ? **this : llvm::Optional<T>();
+  explicit operator std::optional<T> &() const & {
+    return *this ? **this : std::optional<T>();
   }
-  explicit operator llvm::Optional<T> &&() const && {
-    return *this ? std::move(**this) : llvm::Optional<T>();
+  explicit operator std::optional<T> &&() const && {
+    return *this ? std::move(**this) : std::optional<T>();
   }
 };
 
diff --git a/clang/include/clang/Basic/TargetID.h b/clang/include/clang/Basic/TargetID.h
index d7c05b2d0c49ef..f1922942804eb0 100644
--- a/clang/include/clang/Basic/TargetID.h
+++ b/clang/include/clang/Basic/TargetID.h
@@ -12,6 +12,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Triple.h"
+#include <optional>
 #include <set>
 
 namespace clang {
@@ -37,9 +38,9 @@ llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T,
 /// If the target ID contains feature+, map it to true.
 /// If the target ID contains feature-, map it to false.
 /// If the target ID does not contain a feature (default), do not map it.
-llvm::Optional<llvm::StringRef>
-parseTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch,
-              llvm::StringMap<bool> *FeatureMap);
+std::optional<llvm::StringRef> parseTargetID(const llvm::Triple &T,
+                                             llvm::StringRef OffloadArch,
+                                             llvm::StringMap<bool> *FeatureMap);
 
 /// Returns canonical target ID, assuming \p Processor is canonical and all
 /// entries in \p Features are valid.
diff --git a/clang/include/clang/Support/RISCVVIntrinsicUtils.h b/clang/include/clang/Support/RISCVVIntrinsicUtils.h
index b5ce83a2654deb..0d5ebf058e6047 100644
--- a/clang/include/clang/Support/RISCVVIntrinsicUtils.h
+++ b/clang/include/clang/Support/RISCVVIntrinsicUtils.h
@@ -11,10 +11,10 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitmaskEnum.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
+#include <optional>
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -27,7 +27,7 @@ class raw_ostream;
 namespace clang {
 namespace RISCV {
 
-using VScaleVal = llvm::Optional<unsigned>;
+using VScaleVal = std::optional<unsigned>;
 
 // Modifier for vector type.
 enum class VectorTypeModifier : uint8_t {
@@ -197,7 +197,7 @@ struct PrototypeDescriptor {
   static const PrototypeDescriptor Mask;
   static const PrototypeDescriptor Vector;
   static const PrototypeDescriptor VL;
-  static llvm::Optional<PrototypeDescriptor>
+  static std::optional<PrototypeDescriptor>
   parsePrototypeDescriptor(llvm::StringRef PrototypeStr);
 };
 
@@ -238,7 +238,7 @@ struct LMULType {
   LMULType(int Log2LMUL);
   // Return the C/C++ string representation of LMUL
   std::string str() const;
-  llvm::Optional<unsigned> getScale(unsigned ElementBitwidth) const;
+  std::optional<unsigned> getScale(unsigned ElementBitwidth) const;
   void MulLog2LMUL(int Log2LMUL);
 };
 
@@ -354,11 +354,11 @@ class RVVTypeCache {
   /// and LMUL with type transformers). It also record result of type in legal
   /// or illegal set to avoid compute the same config again. The result maybe
   /// have illegal RVVType.
-  llvm::Optional<RVVTypes>
+  std::optional<RVVTypes>
   computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
                llvm::ArrayRef<PrototypeDescriptor> Prototype);
-  llvm::Optional<RVVTypePtr> computeType(BasicType BT, int Log2LMUL,
-                                         PrototypeDescriptor Proto);
+  std::optional<RVVTypePtr> computeType(BasicType BT, int Log2LMUL,
+                                        PrototypeDescriptor Proto);
 };
 
 enum PolicyScheme : uint8_t {
diff --git a/clang/lib/Basic/CLWarnings.cpp b/clang/lib/Basic/CLWarnings.cpp
index 0cf367d9f7f62d..5449d8f59fcf47 100644
--- a/clang/lib/Basic/CLWarnings.cpp
+++ b/clang/lib/Basic/CLWarnings.cpp
@@ -12,10 +12,11 @@
 
 #include "clang/Basic/CLWarnings.h"
 #include "clang/Basic/DiagnosticCategories.h"
+#include <optional>
 
 using namespace clang;
 
-llvm::Optional<diag::Group>
+std::optional<diag::Group>
 clang::diagGroupFromCLWarningID(unsigned CLWarningID) {
   switch (CLWarningID) {
   case 4005: return diag::Group::MacroRedefined;
diff --git a/clang/lib/Basic/TargetID.cpp b/clang/lib/Basic/TargetID.cpp
index 20e07cb7266a7b..7cc4d67e3a5227 100644
--- a/clang/lib/Basic/TargetID.cpp
+++ b/clang/lib/Basic/TargetID.cpp
@@ -101,7 +101,7 @@ parseTargetIDWithFormatCheckingOnly(llvm::StringRef TargetID,
   return Processor;
 }
 
-llvm::Optional<llvm::StringRef>
+std::optional<llvm::StringRef>
 parseTargetID(const llvm::Triple &T, llvm::StringRef TargetID,
               llvm::StringMap<bool> *FeatureMap) {
   auto OptionalProcessor =
diff --git a/clang/lib/DirectoryWatcher/DirectoryScanner.cpp b/clang/lib/DirectoryWatcher/DirectoryScanner.cpp
index fa060af9c7ae51..428f87eddc7b60 100644
--- a/clang/lib/DirectoryWatcher/DirectoryScanner.cpp
+++ b/clang/lib/DirectoryWatcher/DirectoryScanner.cpp
@@ -9,12 +9,13 @@
 #include "DirectoryScanner.h"
 
 #include "llvm/Support/Path.h"
+#include <optional>
 
 namespace clang {
 
 using namespace llvm;
 
-Optional<sys::fs::file_status> getFileStatus(StringRef Path) {
+std::optional<sys::fs::file_status> getFileStatus(StringRef Path) {
   sys::fs::file_status Status;
   std::error_code EC = status(Path, Status);
   if (EC)
diff --git a/clang/lib/DirectoryWatcher/DirectoryScanner.h b/clang/lib/DirectoryWatcher/DirectoryScanner.h
index 42fe8efcc8fecd..84cffa5704f76f 100644
--- a/clang/lib/DirectoryWatcher/DirectoryScanner.h
+++ b/clang/lib/DirectoryWatcher/DirectoryScanner.h
@@ -8,6 +8,7 @@
 
 #include "clang/DirectoryWatcher/DirectoryWatcher.h"
 #include "llvm/Support/FileSystem.h"
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -24,6 +25,6 @@ getAsFileEvents(const std::vector<std::string> &Scan);
 
 /// Gets status of file (or directory) at \p Path.
 /// \returns std::nullopt if \p Path doesn't exist or can't get the status.
-llvm::Optional<llvm::sys::fs::file_status> getFileStatus(llvm::StringRef Path);
+std::optional<llvm::sys::fs::file_status> getFileStatus(llvm::StringRef Path);
 
 } // namespace clang
diff --git a/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h b/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h
index 5815742d57ac72..91e3ccf2ec3047 100644
--- a/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h
+++ b/clang/lib/StaticAnalyzer/Checkers/WebKit/PtrTypesSemantics.h
@@ -10,7 +10,7 @@
 #define LLVM_CLANG_ANALYZER_WEBKIT_PTRTYPESEMANTICS_H
 
 #include "llvm/ADT/APInt.h"
-#include "llvm/ADT/Optional.h"
+#include <optional>
 
 namespace clang {
 class CXXBaseSpecifier;
@@ -28,30 +28,30 @@ class Type;
 
 /// \returns CXXRecordDecl of the base if the type is ref-countable, nullptr if
 /// not, std::nullopt if inconclusive.
-llvm::Optional<const clang::CXXRecordDecl *>
-isRefCountable(const clang::CXXBaseSpecifier *Base);
+std::optional<const clang::CXXRecordDecl*>
+isRefCountable(const clang::CXXBaseSpecifier* Base);
 
 /// \returns true if \p Class is ref-countable, false if not, std::nullopt if
 /// inconclusive.
-llvm::Optional<bool> isRefCountable(const clang::CXXRecordDecl *Class);
+std::optional<bool> isRefCountable(const clang::CXXRecordDecl* Class);
 
 /// \returns true if \p Class is ref-counted, false if not.
 bool isRefCounted(const clang::CXXRecordDecl *Class);
 
 /// \returns true if \p Class is ref-countable AND not ref-counted, false if
 /// not, std::nullopt if inconclusive.
-llvm::Optional<bool> isUncounted(const clang::CXXRecordDecl *Class);
+std::optional<bool> isUncounted(const clang::CXXRecordDecl* Class);
 
 /// \returns true if \p T is either a raw pointer or reference to an uncounted
 /// class, false if not, std::nullopt if inconclusive.
-llvm::Optional<bool> isUncountedPtr(const clang::Type *T);
+std::optional<bool> isUncountedPtr(const clang::Type* T);
 
 /// \returns true if \p F creates ref-countable object from uncounted parameter,
 /// false if not.
 bool isCtorOfRefCounted(const clang::FunctionDecl *F);
 
 /// \returns true if \p M is getter of a ref-counted class, false if not.
-llvm::Optional<bool> isGetterOfRefCounted(const clang::CXXMethodDecl *Method);
+std::optional<bool> isGetterOfRefCounted(const clang::CXXMethodDecl* Method);
 
 /// \returns true if \p F is a conversion between ref-countable or ref-counted
 /// pointer types.
diff --git a/clang/lib/Support/RISCVVIntrinsicUtils.cpp b/clang/lib/Support/RISCVVIntrinsicUtils.cpp
index c1c4a30576adc3..9a550806f69d82 100644
--- a/clang/lib/Support/RISCVVIntrinsicUtils.cpp
+++ b/clang/lib/Support/RISCVVIntrinsicUtils.cpp
@@ -8,7 +8,6 @@
 
 #include "clang/Support/RISCVVIntrinsicUtils.h"
 #include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
@@ -16,6 +15,7 @@
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/raw_ostream.h"
 #include <numeric>
+#include <optional>
 
 using namespace llvm;
 
@@ -362,7 +362,8 @@ void RVVType::applyBasicType() {
   assert(ElementBitwidth != 0 && "Bad element bitwidth!");
 }
 
-Optional<PrototypeDescriptor> PrototypeDescriptor::parsePrototypeDescriptor(
+std::optional<PrototypeDescriptor>
+PrototypeDescriptor::parsePrototypeDescriptor(
     llvm::StringRef PrototypeDescriptorStr) {
   PrototypeDescriptor PD;
   BaseTypeModifier PT = BaseTypeModifier::Invalid;
@@ -783,7 +784,7 @@ void RVVType::applyFixedLog2LMUL(int Log2LMUL, enum FixedLMULType Type) {
   Scale = LMUL.getScale(ElementBitwidth);
 }
 
-Optional<RVVTypes>
+std::optional<RVVTypes>
 RVVTypeCache::computeTypes(BasicType BT, int Log2LMUL, unsigned NF,
                            ArrayRef<PrototypeDescriptor> Prototype) {
   // LMUL x NF must be less than or equal to 8.
@@ -814,8 +815,8 @@ static uint64_t computeRVVTypeHashValue(BasicType BT, int Log2LMUL,
          ((uint64_t)(Proto.VTM & 0xff) << 32);
 }
 
-Optional<RVVTypePtr> RVVTypeCache::computeType(BasicType BT, int Log2LMUL,
-                                               PrototypeDescriptor Proto) {
+std::optional<RVVTypePtr> RVVTypeCache::computeType(BasicType BT, int Log2LMUL,
+                                                    PrototypeDescriptor Proto) {
   uint64_t Idx = computeRVVTypeHashValue(BT, Log2LMUL, Proto);
   // Search first
   auto It = LegalTypes.find(Idx);
diff --git a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
index 2e60519691f044..ad942efb352e84 100644
--- a/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
+++ b/clang/tools/clang-linker-wrapper/ClangLinkerWrapper.cpp
@@ -53,6 +53,7 @@
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include <atomic>
+#include <optional>
 
 using namespace llvm;
 using namespace llvm::opt;
@@ -1231,8 +1232,8 @@ linkAndWrapDeviceFiles(SmallVectorImpl<OffloadFile> &LinkerInputFiles,
   return WrappedOutput;
 }
 
-Optional<std::string> findFile(StringRef Dir, StringRef Root,
-                               const Twine &Name) {
+std::optional<std::string> findFile(StringRef Dir, StringRef Root,
+                                    const Twine &Name) {
   SmallString<128> Path;
   if (Dir.startswith("="))
     sys::path::append(Path, Root, Dir.substr(1), Name);
@@ -1244,20 +1245,24 @@ Optional<std::string> findFile(StringRef Dir, StringRef Root,
   return std::nullopt;
 }
 
-Optional<std::string> findFromSearchPaths(StringRef Name, StringRef Root,
-                                          ArrayRef<StringRef> SearchPaths) {
+std::optional<std::string>
+findFromSearchPaths(StringRef Name, StringRef Root,
+                    ArrayRef<StringRef> SearchPaths) {
   for (StringRef Dir : SearchPaths)
-    if (Optional<std::string> File = findFile(Dir, Root, Name))
+    if (std::optional<std::string> File = findFile(Dir, Root, Name))
       return File;
   return std::nullopt;
 }
 
-Optional<std::string> searchLibraryBaseName(StringRef Name, StringRef Root,
-                                            ArrayRef<StringRef> SearchPaths) {
+std::optional<std::string>
+searchLibraryBaseName(StringRef Name, StringRef Root,
+                      ArrayRef<StringRef> SearchPaths) {
   for (StringRef Dir : SearchPaths) {
-    if (Optional<std::string> File = findFile(Dir, Root, "lib" + Name + ".so"))
+    if (std::optional<std::string> File =
+            findFile(Dir, Root, "lib" + Name + ".so"))
       return File;
-    if (Optional<std::string> File = findFile(Dir, Root, "lib" + Name + ".a"))
+    if (std::optional<std::string> File =
+            findFile(Dir, Root, "lib" + Name + ".a"))
       return File;
   }
   return std::nullopt;
@@ -1265,8 +1270,8 @@ Optional<std::string> searchLibraryBaseName(StringRef Name, StringRef Root,
 
 /// Search for static libraries in the linker's library path given input like
 /// `-lfoo` or `-l:libfoo.a`.
-Optional<std::string> searchLibrary(StringRef Input, StringRef Root,
-                                    ArrayRef<StringRef> SearchPaths) {
+std::optional<std::string> searchLibrary(StringRef Input, StringRef Root,
+                                         ArrayRef<StringRef> SearchPaths) {
   if (Input.startswith(":"))
     return findFromSearchPaths(Input.drop_front(), Root, SearchPaths);
   return searchLibraryBaseName(Input, Root, SearchPaths);
diff --git a/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp b/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp
index 53361a1184f5d1..4ad6f8025674b4 100644
--- a/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp
+++ b/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp
@@ -15,6 +15,7 @@
 #include <condition_variable>
 #include <future>
 #include <mutex>
+#include <optional>
 #include <thread>
 
 using namespace llvm;
@@ -177,7 +178,7 @@ struct VerifyingConsumer {
   }
 
   // Not locking - caller has to lock Mtx.
-  llvm::Optional<bool> result() const {
+  std::optional<bool> result() const {
     if (ExpectedInitial.empty() && ExpectedNonInitial.empty() &&
         UnexpectedInitial.empty() && UnexpectedNonInitial.empty())
       return true;
diff --git a/clang/unittests/libclang/LibclangTest.cpp b/clang/unittests/libclang/LibclangTest.cpp
index 0845476f31dea6..809426a01ca7a6 100644
--- a/clang/unittests/libclang/LibclangTest.cpp
+++ b/clang/unittests/libclang/LibclangTest.cpp
@@ -19,6 +19,7 @@
 #include <functional>
 #include <map>
 #include <memory>
+#include <optional>
 #include <set>
 #define DEBUG_TYPE "libclang-test"
 
@@ -934,7 +935,7 @@ void Class1::fun() {}
   ClangTU = clang_parseTranslationUnit(Index, fileName.c_str(), Args, 1,
                                        nullptr, 0, TUFlags);
 
-  llvm::Optional<CXCursor> typeRefCsr;
+  std::optional<CXCursor> typeRefCsr;
   Traverse([&](CXCursor cursor, CXCursor parent) -> CXChildVisitResult {
     if (cursor.kind == CXCursor_TypeRef) {
       typeRefCsr.emplace(cursor);
diff --git a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
index ec682edb57f630..0b553254682ca8 100644
--- a/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -12,7 +12,6 @@
 
 #include "TableGenBackends.h"
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
@@ -30,6 +29,7 @@
 #include <cctype>
 #include <functional>
 #include <map>
+#include <optional>
 #include <set>
 using namespace llvm;
 
@@ -250,8 +250,9 @@ typedef llvm::PointerUnion<RecordVec*, RecordSet*> VecOrSet;
 
 namespace {
 class InferPedantic {
-  typedef llvm::DenseMap<const Record*,
-                         std::pair<unsigned, Optional<unsigned> > > GMap;
+  typedef llvm::DenseMap<const Record *,
+                         std::pair<unsigned, std::optional<unsigned>>>
+      GMap;
 
   DiagGroupParentMap &DiagGroupParents;
   const std::vector<Record*> &Diags;
@@ -675,7 +676,7 @@ struct DiagnosticTextBuilder {
 };
 
 template <class Derived> struct DiagTextVisitor {
-  using ModifierMappingsType = Optional<std::vector<int>>;
+  using ModifierMappingsType = std::optional<std::vector<int>>;
 
 private:
   Derived &getDerived() { return static_cast<Derived &>(*this); }
@@ -706,7 +707,7 @@ template <class Derived> struct DiagTextVisitor {
 
   private:
     DiagTextVisitor &Visitor;
-    Optional<std::vector<int>> OldMappings;
+    std::optional<std::vector<int>> OldMappings;
 
   public:
     Piece *Substitution;
diff --git a/clang/utils/TableGen/NeonEmitter.cpp b/clang/utils/TableGen/NeonEmitter.cpp
index 98e195d0a63a23..8f46b08b1366f0 100644
--- a/clang/utils/TableGen/NeonEmitter.cpp
+++ b/clang/utils/TableGen/NeonEmitter.cpp
@@ -26,7 +26,6 @@
 #include "TableGenBackends.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
@@ -44,6 +43,7 @@
 #include <cstdint>
 #include <deque>
 #include <map>
+#include <optional>
 #include <set>
 #include <sstream>
 #include <string>
@@ -559,7 +559,7 @@ class NeonEmitter {
   /// Called by Intrinsic - this attempts to get an intrinsic that takes
   /// the given types as arguments.
   Intrinsic &getIntrinsic(StringRef Name, ArrayRef<Type> Types,
-                          Optional<std::string> MangledName);
+                          std::optional<std::string> MangledName);
 
   /// Called by Intrinsic - returns a globally-unique number.
   unsigned getUniqueNumber() { return UniqueNumber++; }
@@ -1471,7 +1471,7 @@ Intrinsic::DagEmitter::emitDagCall(DagInit *DI, bool MatchMangledName) {
     N = SI->getAsUnquotedString();
   else
     N = emitDagArg(DI->getArg(0), "").second;
-  Optional<std::string> MangledName;
+  std::optional<std::string> MangledName;
   if (MatchMangledName) {
     if (Intr.getRecord()->getValueAsBit("isLaneQ"))
       N += "q";
@@ -1895,7 +1895,7 @@ void Intrinsic::indexBody() {
 //===----------------------------------------------------------------------===//
 
 Intrinsic &NeonEmitter::getIntrinsic(StringRef Name, ArrayRef<Type> Types,
-                                     Optional<std::string> MangledName) {
+                                     std::optional<std::string> MangledName) {
   // First, look up the name in the intrinsic map.
   assert_with_loc(IntrinsicMap.find(Name.str()) != IntrinsicMap.end(),
                   ("Intrinsic '" + Name + "' not found!").str());
diff --git a/clang/utils/TableGen/RISCVVEmitter.cpp b/clang/utils/TableGen/RISCVVEmitter.cpp
index b69712e57f04f5..d9caafeec8c421 100644
--- a/clang/utils/TableGen/RISCVVEmitter.cpp
+++ b/clang/utils/TableGen/RISCVVEmitter.cpp
@@ -25,6 +25,7 @@
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include <numeric>
+#include <optional>
 
 using namespace llvm;
 using namespace clang::RISCV;
@@ -560,7 +561,7 @@ void RVVEmitter::createRVVIntrinsics(
     for (char I : TypeRange) {
       for (int Log2LMUL : Log2LMULList) {
         BasicType BT = ParseBasicType(I);
-        Optional<RVVTypes> Types =
+        std::optional<RVVTypes> Types =
             TypeCache.computeTypes(BT, Log2LMUL, NF, Prototype);
         // Ignored to create new intrinsic if there are any illegal types.
         if (!Types)
@@ -584,7 +585,7 @@ void RVVEmitter::createRVVIntrinsics(
                     BasicPrototype, /*IsMasked=*/false,
                     /*HasMaskedOffOperand=*/false, HasVL, NF,
                     IsPrototypeDefaultTU, UnMaskedPolicyScheme, P);
-            Optional<RVVTypes> PolicyTypes =
+            std::optional<RVVTypes> PolicyTypes =
                 TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
             Out.push_back(std::make_unique<RVVIntrinsic>(
                 Name, SuffixStr, OverloadedName, OverloadedSuffixStr, IRName,
@@ -596,7 +597,7 @@ void RVVEmitter::createRVVIntrinsics(
         if (!HasMasked)
           continue;
         // Create a masked intrinsic
-        Optional<RVVTypes> MaskTypes =
+        std::optional<RVVTypes> MaskTypes =
             TypeCache.computeTypes(BT, Log2LMUL, NF, Prototype);
         Out.push_back(std::make_unique<RVVIntrinsic>(
             Name, SuffixStr, OverloadedName, OverloadedSuffixStr, MaskedIRName,
@@ -611,7 +612,7 @@ void RVVEmitter::createRVVIntrinsics(
               RVVIntrinsic::computeBuiltinTypes(
                   BasicPrototype, /*IsMasked=*/true, HasMaskedOffOperand, HasVL,
                   NF, IsPrototypeDefaultTU, MaskedPolicyScheme, P);
-          Optional<RVVTypes> PolicyTypes =
+          std::optional<RVVTypes> PolicyTypes =
               TypeCache.computeTypes(BT, Log2LMUL, NF, PolicyPrototype);
           Out.push_back(std::make_unique<RVVIntrinsic>(
               Name, SuffixStr, OverloadedName, OverloadedSuffixStr,