Use std::nullopt_t instead of NoneType (NFC)

[kazu]

Summary

This patch replaces those occurrences of NoneType that would trigger
an error if the definition of NoneType were missing in None.h.

To keep this patch focused, I am deliberately not replacing None with
std::nullopt in this patch or updating comments. They will be
addressed in subsequent patches.

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

[DavidSpickett]

lldb parts LGTM.

[dblaikie]

Sounds good to me, thanks!

[MaskRay]

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

218

A maintainer might want to check the uses. Having 3 constructors looks confusing to readers.

[steakhal]

This patch breaks llvm::StringSet equality.
The following code would no longer compile:

llvm::StringSet LHS;
llvm::StringSet RHS;
bool equal = LHS == RHS;

Such code might be used as gtest assertions like EXPECT_EQ(LHS, RHS).
@kazu Do you think we should address this by providing an equality operator for the StringSet?
I was thinking of adding this:

bool operator==(const StringSet &RHS) const {
  if (Base::size() != RHS.size())
    return false;

  // For StringSets we only need to check the keys.
  for (const auto &KeyValue : *this) {
    if (RHS.find(KeyValue.getKey()) == RHS.end())
      return false;
  }
  return true;
};

Do you think we should backport this to release/16.x, given that this could break downstream users and that llvm-16.0.0 is not released yet?

[steakhal]

Oh, I forgot to mention why this change breaks the equality operator of llvm::StringSet. It's because the StringMap::operator== will try to compare the value as well, which is of type std::nullopt_t and that has no equality comparison operator.
Previously, the enum class NoneType has a default one.

[steakhal]

Hm, it would be easier to use llvm::StringMap<decltype(std::monostate)> instead of std::nullopt_t, or some adhoc empty struct.

[MaskRay]

In D138539#4164313, @steakhal wrote:

Oh, I forgot to mention why this change breaks the equality operator of llvm::StringSet. It's because the StringMap::operator== will try to compare the value as well, which is of type std::nullopt_t and that has no equality comparison operator.
Previously, the enum class NoneType has a default one.

Since std::unordered_set and counterparts like absl::flat_hash_set provide operator==, I think providing StringMap::operator== is fine. I don't think whether the operation is commonly used, though.

bolt/lib/Profile/DataAggregator.cpp

