[ADT, Support] Use std::nullopt instead of None (NFC)

[kazu]

Summary

This patch mechanically replaces None with std::nullopt where the
compiler would warn if None were deprecated. The intent is to reduce
the amount of manual work required in migrating from Optional to
std::optional.

This is part of an effort to migrate from llvm::Optional to
std::optional:

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

[dblaikie]

Looks good to me!

llvm/include/llvm/ADT/AddressRanges.h

public:
   bool empty() const { return Ranges.empty(); }
   bool contains(uint64_t Addr) const { return find(Addr) != Ranges.end(); }
   bool contains(AddressRange Range) const {
     return find(Range) != Ranges.end();
   }
   Optional<AddressRange> getRangeThatContains(uint64_t Addr) const {
     Collection::const_iterator It = find(Addr);
     if (It == Ranges.end())
-      return None;
+      return std::nullopt;
 
     return *It;
   }
   Collection::const_iterator insert(AddressRange Range);
   void reserve(size_t Capacity) { Ranges.reserve(Capacity); }
   size_t size() const { return Ranges.size(); }
   bool operator==(const AddressRanges &RHS) const {
     return Ranges == RHS.Ranges;
public:
   size_t size() const {
     assert(Ranges.size() == Values.size());
     return AddressRanges::size();
   }
   Optional<std::pair<AddressRange, T>>
   getRangeValueThatContains(uint64_t Addr) const {
     Collection::const_iterator It = find(Addr);
     if (It == Ranges.end())
-      return None;
+      return std::nullopt;
 
     return std::make_pair(*It, Values[It - Ranges.begin()]);
   }
   std::pair<AddressRange, T> operator[](size_t Idx) const {
     return std::make_pair(Ranges[Idx], Values[Idx]);
   }
 
 protected:
   using ValuesCollection = SmallVector<T>;
   ValuesCollection Values;
 };
 
 } // namespace llvm
 
 #endif // LLVM_ADT_ADDRESSRANGES_H

llvm/include/llvm/ADT/BreadthFirstIterator.h

private:
   // Current level.
   unsigned Level = 0;
 
   inline bf_iterator(NodeRef Node) {
     this->Visited.insert(Node);
     Level = 0;
 
     // Also, insert a dummy node as marker.
-    VisitQueue.push(QueueElement(Node, None));
-    VisitQueue.push(None);
+    VisitQueue.push(QueueElement(Node, std::nullopt));
+    VisitQueue.push(std::nullopt);
   }
 
   inline bf_iterator() = default;
 
   inline void toNext() {
     Optional<QueueElement> Head = VisitQueue.front();
     QueueElement H = *Head;
     NodeRef Node = H.first;
     Optional<ChildItTy> &ChildIt = H.second;
 
     if (!ChildIt)
       ChildIt.emplace(GT::child_begin(Node));
     while (*ChildIt != GT::child_end(Node)) {
       NodeRef Next = *(*ChildIt)++;
 
       // Already visited?
       if (this->Visited.insert(Next).second)
-        VisitQueue.push(QueueElement(Next, None));
+        VisitQueue.push(QueueElement(Next, std::nullopt));
     }
     VisitQueue.pop();
 
     // Go to the next element skipping markers if needed.
     if (!VisitQueue.empty()) {
       Head = VisitQueue.front();
-      if (Head != None)
+      if (Head != std::nullopt)
         return;
       Level += 1;
       VisitQueue.pop();
 
       // Don't push another marker if this is the last
       // element.
       if (!VisitQueue.empty())
-        VisitQueue.push(None);
+        VisitQueue.push(std::nullopt);
     }
   }
 
 public:
   // Provide static begin and end methods as our public "constructors"
   static bf_iterator begin(const GraphT &G) {
     return bf_iterator(GT::getEntryNode(G));
   }

llvm/include/llvm/ADT/DepthFirstIterator.h