DataAggregator::writeAggregatedFile(StringRef OutputFilename) const {
 
   uint64_t BranchValues = 0;
   uint64_t MemValues = 0;
 
   if (BAT)
     OutFile << "boltedcollection\n";
   if (opts::BasicAggregation) {
     OutFile << "no_lbr";
-    for (const StringMapEntry<NoneType> &Entry : EventNames)
+    for (const StringMapEntry<std::nullopt_t> &Entry : EventNames)
       OutFile << " " << Entry.getKey();
     OutFile << "\n";
 
     for (const StringMapEntry<FuncSampleData> &Func : NamesToSamples) {
       for (const SampleInfo &SI : Func.getValue().Data) {
         writeLocation(SI.Loc);
         OutFile << SI.Hits << "\n";
         ++BranchValues;

bolt/lib/Profile/YAMLProfileWriter.cpp

std::error_code YAMLProfileWriter::writeProfile(const RewriteInstance &RI) {
   BP.Header.FileName = std::string(BC.getFilename());
   Optional<StringRef> BuildID = BC.getFileBuildID();
   BP.Header.Id = BuildID ? std::string(*BuildID) : "<unknown>";
   BP.Header.Origin = std::string(RI.getProfileReader()->getReaderName());
 
   StringSet<> EventNames = RI.getProfileReader()->getEventNames();
   if (!EventNames.empty()) {
     std::string Sep;
-    for (const StringMapEntry<NoneType> &EventEntry : EventNames) {
+    for (const StringMapEntry<std::nullopt_t> &EventEntry : EventNames) {
       BP.Header.EventNames += Sep + EventEntry.first().str();
       Sep = ",";
     }
   }
 
   // Make sure the profile is consistent across all functions.
   uint16_t ProfileFlags = BinaryFunction::PF_NONE;
   for (const auto &BFI : Functions) {

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

 }
 
 namespace {
 class NameLookup {
   llvm::PointerIntPair<const NamedDecl *, 1, bool> Data;
 
 public:
   explicit NameLookup(const NamedDecl *ND) : Data(ND, false) {}
-  explicit NameLookup(llvm::NoneType) : Data(nullptr, true) {}
+  explicit NameLookup(std::nullopt_t) : Data(nullptr, true) {}
   explicit NameLookup(std::nullptr_t) : Data(nullptr, false) {}
   NameLookup() : NameLookup(nullptr) {}
 
   bool hasMultipleResolutions() const { return Data.getInt(); }
   const NamedDecl *getDecl() const {
     assert(!hasMultipleResolutions() && "Found multiple decls");
     return Data.getPointer();
   }
   operator bool() const { return !hasMultipleResolutions(); }

clang-tools-extra/clangd/support/ThreadsafeFS.h

 /// different contexts, so either ThreadsafeFS::view or the returned FS may
 /// contain this logic.
 class ThreadsafeFS {
 public:
   virtual ~ThreadsafeFS() = default;
 
   /// Obtain a vfs::FileSystem with an arbitrary initial working directory.
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>
-  view(llvm::NoneType CWD) const {
+  view(std::nullopt_t CWD) const {
     return viewImpl();
   }
 
   /// Obtain a vfs::FileSystem with a specified working directory.
   /// If the working directory can't be set (e.g. doesn't exist), logs and
   /// returns the FS anyway.
   llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> view(PathRef CWD) const;
 

clang/include/clang/Analysis/Analyses/PostOrderCFGView.h

public:
     // value_type type.
     struct iterator { using value_type = const CFGBlock *; };
 
     CFGBlockSet() = default;
     CFGBlockSet(const CFG *G) : VisitedBlockIDs(G->getNumBlockIDs(), false) {}
 
     /// Set the bit associated with a particular CFGBlock.
     /// This is the important method for the SetType template parameter.
-    std::pair<llvm::NoneType, bool> insert(const CFGBlock *Block) {
+    std::pair<std::nullopt_t, bool> insert(const CFGBlock *Block) {
       // Note that insert() is called by po_iterator, which doesn't check to
       // make sure that Block is non-null.  Moreover, the CFGBlock iterator will
       // occasionally hand out null pointers for pruned edges, so we catch those
       // here.
       if (!Block)
         return std::make_pair(None, false); // if an edge is trivially false.
       if (VisitedBlockIDs.test(Block->getBlockID()))
         return std::make_pair(None, false);

clang/include/clang/Basic/DirectoryEntry.h

OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr(
       OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &&) = default;
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr(
       const OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &) = default;
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &
   operator=(OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &&) = default;
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &
   operator=(const OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &) = default;
 
-  OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr(llvm::NoneType) {}
+  OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr(std::nullopt_t) {}
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr(DirectoryEntryRef Ref)
       : Optional<DirectoryEntryRef>(Ref) {}
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr(Optional<DirectoryEntryRef> MaybeRef)
       : Optional<DirectoryEntryRef>(MaybeRef) {}
 
-  OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &operator=(llvm::NoneType) {
+  OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &
+  operator=(std::nullopt_t) {
     Optional<DirectoryEntryRef>::operator=(None);
     return *this;
   }
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &operator=(DirectoryEntryRef Ref) {
     Optional<DirectoryEntryRef>::operator=(Ref);
     return *this;
   }
   OptionalDirectoryEntryRefDegradesToDirectoryEntryPtr &

clang/include/clang/Basic/FileEntry.h

OptionalFileEntryRefDegradesToFileEntryPtr(
       OptionalFileEntryRefDegradesToFileEntryPtr &&) = default;
   OptionalFileEntryRefDegradesToFileEntryPtr(
       const OptionalFileEntryRefDegradesToFileEntryPtr &) = default;
   OptionalFileEntryRefDegradesToFileEntryPtr &
   operator=(OptionalFileEntryRefDegradesToFileEntryPtr &&) = default;
   OptionalFileEntryRefDegradesToFileEntryPtr &
   operator=(const OptionalFileEntryRefDegradesToFileEntryPtr &) = default;
 
-  OptionalFileEntryRefDegradesToFileEntryPtr(llvm::NoneType) {}
+  OptionalFileEntryRefDegradesToFileEntryPtr(std::nullopt_t) {}
   OptionalFileEntryRefDegradesToFileEntryPtr(FileEntryRef Ref)
       : Optional<FileEntryRef>(Ref) {}
   OptionalFileEntryRefDegradesToFileEntryPtr(Optional<FileEntryRef> MaybeRef)
       : Optional<FileEntryRef>(MaybeRef) {}
 
-  OptionalFileEntryRefDegradesToFileEntryPtr &operator=(llvm::NoneType) {
+  OptionalFileEntryRefDegradesToFileEntryPtr &operator=(std::nullopt_t) {
     Optional<FileEntryRef>::operator=(None);
     return *this;
   }
   OptionalFileEntryRefDegradesToFileEntryPtr &operator=(FileEntryRef Ref) {
     Optional<FileEntryRef>::operator=(Ref);
     return *this;
   }
   OptionalFileEntryRefDegradesToFileEntryPtr &

clang/include/clang/Sema/Template.h

public:
 
     void addOuterTemplateArguments(ArgList Args) {
       assert(!NumRetainedOuterLevels &&
              "substituted args outside retained args?");
       assert(getKind() == TemplateSubstitutionKind::Rewrite);
       TemplateArgumentLists.push_back({{}, Args});
     }
 
-    void addOuterTemplateArguments(llvm::NoneType) {
+    void addOuterTemplateArguments(std::nullopt_t) {
       assert(!NumRetainedOuterLevels &&
              "substituted args outside retained args?");
       TemplateArgumentLists.push_back({});
     }
 
     /// Replaces the current 'innermost' level with the provided argument list.
     /// This is useful for type deduction cases where we need to get the entire
     /// list from the AST, but then add the deduced innermost list.

clang/lib/AST/ExprConstant.cpp

class BufferToAPValueConverter {
 
   BufferToAPValueConverter(EvalInfo &Info, const BitCastBuffer &Buffer,
                            const CastExpr *BCE)
       : Info(Info), Buffer(Buffer), BCE(BCE) {}
 
   // Emit an unsupported bit_cast type error. Sema refuses to build a bit_cast
   // with an invalid type, so anything left is a deficiency on our part (FIXME).
   // Ideally this will be unreachable.
-  llvm::NoneType unsupportedType(QualType Ty) {
+  std::nullopt_t unsupportedType(QualType Ty) {
     Info.FFDiag(BCE->getBeginLoc(),
                 diag::note_constexpr_bit_cast_unsupported_type)
         << Ty;
     return None;
   }
 
-  llvm::NoneType unrepresentableValue(QualType Ty, const APSInt &Val) {
+  std::nullopt_t unrepresentableValue(QualType Ty, const APSInt &Val) {
     Info.FFDiag(BCE->getBeginLoc(),
                 diag::note_constexpr_bit_cast_unrepresentable_value)
         << Ty << toString(Val, /*Radix=*/10);
     return None;
   }
 
   Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
                           const EnumType *EnumSugar = nullptr) {

clang/lib/Tooling/Transformer/Parsing.cpp

 }
 
 static StringRef consumeWhitespace(StringRef S) {
   return S.drop_while([](char c) { return isASCII(c) && isWhitespace(c); });
 }
 
 // Parses a single expected character \c c from \c State, skipping preceding
 // whitespace.  Error if the expected character isn't found.
-static ExpectedProgress<llvm::NoneType> parseChar(char c, ParseState State) {
+static ExpectedProgress<std::nullopt_t> parseChar(char c, ParseState State) {
   State.Input = consumeWhitespace(State.Input);
   if (State.Input.empty() || State.Input.front() != c)
     return makeParseError(State,
                           ("expected char not found: " + llvm::Twine(c)).str());
   return makeParseProgress(advance(State, 1), llvm::None);
 }
 
 // Parses an identitifer "token" -- handles preceding whitespace.

lldb/include/lldb/Utility/Timeout.h

private:
   template <typename Rep2, typename Ratio2>
   using EnableIf = std::enable_if<
       std::is_convertible<std::chrono::duration<Rep2, Ratio2>,
                           std::chrono::duration<int64_t, Ratio>>::value>;
 
   using Base = llvm::Optional<Dur<Ratio>>;
 
 public:
-  Timeout(llvm::NoneType none) : Base(none) {}
+  Timeout(std::nullopt_t none) : Base(none) {}
 
   template <typename Ratio2,
             typename = typename EnableIf<int64_t, Ratio2>::type>
   Timeout(const Timeout<Ratio2> &other)
       : Base(other ? Base(Dur<Ratio>(*other)) : llvm::None) {}
 
   template <typename Rep2, typename Ratio2,
             typename = typename EnableIf<Rep2, Ratio2>::type>

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

enum IsolatedASTKind {
     /// often conflict with the templates we generate from debug information,
     /// so we put these types in their own AST.
     CppModules
   };
 
   /// Alias for requesting the default scratch TypeSystemClang in GetForTarget.
   // This isn't constexpr as gtest/llvm::Optional comparison logic is trying
   // to get the address of this for pretty-printing.
-  static const llvm::NoneType DefaultAST;
+  static const std::nullopt_t DefaultAST;
 
   /// Infers the appropriate sub-AST from Clang's LangOptions.
   static llvm::Optional<IsolatedASTKind>
   InferIsolatedASTKindFromLangOpts(const clang::LangOptions &l) {
     // If modules are activated we want the dedicated C++ module AST.
     // See IsolatedASTKind::CppModules for more info.
     if (l.Modules)
       return IsolatedASTKind::CppModules;

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

public:
   }
 
   /// The ExternalASTSource that performs lookups and completes types.
   std::unique_ptr<ClangASTSource> m_scratch_ast_source_up;
 };
 } // namespace
 
 char ScratchTypeSystemClang::ID;
-const llvm::NoneType ScratchTypeSystemClang::DefaultAST = llvm::None;
+const std::nullopt_t ScratchTypeSystemClang::DefaultAST = llvm::None;
 
 ScratchTypeSystemClang::ScratchTypeSystemClang(Target &target,
                                                llvm::Triple triple)
     : TypeSystemClang("scratch ASTContext", triple), m_triple(triple),
       m_target_wp(target.shared_from_this()),
       m_persistent_variables(
           new ClangPersistentVariables(target.shared_from_this())) {
   m_scratch_ast_source_up = CreateASTSource();

llvm/include/llvm/ADT/ArrayRef.h

namespace llvm {
   public:
     /// @name Constructors
     /// @{
 
     /// Construct an empty ArrayRef.
     /*implicit*/ ArrayRef() = default;
 
     /// Construct an empty ArrayRef from None.
-    /*implicit*/ ArrayRef(NoneType) {}
+    /*implicit*/ ArrayRef(std::nullopt_t) {}
 
     /// Construct an ArrayRef from a single element.
     /*implicit*/ ArrayRef(const T &OneElt)
       : Data(&OneElt), Length(1) {}
 
     /// Construct an ArrayRef from a pointer and length.
     /*implicit*/ ArrayRef(const T *data, size_t length)
       : Data(data), Length(length) {}
public:
     using const_reverse_iterator = std::reverse_iterator<const_iterator>;
     using size_type = size_t;
     using difference_type = ptrdiff_t;
 
     /// Construct an empty MutableArrayRef.
     /*implicit*/ MutableArrayRef() = default;
 
     /// Construct an empty MutableArrayRef from None.
-    /*implicit*/ MutableArrayRef(NoneType) : ArrayRef<T>() {}
+    /*implicit*/ MutableArrayRef(std::nullopt_t) : ArrayRef<T>() {}
 
     /// Construct a MutableArrayRef from a single element.
     /*implicit*/ MutableArrayRef(T &OneElt) : ArrayRef<T>(OneElt) {}
 
     /// Construct a MutableArrayRef from a pointer and length.
     /*implicit*/ MutableArrayRef(T *data, size_t length)
       : ArrayRef<T>(data, length) {}
 

llvm/include/llvm/ADT/Optional.h

 
 template <typename T> class Optional {
   optional_detail::OptionalStorage<T> Storage;
 
 public:
   using value_type = T;
 
   constexpr Optional() = default;
-  constexpr Optional(NoneType) {}
+  constexpr Optional(std::nullopt_t) {}
 
   constexpr Optional(const T &y) : Storage(std::in_place, y) {}
   constexpr Optional(const Optional &O) = default;
 
   constexpr Optional(T &&y) : Storage(std::in_place, std::move(y)) {}
   constexpr Optional(Optional &&O) = default;
 
   template <typename... ArgTypes>

 }
 
 template <typename T, typename U>
 constexpr bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
   return !(X < Y);
 }
 
 template <typename T>
-constexpr bool operator==(const Optional<T> &X, NoneType) {
+constexpr bool operator==(const Optional<T> &X, std::nullopt_t) {
   return !X;
 }
 
 template <typename T>
-constexpr bool operator==(NoneType, const Optional<T> &X) {
+constexpr bool operator==(std::nullopt_t, const Optional<T> &X) {
   return X == None;
 }
 
 template <typename T>
-constexpr bool operator!=(const Optional<T> &X, NoneType) {
+constexpr bool operator!=(const Optional<T> &X, std::nullopt_t) {
   return !(X == None);
 }
 
 template <typename T>
-constexpr bool operator!=(NoneType, const Optional<T> &X) {
+constexpr bool operator!=(std::nullopt_t, const Optional<T> &X) {
   return X != None;
 }
 
-template <typename T> constexpr bool operator<(const Optional<T> &, NoneType) {
+template <typename T>
+constexpr bool operator<(const Optional<T> &, std::nullopt_t) {
   return false;
 }
 
-template <typename T> constexpr bool operator<(NoneType, const Optional<T> &X) {
+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, NoneType) {
+constexpr bool operator<=(const Optional<T> &X, std::nullopt_t) {
   return !(None < X);
 }
 
 template <typename T>
-constexpr bool operator<=(NoneType, const Optional<T> &X) {
+constexpr bool operator<=(std::nullopt_t, const Optional<T> &X) {
   return !(X < None);
 }
 
-template <typename T> constexpr bool operator>(const Optional<T> &X, NoneType) {
+template <typename T>
+constexpr bool operator>(const Optional<T> &X, std::nullopt_t) {
   return None < X;
 }
 
-template <typename T> constexpr bool operator>(NoneType, const Optional<T> &X) {
+template <typename T>
+constexpr bool operator>(std::nullopt_t, const Optional<T> &X) {
   return X < None;
 }
 
 template <typename T>
-constexpr bool operator>=(const Optional<T> &X, NoneType) {
+constexpr bool operator>=(const Optional<T> &X, std::nullopt_t) {
   return None <= X;
 }
 
 template <typename T>
-constexpr bool operator>=(NoneType, const Optional<T> &X) {
+constexpr bool operator>=(std::nullopt_t, const Optional<T> &X) {
   return X <= None;
 }
 
 template <typename T>
 constexpr bool operator==(const Optional<T> &X, const T &Y) {
   return X && *X == Y;
 }
 
constexpr bool operator>=(const Optional<T> &X, const T &Y) {
   return !(X < Y);
 }
 
 template <typename T>
 constexpr bool operator>=(const T &X, const Optional<T> &Y) {
   return !(X < Y);
 }
 
-raw_ostream &operator<<(raw_ostream &OS, NoneType);
+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;
   return OS;
 }
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_OPTIONAL_H

llvm/include/llvm/ADT/StringMapEntry.h

public:
   StringMapEntryStorage(StringMapEntryStorage &e) = delete;
 
   const ValueTy &getValue() const { return second; }
   ValueTy &getValue() { return second; }
 
   void setValue(const ValueTy &V) { second = V; }
 };
 
-template <> class StringMapEntryStorage<NoneType> : public StringMapEntryBase {
+template <>
+class StringMapEntryStorage<std::nullopt_t> : public StringMapEntryBase {
 public:
-  explicit StringMapEntryStorage(size_t keyLength, NoneType = None)
+  explicit StringMapEntryStorage(size_t keyLength, std::nullopt_t = None)
       : StringMapEntryBase(keyLength) {}
   StringMapEntryStorage(StringMapEntryStorage &entry) = delete;
 
-  NoneType getValue() const { return None; }
+  std::nullopt_t getValue() const { return None; }
 };
 
 /// 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/StringSet.h

 #define LLVM_ADT_STRINGSET_H
 
 #include "llvm/ADT/StringMap.h"
 
 namespace llvm {
 
 /// StringSet - A wrapper for StringMap that provides set-like functionality.
 template <class AllocatorTy = MallocAllocator>
-class StringSet : public StringMap<NoneType, AllocatorTy> {
-  using Base = StringMap<NoneType, AllocatorTy>;
+class StringSet : public StringMap<std::nullopt_t, AllocatorTy> {
+  using Base = StringMap<std::nullopt_t, AllocatorTy>;
 
 public:
   StringSet() = default;
   StringSet(std::initializer_list<StringRef> initializer) {
     for (StringRef str : initializer)
       insert(str);
   }
   explicit StringSet(AllocatorTy a) : Base(a) {}

llvm/include/llvm/FuzzMutate/OpDescriptor.h

 
 private:
   PredT Pred;
   MakeT Make;
 
 public:
   /// Create a fully general source predicate.
   SourcePred(PredT Pred, MakeT Make) : Pred(Pred), Make(Make) {}
-  SourcePred(PredT Pred, NoneType) : Pred(Pred) {
+  SourcePred(PredT Pred, std::nullopt_t) : Pred(Pred) {
     Make = [Pred](ArrayRef<Value *> Cur, ArrayRef<Type *> BaseTypes) {
       // Default filter just calls Pred on each of the base types.
       std::vector<Constant *> Result;
       for (Type *T : BaseTypes) {
         Constant *V = UndefValue::get(T);
         if (Pred(Cur, V))
           makeConstantsWithType(T, Result);
       }

llvm/include/llvm/Support/SMLoc.h

 /// SMRange is implemented using a half-open range, as is the convention in C++.
 /// In the string "abc", the range [1,3) represents the substring "bc", and the
 /// range [2,2) represents an empty range between the characters "b" and "c".
 class SMRange {
 public:
   SMLoc Start, End;
 
   SMRange() = default;
-  SMRange(NoneType) {}
+  SMRange(std::nullopt_t) {}
   SMRange(SMLoc St, SMLoc En) : Start(St), End(En) {
     assert(Start.isValid() == End.isValid() &&
            "Start and End should either both be valid or both be invalid!");
   }
 
   bool isValid() const { return Start.isValid(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_SMLOC_H

llvm/lib/CodeGen/MIRParser/MILexer.cpp

 
 /// This class provides a way to iterate and get characters from the source
 /// string.
 class Cursor {
   const char *Ptr = nullptr;
   const char *End = nullptr;
 
 public:
-  Cursor(NoneType) {}
+  Cursor(std::nullopt_t) {}
 
   explicit Cursor(StringRef Str) {
     Ptr = Str.data();
     End = Ptr + Str.size();
   }
 
   bool isEOF() const { return Ptr == End; }
 

llvm/lib/Support/Optional.cpp

 //===- Optional.cpp - Optional values ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/raw_ostream.h"
 
-llvm::raw_ostream &llvm::operator<<(raw_ostream &OS, NoneType) {
+llvm::raw_ostream &llvm::operator<<(raw_ostream &OS, std::nullopt_t) {
   return OS << "None";
 }

mlir/include/mlir/IR/OpDefinition.h

 /// shouldn't be attributed to "not present".
 class OptionalParseResult {
 public:
   OptionalParseResult() = default;
   OptionalParseResult(LogicalResult result) : impl(result) {}
   OptionalParseResult(ParseResult result) : impl(result) {}
   OptionalParseResult(const InFlightDiagnostic &)
       : OptionalParseResult(failure()) {}
-  OptionalParseResult(llvm::NoneType) : impl(llvm::None) {}
+  OptionalParseResult(std::nullopt_t) : impl(llvm::None) {}
 
   /// Returns true if we contain a valid ParseResult value.
   bool has_value() const { return impl.has_value(); }
 
   /// Access the internal ParseResult value.
   ParseResult value() const { return impl.value(); }
   ParseResult operator*() const { return value(); }
 

mlir/include/mlir/IR/OperationSupport.h

 public:
   using iterator = SmallVectorImpl<NamedAttribute>::iterator;
   using const_iterator = SmallVectorImpl<NamedAttribute>::const_iterator;
   using reference = NamedAttribute &;
   using const_reference = const NamedAttribute &;
   using size_type = size_t;
 
   NamedAttrList() : dictionarySorted({}, true) {}
-  NamedAttrList(llvm::NoneType none) : NamedAttrList() {}
+  NamedAttrList(std::nullopt_t none) : NamedAttrList() {}
   NamedAttrList(ArrayRef<NamedAttribute> attributes);
   NamedAttrList(DictionaryAttr attributes);
   NamedAttrList(const_iterator inStart, const_iterator inEnd);
 
   template <typename Container>
   NamedAttrList(const Container &vec)
       : NamedAttrList(ArrayRef<NamedAttribute>(vec)) {}
 

 // OpPrintingFlags
 //===----------------------------------------------------------------------===//
 
 /// Set of flags used to control the behavior of the various IR print methods
 /// (e.g. Operation::Print).
 class OpPrintingFlags {
 public:
   OpPrintingFlags();
-  OpPrintingFlags(llvm::NoneType) : OpPrintingFlags() {}
+  OpPrintingFlags(std::nullopt_t) : OpPrintingFlags() {}
 
   /// Enables the elision of large elements attributes by printing a lexically
   /// valid but otherwise meaningless form instead of the element data. The
   /// `largeElementLimit` is used to configure what is considered to be a
   /// "large" ElementsAttr by providing an upper limit to the number of
   /// elements.
   OpPrintingFlags &elideLargeElementsAttrs(int64_t largeElementLimit = 16);
 

mlir/include/mlir/Support/Timing.h

 /// is guaranteed to be reproduced by later interning of the same string. The
 /// `TimingManager` uses this mechanism to provide timers with an opaque id
 /// even when the user of the API merely provided a string as identification
 /// (instead of a pass for example).
 ///
 /// This is a POD type with pointer size, so it should be passed around by
 /// value. The underlying data is owned by the `TimingManager`.
 class TimingIdentifier {
-  using EntryType = llvm::StringMapEntry<llvm::NoneType>;
+  using EntryType = llvm::StringMapEntry<std::nullopt_t>;
 
 public:
   TimingIdentifier(const TimingIdentifier &) = default;
   TimingIdentifier &operator=(const TimingIdentifier &other) = default;
 
   /// Return an identifier for the specified string.
   static TimingIdentifier get(StringRef str, TimingManager &tm);
 

mlir/lib/Support/Timing.cpp

 class TimingManagerImpl {
 public:
   // Identifier allocator, map, and mutex for thread safety.
   llvm::BumpPtrAllocator identifierAllocator;
   llvm::StringSet<llvm::BumpPtrAllocator &> identifiers;
   llvm::sys::SmartRWMutex<true> identifierMutex;
 
   /// A thread local cache of identifiers to reduce lock contention.
-  ThreadLocalCache<llvm::StringMap<llvm::StringMapEntry<llvm::NoneType> *>>
+  ThreadLocalCache<llvm::StringMap<llvm::StringMapEntry<std::nullopt_t> *>>
       localIdentifierCache;
 
   TimingManagerImpl() : identifiers(identifierAllocator) {}
 };
 } // namespace detail
 } // namespace mlir
 
 TimingManager::TimingManager() : impl(std::make_unique<TimingManagerImpl>()) {}