private:
   // DFS.
   using StackElement = std::pair<NodeRef, Optional<ChildItTy>>;
 
   // VisitStack - Used to maintain the ordering.  Top = current block
   std::vector<StackElement> VisitStack;
 
   inline df_iterator(NodeRef Node) {
     this->Visited.insert(Node);
-    VisitStack.push_back(StackElement(Node, None));
+    VisitStack.push_back(StackElement(Node, std::nullopt));
   }
 
   inline df_iterator() = default; // End is when stack is empty
 
   inline df_iterator(NodeRef Node, SetType &S)
       : df_iterator_storage<SetType, ExtStorage>(S) {
     if (this->Visited.insert(Node).second)
-      VisitStack.push_back(StackElement(Node, None));
+      VisitStack.push_back(StackElement(Node, std::nullopt));
   }
 
   inline df_iterator(SetType &S)
     : df_iterator_storage<SetType, ExtStorage>(S) {
     // End is when stack is empty
   }
 
   inline void toNext() {
     do {
       NodeRef Node = VisitStack.back().first;
       Optional<ChildItTy> &Opt = VisitStack.back().second;
 
       if (!Opt)
         Opt.emplace(GT::child_begin(Node));
 
       // Notice that we directly mutate *Opt here, so that
       // VisitStack.back().second actually gets updated as the iterator
       // increases.
       while (*Opt != GT::child_end(Node)) {
         NodeRef Next = *(*Opt)++;
         // Has our next sibling been visited?
         if (this->Visited.insert(Next).second) {
           // No, do it now.
-          VisitStack.push_back(StackElement(Next, None));
+          VisitStack.push_back(StackElement(Next, std::nullopt));
           return;
         }
       }
       this->Visited.completed(Node);
 
       // Oops, ran out of successors... go up a level on the stack.
       VisitStack.pop_back();
     } while (!VisitStack.empty());

llvm/include/llvm/ADT/Optional.h

template <typename U> constexpr T value_or(U &&alt) const & {
     return has_value() ? value() : std::forward<U>(alt);
   }
 
   /// Apply a function to the value if present; otherwise return None.
   template <class Function>
   auto transform(const Function &F) const & -> Optional<decltype(F(value()))> {
     if (*this)
       return F(value());
-    return None;
+    return std::nullopt;
   }
 
   T &&value() && { return std::move(Storage.value()); }
   T &&operator*() && { return std::move(Storage.value()); }
 
   template <typename U> T value_or(U &&alt) && {
     return has_value() ? std::move(value()) : std::forward<U>(alt);
   }
 
   /// Apply a function to the value if present; otherwise return None.
   template <class Function>
   auto transform(
       const Function &F) && -> Optional<decltype(F(std::move(*this).value()))> {
     if (*this)
       return F(std::move(*this).value());
-    return None;
+    return std::nullopt;
   }
 };
 
 template<typename T>
 Optional(const T&) -> Optional<T>;
 
 template <class T> llvm::hash_code hash_value(const Optional<T> &O) {
   return O ? hash_combine(true, *O) : hash_value(false);

 
 template <typename T>
 constexpr bool operator==(const Optional<T> &X, std::nullopt_t) {
   return !X;
 }
 
 template <typename T>
 constexpr bool operator==(std::nullopt_t, const Optional<T> &X) {
-  return X == None;
+  return X == std::nullopt;
 }
 
 template <typename T>
 constexpr bool operator!=(const Optional<T> &X, std::nullopt_t) {
-  return !(X == None);
+  return !(X == std::nullopt);
 }
 
 template <typename T>
 constexpr bool operator!=(std::nullopt_t, const Optional<T> &X) {
-  return X != None;
+  return X != std::nullopt;
 }
 
 template <typename T>
 constexpr bool operator<(const Optional<T> &, std::nullopt_t) {
   return false;
 }
 
 template <typename T>
 constexpr bool operator<(std::nullopt_t, const Optional<T> &X) {
   return X.has_value();
 }
 
 template <typename T>
 constexpr bool operator<=(const Optional<T> &X, std::nullopt_t) {
-  return !(None < X);
+  return !(std::nullopt < X);
 }
 
 template <typename T>
 constexpr bool operator<=(std::nullopt_t, const Optional<T> &X) {
-  return !(X < None);
+  return !(X < std::nullopt);
 }
 
 template <typename T>
 constexpr bool operator>(const Optional<T> &X, std::nullopt_t) {
-  return None < X;
+  return std::nullopt < X;
 }
 
 template <typename T>
 constexpr bool operator>(std::nullopt_t, const Optional<T> &X) {
-  return X < None;
+  return X < std::nullopt;
 }
 
 template <typename T>
 constexpr bool operator>=(const Optional<T> &X, std::nullopt_t) {
-  return None <= X;
+  return std::nullopt <= X;
 }
 
 template <typename T>
 constexpr bool operator>=(std::nullopt_t, const Optional<T> &X) {
-  return X <= None;
+  return X <= std::nullopt;
 }
 
 template <typename T>
 constexpr bool operator==(const Optional<T> &X, const T &Y) {
   return X && *X == Y;
 }
 
 template <typename T>

 raw_ostream &operator<<(raw_ostream &OS, std::nullopt_t);
 
 template <typename T, typename = decltype(std::declval<raw_ostream &>()
                                           << std::declval<const T &>())>
 raw_ostream &operator<<(raw_ostream &OS, const Optional<T> &O) {
   if (O)
     OS << *O;
   else
-    OS << None;
+    OS << std::nullopt;
   return OS;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_OPTIONAL_H

llvm/include/llvm/ADT/STLExtras.h

if (I == End)
     return End;
   return std::next(I);
 }
 
 template <typename Iter>
 auto deref_or_none(const Iter &I, const Iter &End) -> llvm::Optional<
     std::remove_const_t<std::remove_reference_t<decltype(*I)>>> {
   if (I == End)
-    return None;
+    return std::nullopt;
   return *I;
 }
 
 template <typename Iter> struct ZipLongestItemType {
   using type = llvm::Optional<std::remove_const_t<
       std::remove_reference_t<decltype(*std::declval<Iter>())>>>;
 };
 

llvm/include/llvm/ADT/StringMapEntry.h

public:
   ValueTy &getValue() { return second; }
 
   void setValue(const ValueTy &V) { second = V; }
 };
 
 template <>
 class StringMapEntryStorage<std::nullopt_t> : public StringMapEntryBase {
 public:
-  explicit StringMapEntryStorage(size_t keyLength, std::nullopt_t = None)
+  explicit StringMapEntryStorage(size_t keyLength,
+                                 std::nullopt_t = std::nullopt)
       : StringMapEntryBase(keyLength) {}
   StringMapEntryStorage(StringMapEntryStorage &entry) = delete;
 
-  std::nullopt_t getValue() const { return None; }
+  std::nullopt_t getValue() const { return std::nullopt; }
 };
 
 /// StringMapEntry - This is used to represent one value that is inserted into
 /// a StringMap.  It contains the Value itself and the key: the string length
 /// and data.
 template <typename ValueTy>
 class StringMapEntry final : public StringMapEntryStorage<ValueTy> {
 public:

llvm/include/llvm/ADT/TinyPtrVector.h

public:
   TinyPtrVector(size_t Count, EltTy Value)
       : Val(Count == 0 ? PtrUnion()
                        : Count == 1 ? PtrUnion(Value)
                                     : PtrUnion(new VecTy(Count, Value))) {}
 
   // implicit conversion operator to ArrayRef.
   operator ArrayRef<EltTy>() const {
     if (Val.isNull())
-      return None;
+      return std::nullopt;
     if (Val.template is<EltTy>())
       return *Val.getAddrOfPtr1();
     return *Val.template get<VecTy*>();
   }
 
   // implicit conversion operator to MutableArrayRef.
   operator MutableArrayRef<EltTy>() {
     if (Val.isNull())
-      return None;
+      return std::nullopt;
     if (Val.template is<EltTy>())
       return *Val.getAddrOfPtr1();
     return *Val.template get<VecTy*>();
   }
 
   // Implicit conversion to ArrayRef<U> if EltTy* implicitly converts to U*.
   template <
       typename U,

llvm/include/llvm/Support/Allocator.h

llvm::Optional<int64_t> identifyObject(const void *Ptr) {
     int64_t InCustomSizedSlabIdx = -1;
     for (size_t Idx = 0, E = CustomSizedSlabs.size(); Idx < E; Idx++) {
       const char *S = static_cast<const char *>(CustomSizedSlabs[Idx].first);
       size_t Size = CustomSizedSlabs[Idx].second;
       if (P >= S && P < S + Size)
         return InCustomSizedSlabIdx - static_cast<int64_t>(P - S);
       InCustomSizedSlabIdx -= static_cast<int64_t>(Size);
     }
-    return None;
+    return std::nullopt;
   }
 
   /// A wrapper around identifyObject that additionally asserts that
   /// the object is indeed within the allocator.
   /// \return An index uniquely and reproducibly identifying
   /// an input pointer \p Ptr in the given allocator.
   int64_t identifyKnownObject(const void *Ptr) {
     Optional<int64_t> Out = identifyObject(Ptr);

llvm/include/llvm/Support/CheckedArithmetic.h

 std::enable_if_t<std::is_integral<T>::value && sizeof(T) * 8 <= 64,
                  llvm::Optional<T>>
 checkedOp(T LHS, T RHS, F Op, bool Signed = true) {
   llvm::APInt ALHS(sizeof(T) * 8, LHS, Signed);
   llvm::APInt ARHS(sizeof(T) * 8, RHS, Signed);
   bool Overflow;
   llvm::APInt Out = (ALHS.*Op)(ARHS, Overflow);
   if (Overflow)
-    return llvm::None;
+    return std::nullopt;
   return Signed ? Out.getSExtValue() : Out.getZExtValue();
 }
 }
 
 namespace llvm {
 
 /// Add two signed integers \p LHS and \p RHS.
 /// \return Optional of sum if no signed overflow occurred,

 /// Multiply A and B, and add C to the resulting product.
 /// \return Optional of result if no signed overflow occurred,
 /// \c None otherwise.
 template <typename T>
 std::enable_if_t<std::is_signed<T>::value, llvm::Optional<T>>
 checkedMulAdd(T A, T B, T C) {
   if (auto Product = checkedMul(A, B))
     return checkedAdd(*Product, C);
-  return llvm::None;
+  return std::nullopt;
 }
 
 /// Add two unsigned integers \p LHS and \p RHS.
 /// \return Optional of sum if no unsigned overflow occurred,
 /// \c None otherwise.
 template <typename T>
 std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>>
 checkedAddUnsigned(T LHS, T RHS) {

 /// Multiply unsigned integers A and B, and add C to the resulting product.
 /// \return Optional of result if no unsigned overflow occurred,
 /// \c None otherwise.
 template <typename T>
 std::enable_if_t<std::is_unsigned<T>::value, llvm::Optional<T>>
 checkedMulAddUnsigned(T A, T B, T C) {
   if (auto Product = checkedMulUnsigned(A, B))
     return checkedAddUnsigned(*Product, C);
-  return llvm::None;
+  return std::nullopt;
 }
 
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Support/Error.h

 ///
 /// Uses of this method are potentially indicative of problems: perhaps the
 /// error should be propagated further, or the error-producer should just
 /// return an Optional in the first place.
 template <typename T> Optional<T> expectedToOptional(Expected<T> &&E) {
   if (E)
     return std::move(*E);
   consumeError(E.takeError());
-  return None;
+  return std::nullopt;
 }
 
 /// Helper for converting an Error to a bool.
 ///
 /// This method returns true if Err is in an error state, or false if it is
 /// in a success state.  Puts Err in a checked state in both cases (unlike
 /// Error::operator bool(), which only does this for success states).
 inline bool errorToBool(Error Err) {

llvm/include/llvm/Support/FileUtilities.h

namespace llvm {
   class FilePermissionsApplier {
   public:
     static Expected<FilePermissionsApplier> create(StringRef InputFilename);
 
     /// Apply stored permissions to the \p OutputFilename.
     /// Copy LastAccess and ModificationTime if \p CopyDates is true.
     /// Overwrite stored permissions if \p OverwritePermissions is specified.
     Error apply(StringRef OutputFilename, bool CopyDates = false,
-                Optional<sys::fs::perms> OverwritePermissions = None);
+                Optional<sys::fs::perms> OverwritePermissions = std::nullopt);
 
   private:
     FilePermissionsApplier(StringRef InputFilename, sys::fs::file_status Status)
         : InputFilename(InputFilename), InputStatus(Status) {}
 
     StringRef InputFilename;
     sys::fs::file_status InputStatus;
   };
 } // End llvm namespace
 
 #endif

llvm/include/llvm/Support/Format.h

FormattedBytes(ArrayRef<uint8_t> B, uint32_t IL, Optional<uint64_t> O,
         ByteGroupSize(BGS), Upper(U), ASCII(A) {
 
     if (ByteGroupSize > NumPerLine)
       ByteGroupSize = NumPerLine;
   }
 };
 
 inline FormattedBytes
-format_bytes(ArrayRef<uint8_t> Bytes, Optional<uint64_t> FirstByteOffset = None,
+format_bytes(ArrayRef<uint8_t> Bytes,
+             Optional<uint64_t> FirstByteOffset = std::nullopt,
              uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,
              uint32_t IndentLevel = 0, bool Upper = false) {
   return FormattedBytes(Bytes, IndentLevel, FirstByteOffset, NumPerLine,
                         ByteGroupSize, Upper, false);
 }
 
 inline FormattedBytes
 format_bytes_with_ascii(ArrayRef<uint8_t> Bytes,
-                        Optional<uint64_t> FirstByteOffset = None,
+                        Optional<uint64_t> FirstByteOffset = std::nullopt,
                         uint32_t NumPerLine = 16, uint8_t ByteGroupSize = 4,
                         uint32_t IndentLevel = 0, bool Upper = false) {
   return FormattedBytes(Bytes, IndentLevel, FirstByteOffset, NumPerLine,
                         ByteGroupSize, Upper, true);
 }
 
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/FormatProviders.h

struct use_double_formatter
     : public std::integral_constant<bool, std::is_floating_point<T>::value> {};
 
 class HelperFunctions {
 protected:
   static Optional<size_t> parseNumericPrecision(StringRef Str) {
     size_t Prec;
     Optional<size_t> Result;
     if (Str.empty())
-      Result = None;
+      Result = std::nullopt;
     else if (Str.getAsInteger(10, Prec)) {
       assert(false && "Invalid precision specifier");
-      Result = None;
+      Result = std::nullopt;
     } else {
       assert(Prec < 100 && "Precision out of range");
       Result = std::min<size_t>(99u, Prec);
     }
     return Result;
   }
 
   static bool consumeHexStyle(StringRef &Str, HexPrintStyle &Style) {

llvm/include/llvm/Support/InstructionCost.h

public:
   CostState getState() const { return State; }
 
   /// This function is intended to be used as sparingly as possible, since the
   /// class provides the full range of operator support required for arithmetic
   /// and comparisons.
   std::optional<CostType> getValue() const {
     if (isValid())
       return Value;
-    return None;
+    return std::nullopt;
   }
 
   /// For all of the arithmetic operators provided here any invalid state is
   /// perpetuated and cannot be removed. Once a cost becomes invalid it stays
   /// invalid, and it also inherits any invalid state from the RHS.
   /// Arithmetic work on the actual values is implemented with saturation,
   /// to avoid overflow when using more extreme cost values.
 

llvm/include/llvm/Support/JSON.h

Kind kind() const {
     }
     llvm_unreachable("Unknown kind");
   }
 
   // Typed accessors return None/nullptr if the Value is not of this type.
   llvm::Optional<std::nullptr_t> getAsNull() const {
     if (LLVM_LIKELY(Type == T_Null))
       return nullptr;
-    return llvm::None;
+    return std::nullopt;
   }
   llvm::Optional<bool> getAsBoolean() const {
     if (LLVM_LIKELY(Type == T_Boolean))
       return as<bool>();
-    return llvm::None;
+    return std::nullopt;
   }
   llvm::Optional<double> getAsNumber() const {
     if (LLVM_LIKELY(Type == T_Double))
       return as<double>();
     if (LLVM_LIKELY(Type == T_Integer))
       return as<int64_t>();
     if (LLVM_LIKELY(Type == T_UINT64))
       return as<uint64_t>();
-    return llvm::None;
+    return std::nullopt;
   }
   // Succeeds if the Value is a Number, and exactly representable as int64_t.
   llvm::Optional<int64_t> getAsInteger() const {
     if (LLVM_LIKELY(Type == T_Integer))
       return as<int64_t>();
     if (LLVM_LIKELY(Type == T_Double)) {
       double D = as<double>();
       if (LLVM_LIKELY(std::modf(D, &D) == 0.0 &&
                       D >= double(std::numeric_limits<int64_t>::min()) &&
                       D <= double(std::numeric_limits<int64_t>::max())))
         return D;
     }
-    return llvm::None;
+    return std::nullopt;
   }
   llvm::Optional<uint64_t> getAsUINT64() const {
     if (Type == T_UINT64)
       return as<uint64_t>();
     else if (Type == T_Integer) {
       int64_t N = as<int64_t>();
       if (N >= 0)
         return as<uint64_t>();
     }
-    return llvm::None;
+    return std::nullopt;
   }
   llvm::Optional<llvm::StringRef> getAsString() const {
     if (Type == T_String)
       return llvm::StringRef(as<std::string>());
     if (LLVM_LIKELY(Type == T_StringRef))
       return as<llvm::StringRef>();
-    return llvm::None;
+    return std::nullopt;
   }
   const json::Object *getAsObject() const {
     return LLVM_LIKELY(Type == T_Object) ? &as<json::Object>() : nullptr;
   }
   json::Object *getAsObject() {
     return LLVM_LIKELY(Type == T_Object) ? &as<json::Object>() : nullptr;
   }
   const json::Array *getAsArray() const {
if (auto S = E.getAsNull()) {
     return true;
   }
   P.report("expected null");
   return false;
 }
 template <typename T>
 bool fromJSON(const Value &E, llvm::Optional<T> &Out, Path P) {
   if (E.getAsNull()) {
-    Out = llvm::None;
+    Out = std::nullopt;
     return true;
   }
   T Result;
   if (!fromJSON(E, Result, P))
     return false;
   Out = std::move(Result);
   return true;
 }
public:
 
   /// Maps a property to a field, if it exists.
   /// If the property exists and is invalid, reports an error.
   /// (Optional requires special handling, because missing keys are OK).
   template <typename T> bool map(StringLiteral Prop, llvm::Optional<T> &Out) {
     assert(*this && "Must check this is an object before calling map()");
     if (const Value *E = O->get(Prop))
       return fromJSON(*E, Out, P.field(Prop));
-    Out = llvm::None;
+    Out = std::nullopt;
     return true;
   }
 
   /// Maps a property to a field, if it exists.
   /// If the property exists and is invalid, reports an error.
   /// If the property does not exist, Out is unchanged.
   template <typename T> bool mapOptional(StringLiteral Prop, T &Out) {
     assert(*this && "Must check this is an object before calling map()");

llvm/include/llvm/Support/MemoryBuffer.h

public:
   /// can change outside the user's control, e.g. when libclang tries to parse
   /// while the user is editing/updating the file or if the file is on an NFS.
   ///
   /// \param Alignment Set to indicate that the buffer should be aligned to at
   /// least the specified alignment.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getFile(const Twine &Filename, bool IsText = false,
           bool RequiresNullTerminator = true, bool IsVolatile = false,
-          Optional<Align> Alignment = None);
+          Optional<Align> Alignment = std::nullopt);
 
   /// Read all of the specified file into a MemoryBuffer as a stream
   /// (i.e. until EOF reached). This is useful for special files that
   /// look like a regular file but have 0 size (e.g. /proc/cpuinfo on Linux).
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getFileAsStream(const Twine &Filename);
 
   /// Given an already-open file descriptor, map some slice of it into a
   /// MemoryBuffer. The slice is specified by an \p Offset and \p MapSize.
   /// Since this is in the middle of a file, the buffer is not null terminated.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize,
                    int64_t Offset, bool IsVolatile = false,
-                   Optional<Align> Alignment = None);
+                   Optional<Align> Alignment = std::nullopt);
 
   /// Given an already-open file descriptor, read the file and return a
   /// MemoryBuffer.
   ///
   /// \param IsVolatile Set to true to indicate that the contents of the file
   /// can change outside the user's control, e.g. when libclang tries to parse
   /// while the user is editing/updating the file or if the file is on an NFS.
   ///
   /// \param Alignment Set to indicate that the buffer should be aligned to at
   /// least the specified alignment.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize,
               bool RequiresNullTerminator = true, bool IsVolatile = false,
-              Optional<Align> Alignment = None);
+              Optional<Align> Alignment = std::nullopt);
 
   /// Open the specified memory range as a MemoryBuffer. Note that InputData
   /// must be null terminated if RequiresNullTerminator is true.
   static std::unique_ptr<MemoryBuffer>
   getMemBuffer(StringRef InputData, StringRef BufferName = "",
                bool RequiresNullTerminator = true);
 
   static std::unique_ptr<MemoryBuffer>
   getMemBuffer(MemoryBufferRef Ref, bool RequiresNullTerminator = true);
 
   /// Open the specified memory range as a MemoryBuffer, copying the contents
   /// and taking ownership of it. InputData does not have to be null terminated.
   static std::unique_ptr<MemoryBuffer>
   getMemBufferCopy(StringRef InputData, const Twine &BufferName = "");
 
   /// Read all of stdin into a file buffer, and return it.
   static ErrorOr<std::unique_ptr<MemoryBuffer>> getSTDIN();
 
   /// Open the specified file as a MemoryBuffer, or open stdin if the Filename
   /// is "-".
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getFileOrSTDIN(const Twine &Filename, bool IsText = false,
                  bool RequiresNullTerminator = true,
-                 Optional<Align> Alignment = None);
+                 Optional<Align> Alignment = std::nullopt);
 
   /// Map a subrange of the specified file as a MemoryBuffer.
   static ErrorOr<std::unique_ptr<MemoryBuffer>>
   getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
-               bool IsVolatile = false, Optional<Align> Alignment = None);
+               bool IsVolatile = false,
+               Optional<Align> Alignment = std::nullopt);
 
   //===--------------------------------------------------------------------===//
   // Provided for performance analysis.
   //===--------------------------------------------------------------------===//
 
   /// The kind of memory backing used to support the MemoryBuffer.
   enum BufferKind {
     MemoryBuffer_Malloc,
char *getBufferEnd() {
     return const_cast<char *>(MemoryBuffer::getBufferEnd());
   }
   MutableArrayRef<char> getBuffer() {
     return {getBufferStart(), getBufferEnd()};
   }
 
   static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
   getFile(const Twine &Filename, bool IsVolatile = false,
-          Optional<Align> Alignment = None);
+          Optional<Align> Alignment = std::nullopt);
 
   /// Map a subrange of the specified file as a WritableMemoryBuffer.
   static ErrorOr<std::unique_ptr<WritableMemoryBuffer>>
   getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset,
-               bool IsVolatile = false, Optional<Align> Alignment = None);
+               bool IsVolatile = false,
+               Optional<Align> Alignment = std::nullopt);
 
   /// Allocate a new MemoryBuffer of the specified size that is not initialized.
   /// Note that the caller should initialize the memory allocated by this
   /// method. The memory is owned by the MemoryBuffer object.
   ///
   /// \param Alignment Set to indicate that the buffer should be aligned to at
   /// least the specified alignment.
   static std::unique_ptr<WritableMemoryBuffer>
   getNewUninitMemBuffer(size_t Size, const Twine &BufferName = "",
-                        Optional<Align> Alignment = None);
+                        Optional<Align> Alignment = std::nullopt);
 
   /// Allocate a new zero-initialized MemoryBuffer of the specified size. Note
   /// that the caller need not initialize the memory allocated by this method.
   /// The memory is owned by the MemoryBuffer object.
   static std::unique_ptr<WritableMemoryBuffer>
   getNewMemBuffer(size_t Size, const Twine &BufferName = "");
 
 private:

llvm/include/llvm/Support/NativeFormatting.h

 void write_integer(raw_ostream &S, long N, size_t MinDigits,
                    IntegerStyle Style);
 void write_integer(raw_ostream &S, unsigned long long N, size_t MinDigits,
                    IntegerStyle Style);
 void write_integer(raw_ostream &S, long long N, size_t MinDigits,
                    IntegerStyle Style);
 
 void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
-               Optional<size_t> Width = None);
+               Optional<size_t> Width = std::nullopt);
 void write_double(raw_ostream &S, double D, FloatStyle Style,
-                  Optional<size_t> Precision = None);
+                  Optional<size_t> Precision = std::nullopt);
 }
 
 #endif
 

llvm/include/llvm/Support/VersionTuple.h

public:
   }
 
   /// Retrieve the major version number.
   unsigned getMajor() const { return Major; }
 
   /// Retrieve the minor version number, if provided.
   Optional<unsigned> getMinor() const {
     if (!HasMinor)
-      return None;
+      return std::nullopt;
     return Minor;
   }
 
   /// Retrieve the subminor version number, if provided.
   Optional<unsigned> getSubminor() const {
     if (!HasSubminor)
-      return None;
+      return std::nullopt;
     return Subminor;
   }
 
   /// Retrieve the build version number, if provided.
   Optional<unsigned> getBuild() const {
     if (!HasBuild)
-      return None;
+      return std::nullopt;
     return Build;
   }
 
   /// Return a version tuple that contains only the first 3 version components.
   VersionTuple withoutBuild() const {
     if (HasBuild)
       return VersionTuple(Major, Minor, Subminor);
     return *this;

llvm/include/llvm/Support/VirtualFileSystem.h

public:
   /// Add a file containing a buffer or a directory to the VFS with a
   /// path. The VFS owns the buffer.  If present, User, Group, Type
   /// and Perms apply to the newly-created file or directory.
   /// \return true if the file or directory was successfully added,
   /// false if the file or directory already exists in the file system with
   /// different contents.
   bool addFile(const Twine &Path, time_t ModificationTime,
                std::unique_ptr<llvm::MemoryBuffer> Buffer,
-               Optional<uint32_t> User = None, Optional<uint32_t> Group = None,
-               Optional<llvm::sys::fs::file_type> Type = None,
-               Optional<llvm::sys::fs::perms> Perms = None);
+               Optional<uint32_t> User = std::nullopt,
+               Optional<uint32_t> Group = std::nullopt,
+               Optional<llvm::sys::fs::file_type> Type = std::nullopt,
+               Optional<llvm::sys::fs::perms> Perms = std::nullopt);
 
   /// Add a hard link to a file.
   ///
   /// Here hard links are not intended to be fully equivalent to the classical
   /// filesystem. Both the hard link and the file share the same buffer and
   /// status (and thus have the same UniqueID). Because of this there is no way
   /// to distinguish between the link and the file after the link has been
   /// added.
public:
   /// Arbitrary max depth to search through symlinks. We can get into problems
   /// if a link links to a link that links back to the link, for example.
   static constexpr size_t MaxSymlinkDepth = 16;
 
   /// Add a symbolic link. Unlike a HardLink, because \p Target doesn't need
   /// to refer to a file (or refer to anything, as it happens). Also, an
   /// in-memory directory for \p Target isn't automatically created.
   bool addSymbolicLink(const Twine &NewLink, const Twine &Target,
-                       time_t ModificationTime, Optional<uint32_t> User = None,
-                       Optional<uint32_t> Group = None,
-                       Optional<llvm::sys::fs::perms> Perms = None);
+                       time_t ModificationTime,
+                       Optional<uint32_t> User = std::nullopt,
+                       Optional<uint32_t> Group = std::nullopt,
+                       Optional<llvm::sys::fs::perms> Perms = std::nullopt);
 
   /// Add a buffer to the VFS with a path. The VFS does not own the buffer.
   /// If present, User, Group, Type and Perms apply to the newly-created file
   /// or directory.
   /// \return true if the file or directory was successfully added,
   /// false if the file or directory already exists in the file system with
   /// different contents.
   bool addFileNoOwn(const Twine &Path, time_t ModificationTime,
                     const llvm::MemoryBufferRef &Buffer,
-                    Optional<uint32_t> User = None,
-                    Optional<uint32_t> Group = None,
-                    Optional<llvm::sys::fs::file_type> Type = None,
-                    Optional<llvm::sys::fs::perms> Perms = None);
+                    Optional<uint32_t> User = std::nullopt,
+                    Optional<uint32_t> Group = std::nullopt,
+                    Optional<llvm::sys::fs::file_type> Type = std::nullopt,
+                    Optional<llvm::sys::fs::perms> Perms = std::nullopt);
 
   std::string toString() const;
 
   /// Return true if this file system normalizes . and .. in paths.
   bool useNormalizedPaths() const { return UseNormalizedPaths; }
 
   llvm::ErrorOr<Status> status(const Twine &Path) override;
   llvm::ErrorOr<std::unique_ptr<File>>
public:
     /// If the found Entry maps the the input path to a path in the external
     /// file system (i.e. it is a FileEntry or DirectoryRemapEntry), returns
     /// that path.
     Optional<StringRef> getExternalRedirect() const {
       if (isa<DirectoryRemapEntry>(E))
         return StringRef(*ExternalRedirect);
       if (auto *FE = dyn_cast<FileEntry>(E))
         return FE->getExternalContentsPath();
-      return None;
+      return std::nullopt;
     }
   };
 
 private:
   friend class RedirectingFSDirIterImpl;
   friend class RedirectingFileSystemParser;
 
   /// Canonicalize path by removing ".", "..", "./", components. This is