Use None consistently (NFC)

[kazu]

Summary

This patch replaces NoneType() and NoneType::None with None in
preparation for migration from llvm::Optional to std::optional.

In the std::optional world, we are not guranteed to be able to
default-construct std::nullopt_t or peek what's inside it, so neither
NoneType() nor NoneType::None has a corresponding expression in the
std::optional world.

Once we consistently use None, we should even be able to replace the
contents of llvm/include/llvm/ADT/None.h with something like:

using NoneType = std::nullopt_t;
inline constexpr std::nullopt_t None = std::nullopt;

to ease the migration from llvm::Optional to std::optional.

[MaskRay]

LGTM. enum class NoneType { None = 1 }; is from 0cd22f9540c0591132ec991c51103cf800cf4e24 (2017) for MSVC workaround. I assume it is no longer needed..

[ayermolo]

Is there an a RFC for this or something?

[tschuett]

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

bolt/include/bolt/Core/BinaryContext.h

public:
 
   StringRef getFilename() const { return Filename; }
   void setFilename(StringRef Name) { Filename = std::string(Name); }
 
   Optional<StringRef> getFileBuildID() const {
     if (FileBuildID)
       return StringRef(*FileBuildID);
 
-    return NoneType();
+    return None;
   }
   void setFileBuildID(StringRef ID) { FileBuildID = std::string(ID); }
 
   bool hasSymbolsWithFileName() const { return HasSymbolsWithFileName; }
   void setHasSymbolsWithFileName(bool Value) { HasSymbolsWithFileName = true; }
 
   /// Return true if relocations against symbol with a given name
   /// must be created.

bolt/include/bolt/Core/BinaryFunction.h

Optional<StringRef> forEachName(FType Callback) const {
     for (MCSymbol *Symbol : Symbols)
       if (Callback(Symbol->getName()))
         return Symbol->getName();
 
     for (const std::string &Name : Aliases)
       if (Callback(StringRef(Name)))
         return StringRef(Name);
 
-    return NoneType();
+    return None;
   }
 
   /// Check if (possibly one out of many) function name matches the given
   /// string. Use this member function instead of direct name comparison.
   bool hasName(const std::string &FunctionName) const {
     auto Res =
         forEachName([&](StringRef Name) { return Name == FunctionName; });
     return Res.has_value();
void addRelocation(uint64_t Address, MCSymbol *Symbol, uint64_t RelType,
     }
 
     return addRelocationX86(Offset, Symbol, RelType, Addend, Value);
   }
 
   /// Return the name of the section this function originated from.
   Optional<StringRef> getOriginSectionName() const {
     if (!OriginSection)
-      return NoneType();
+      return None;
     return OriginSection->getName();
   }
 
   /// Return internal section name for this function.
   SmallString<32>
   getCodeSectionName(const FragmentNum Fragment = FragmentNum::main()) const {
     if (Fragment == FragmentNum::main())
       return SmallString<32>(CodeSectionName);

bolt/include/bolt/Core/MCPlusBuilder.h

void setAnnotationOpValue(MCInst &Inst, unsigned Index, int64_t Value,
 
     AnnotationInst->addOperand(MCOperand::createImm(AnnotationValue));
   }
 
   Optional<int64_t> getAnnotationOpValue(const MCInst &Inst,
                                          unsigned Index) const {
     const MCInst *AnnotationInst = getAnnotationInst(Inst);
     if (!AnnotationInst)
-      return NoneType();
+      return None;
 
     for (int I = AnnotationInst->getNumOperands() - 1; I >= 0; --I) {
       int64_t ImmValue = AnnotationInst->getOperand(I).getImm();
       if (extractAnnotationIndex(ImmValue) == Index) {
         return extractAnnotationValue(ImmValue);
       }
     }
 
-    return NoneType();
+    return None;
   }
 
 protected:
   const MCInstrAnalysis *Analysis;
   const MCInstrInfo *Info;
   const MCRegisterInfo *RegInfo;
 
   /// Map annotation name into an annotation index.
virtual bool createEHLabel(MCInst &Inst, const MCSymbol *Label,
     return true;
   }
 
   /// Return annotation index matching the \p Name.
   Optional<unsigned> getAnnotationIndex(StringRef Name) const {
     auto AI = AnnotationNameIndexMap.find(Name);
     if (AI != AnnotationNameIndexMap.end())
       return AI->second;
-    return NoneType();
+    return None;
   }
 
   /// Return annotation index matching the \p Name. Create a new index if the
   /// \p Name wasn't registered previously.
   unsigned getOrCreateAnnotationIndex(StringRef Name) {
     auto AI = AnnotationNameIndexMap.find(Name);
     if (AI != AnnotationNameIndexMap.end())
       return AI->second;

bolt/lib/Core/BinaryContext.cpp

for (auto &KV : SegmentMapInfo) {
     const SegmentInfo &SegInfo = KV.second;
     if (alignDown(SegInfo.FileOffset, SegInfo.Alignment) == FileOffset) {
       // Use segment's aligned memory offset to calculate the base address.
       const uint64_t MemOffset = alignDown(SegInfo.Address, SegInfo.Alignment);
       return MMapAddress - MemOffset;
     }
   }
 
-  return NoneType();
+  return None;
 }
 
 ErrorOr<BinarySection &> BinaryContext::getSectionForAddress(uint64_t Address) {
   auto SI = AddressToSection.upper_bound(Address);
   if (SI != AddressToSection.begin()) {
     --SI;
     uint64_t UpperBound = SI->first + SI->second->getSize();
     if (!SI->second->getSize())

bolt/lib/Core/MCPlusBuilder.cpp

if (hasAnnotation(Inst, MCAnnotation::kTailCall))
     return true;
   if (getConditionalTailCall(Inst))
     return true;
   return false;
 }
 
 Optional<MCLandingPad> MCPlusBuilder::getEHInfo(const MCInst &Inst) const {
   if (!isCall(Inst))
-    return NoneType();
+    return None;
   Optional<int64_t> LPSym =
       getAnnotationOpValue(Inst, MCAnnotation::kEHLandingPad);
   if (!LPSym)
-    return NoneType();
+    return None;
   Optional<int64_t> Action =
       getAnnotationOpValue(Inst, MCAnnotation::kEHAction);
   if (!Action)
-    return NoneType();
+    return None;
 
   return std::make_pair(reinterpret_cast<const MCSymbol *>(*LPSym),
                         static_cast<uint64_t>(*Action));
 }
 
 void MCPlusBuilder::addEHInfo(MCInst &Inst, const MCLandingPad &LP) {
   if (isCall(Inst)) {
     assert(!getEHInfo(Inst));
bool MCPlusBuilder::unsetJumpTable(MCInst &Inst) {
   return true;
 }
 
 Optional<uint64_t>
 MCPlusBuilder::getConditionalTailCall(const MCInst &Inst) const {
   Optional<int64_t> Value =
       getAnnotationOpValue(Inst, MCAnnotation::kConditionalTailCall);
   if (!Value)
-    return NoneType();
+    return None;
   return static_cast<uint64_t>(*Value);
 }
 
 bool MCPlusBuilder::setConditionalTailCall(MCInst &Inst, uint64_t Dest) {
   if (!isConditionalBranch(Inst))
     return false;
 
   setAnnotationOpValue(Inst, MCAnnotation::kConditionalTailCall, Dest);
   return true;
 }
 
 bool MCPlusBuilder::unsetConditionalTailCall(MCInst &Inst) {
   if (!getConditionalTailCall(Inst))
     return false;
   removeAnnotation(Inst, MCAnnotation::kConditionalTailCall);
   return true;
 }
 
 Optional<uint32_t> MCPlusBuilder::getOffset(const MCInst &Inst) const {
   Optional<int64_t> Value = getAnnotationOpValue(Inst, MCAnnotation::kOffset);
   if (!Value)
-    return NoneType();
+    return None;
   return static_cast<uint32_t>(*Value);
 }
 
 uint32_t MCPlusBuilder::getOffsetWithDefault(const MCInst &Inst,
                                              uint32_t Default) const {
   if (Optional<uint32_t> Offset = getOffset(Inst))
     return *Offset;
   return Default;

bolt/lib/Profile/BoltAddressTranslation.cpp

BoltAddressTranslation::getFallthroughsInTrace(uint64_t FuncAddress,
   if (From >= To)
     return Res;
 
   From -= FuncAddress;
   To -= FuncAddress;
 
   auto Iter = Maps.find(FuncAddress);
   if (Iter == Maps.end())
-    return NoneType();
+    return None;
 
   const MapTy &Map = Iter->second;
   auto FromIter = Map.upper_bound(From);
   if (FromIter == Map.begin())
     return Res;
   // Skip instruction entries, to create fallthroughs we are only interested in
   // BB boundaries
   do {

bolt/lib/Profile/DataAggregator.cpp

 Optional<SmallVector<std::pair<uint64_t, uint64_t>, 16>>
 DataAggregator::getFallthroughsInTrace(BinaryFunction &BF,
                                        const LBREntry &FirstLBR,
                                        const LBREntry &SecondLBR,
                                        uint64_t Count) const {
   SmallVector<std::pair<uint64_t, uint64_t>, 16> Res;
 
   if (!recordTrace(BF, FirstLBR, SecondLBR, Count, &Res))
-    return NoneType();
+    return None;
 
   return Res;
 }
 
 bool DataAggregator::recordEntry(BinaryFunction &BF, uint64_t To, bool Mispred,
                                  uint64_t Count) const {
   if (To > BF.getSize())
     return false;
void DataAggregator::processPreAggregated() {
   outs() << "\n";
 }
 
 Optional<int32_t> DataAggregator::parseCommExecEvent() {
   size_t LineEnd = ParsingBuf.find_first_of("\n");
   if (LineEnd == StringRef::npos) {
     reportError("expected rest of line");
     Diag << "Found: " << ParsingBuf << "\n";
-    return NoneType();
+    return None;
   }
   StringRef Line = ParsingBuf.substr(0, LineEnd);
 
   size_t Pos = Line.find("PERF_RECORD_COMM exec");
   if (Pos == StringRef::npos)
-    return NoneType();
+    return None;
   Line = Line.drop_front(Pos);
 
   // Line:
   //  PERF_RECORD_COMM exec: <name>:<pid>/<tid>"
   StringRef PIDStr = Line.rsplit(':').second.split('/').first;
   int32_t PID;
   if (PIDStr.getAsInteger(10, PID)) {
     reportError("expected PID");
     Diag << "Found: " << PIDStr << "in '" << Line << "'\n";
-    return NoneType();
+    return None;
   }
 
   return PID;
 }
 
 namespace {
 Optional<uint64_t> parsePerfTime(const StringRef TimeStr) {
   const StringRef SecTimeStr = TimeStr.split('.').first;
   const StringRef USecTimeStr = TimeStr.split('.').second;
   uint64_t SecTime;
   uint64_t USecTime;
   if (SecTimeStr.getAsInteger(10, SecTime) ||
       USecTimeStr.getAsInteger(10, USecTime))
-    return NoneType();
+    return None;
   return SecTime * 1000000ULL + USecTime;
 }
 }
 
 Optional<DataAggregator::ForkInfo> DataAggregator::parseForkEvent() {
   while (checkAndConsumeFS()) {
   }
 
   size_t LineEnd = ParsingBuf.find_first_of("\n");
   if (LineEnd == StringRef::npos) {
     reportError("expected rest of line");
     Diag << "Found: " << ParsingBuf << "\n";
-    return NoneType();
+    return None;
   }
   StringRef Line = ParsingBuf.substr(0, LineEnd);
 
   size_t Pos = Line.find("PERF_RECORD_FORK");
   if (Pos == StringRef::npos) {
     consumeRestOfLine();
-    return NoneType();
+    return None;
   }
 
   ForkInfo FI;
 
   const StringRef TimeStr =
       Line.substr(0, Pos).rsplit(':').first.rsplit(FieldSeparator).second;
   if (Optional<uint64_t> TimeRes = parsePerfTime(TimeStr)) {
     FI.Time = *TimeRes;
   }
 
   Line = Line.drop_front(Pos);
 
   // Line:
   //  PERF_RECORD_FORK(<child_pid>:<child_tid>):(<parent_pid>:<parent_tid>)
   const StringRef ChildPIDStr = Line.split('(').second.split(':').first;
   if (ChildPIDStr.getAsInteger(10, FI.ChildPID)) {
     reportError("expected PID");
     Diag << "Found: " << ChildPIDStr << "in '" << Line << "'\n";
-    return NoneType();
+    return None;
   }
 
   const StringRef ParentPIDStr = Line.rsplit('(').second.split(':').first;
   if (ParentPIDStr.getAsInteger(10, FI.ParentPID)) {
     reportError("expected PID");
     Diag << "Found: " << ParentPIDStr << "in '" << Line << "'\n";
-    return NoneType();
+    return None;
   }
 
   consumeRestOfLine();
 
   return FI;
 }
 
 ErrorOr<std::pair<StringRef, DataAggregator::MMapInfo>>

 
 Optional<std::pair<StringRef, StringRef>>
 DataAggregator::parseNameBuildIDPair() {
   while (checkAndConsumeFS()) {
   }
 
   ErrorOr<StringRef> BuildIDStr = parseString(FieldSeparator, true);
   if (std::error_code EC = BuildIDStr.getError())
-    return NoneType();
+    return None;
 
   // If one of the strings is missing, don't issue a parsing error, but still
   // do not return a value.
   consumeAllRemainingFS();
   if (checkNewLine())
-    return NoneType();
+    return None;
 
   ErrorOr<StringRef> NameStr = parseString(FieldSeparator, true);
   if (std::error_code EC = NameStr.getError())
-    return NoneType();
+    return None;
 
   consumeRestOfLine();
   return std::make_pair(NameStr.get(), BuildIDStr.get());
 }
 
 bool DataAggregator::hasAllBuildIDs() {
   const StringRef SavedParsingBuf = ParsingBuf;
 
while (hasData()) {
     }
   }
 
   ParsingBuf = SavedParsingBuf;
 
   if (!FileName.empty())
     return FileName;
 
-  return NoneType();
+  return None;
 }
 
 std::error_code
 DataAggregator::writeAggregatedFile(StringRef OutputFilename) const {
   std::error_code EC;
   raw_fd_ostream OutFile(OutputFilename, EC, sys::fs::OpenFlags::OF_None);
   if (EC)
     return EC;

bolt/lib/Profile/DataReader.cpp

 Optional<StringRef> getLTOCommonName(const StringRef Name) {
   size_t LTOSuffixPos = Name.find(".lto_priv.");
   if (LTOSuffixPos != StringRef::npos)
     return Name.substr(0, LTOSuffixPos + 10);
   if ((LTOSuffixPos = Name.find(".constprop.")) != StringRef::npos)
     return Name.substr(0, LTOSuffixPos + 11);
   if ((LTOSuffixPos = Name.find(".llvm.")) != StringRef::npos)
     return Name.substr(0, LTOSuffixPos + 6);
-  return NoneType();
+  return None;
 }
 
 namespace {
 
 /// Return true if the function name can change across compilations.
 bool hasVolatileName(const BinaryFunction &BF) {
   for (const StringRef &Name : BF.getNames())
     if (getLTOCommonName(Name))

bolt/lib/Rewrite/RewriteInstance.cpp

void RewriteInstance::parseBuildID() {
   if (Name.substr(0, 3) != "GNU")
     return;
 
   BuildID = Buf.slice(Offset, Offset + DescSz);
 }
 
 Optional<std::string> RewriteInstance::getPrintableBuildID() const {
   if (BuildID.empty())
-    return NoneType();
+    return None;
 
   std::string Str;
   raw_string_ostream OS(Str);
   const unsigned char *CharIter = BuildID.bytes_begin();
   while (CharIter != BuildID.bytes_end()) {
     if (*CharIter < 0x10)
       OS << "0";
     OS << Twine::utohexstr(*CharIter);
if (Function) {
       }
     }
 
     // Handle special symbols based on their name.
     Expected<StringRef> SymbolName = Symbol.getName(StringSection);
     assert(SymbolName && "cannot get symbol name");
 
     auto updateSymbolValue = [&](const StringRef Name,
-                                 Optional<uint64_t> Value = NoneType()) {
+                                 Optional<uint64_t> Value = None) {
       NewSymbol.st_value = Value ? *Value : getNewValueForSymbol(Name);
       NewSymbol.st_shndx = ELF::SHN_ABS;
       outs() << "BOLT-INFO: setting " << Name << " to 0x"
              << Twine::utohexstr(NewSymbol.st_value) << '\n';
     };
 
     if (opts::HotText &&
         (*SymbolName == "__hot_start" || *SymbolName == "__hot_end")) {

bolt/lib/Target/X86/X86MCPlusBuilder.cpp

createRelocation(const MCFixup &Fixup,
 
     assert(FKI.TargetOffset == 0 && "0-bit relocation offset expected");
     const uint64_t RelOffset = Fixup.getOffset();
 
     uint64_t RelType;
     if (FKI.Flags & MCFixupKindInfo::FKF_IsPCRel) {
       switch (FKI.TargetSize) {
       default:
-        return NoneType();
+        return None;
       case  8: RelType = ELF::R_X86_64_PC8; break;
       case 16: RelType = ELF::R_X86_64_PC16; break;
       case 32: RelType = ELF::R_X86_64_PC32; break;
       case 64: RelType = ELF::R_X86_64_PC64; break;
       }
     } else {
       switch (FKI.TargetSize) {
       default:
-        return NoneType();
+        return None;
       case  8: RelType = ELF::R_X86_64_8; break;
       case 16: RelType = ELF::R_X86_64_16; break;
       case 32: RelType = ELF::R_X86_64_32; break;
       case 64: RelType = ELF::R_X86_64_64; break;
       }
     }
 
     // Extract a symbol and an addend out of the fixup value expression.

bolt/lib/Utils/Utils.cpp

if (Output[I] == '\\')
       Output.erase(I++, 1);
 
   return Output;
 }
 
 Optional<uint8_t> readDWARFExpressionTargetReg(StringRef ExprBytes) {
   uint8_t Opcode = ExprBytes[0];
   if (Opcode == dwarf::DW_CFA_def_cfa_expression)
-    return NoneType();
+    return None;
   assert((Opcode == dwarf::DW_CFA_expression ||
           Opcode == dwarf::DW_CFA_val_expression) &&
          "invalid DWARF expression CFI");
   assert(ExprBytes.size() > 1 && "DWARF expression CFI is too short");
   const uint8_t *const Start =
       reinterpret_cast<const uint8_t *>(ExprBytes.drop_front(1).data());
   const uint8_t *const End =
       reinterpret_cast<const uint8_t *>(Start + ExprBytes.size() - 1);

clang/lib/Driver/ToolChains/HLSL.cpp

bool isLegalShaderModel(Triple &T) {
   return false;
 }
 
 llvm::Optional<std::string> tryParseProfile(StringRef Profile) {
   // [ps|vs|gs|hs|ds|cs|ms|as]_[major]_[minor]
   SmallVector<StringRef, 3> Parts;
   Profile.split(Parts, "_");
   if (Parts.size() != 3)
-    return NoneType();
+    return None;
 
   Triple::EnvironmentType Kind =
       StringSwitch<Triple::EnvironmentType>(Parts[0])
           .Case("ps", Triple::EnvironmentType::Pixel)
           .Case("vs", Triple::EnvironmentType::Vertex)
           .Case("gs", Triple::EnvironmentType::Geometry)
           .Case("hs", Triple::EnvironmentType::Hull)
           .Case("ds", Triple::EnvironmentType::Domain)
           .Case("cs", Triple::EnvironmentType::Compute)
           .Case("lib", Triple::EnvironmentType::Library)
           .Case("ms", Triple::EnvironmentType::Mesh)
           .Case("as", Triple::EnvironmentType::Amplification)
           .Default(Triple::EnvironmentType::UnknownEnvironment);
   if (Kind == Triple::EnvironmentType::UnknownEnvironment)
-    return NoneType();
+    return None;
 
   unsigned long long Major = 0;
   if (llvm::getAsUnsignedInteger(Parts[1], 0, Major))
-    return NoneType();
+    return None;
 
   unsigned long long Minor = 0;
   if (Parts[2] == "x" && Kind == Triple::EnvironmentType::Library)
     Minor = OfflineLibMinor;
   else if (llvm::getAsUnsignedInteger(Parts[2], 0, Minor))
-    return NoneType();
+    return None;
 
   // dxil-unknown-shadermodel-hull
   llvm::Triple T;
   T.setArch(Triple::ArchType::dxil);
   T.setOSName(Triple::getOSTypeName(Triple::OSType::ShaderModel).str() +
               VersionTuple(Major, Minor).getAsString());
   T.setEnvironment(Kind);
   if (isLegalShaderModel(T))
     return T.getTriple();
   else
-    return NoneType();
+    return None;
 }
 
 bool isLegalValidatorVersion(StringRef ValVersionStr, const Driver &D) {
   VersionTuple Version;
   if (Version.tryParse(ValVersionStr) || Version.getBuild() ||
       Version.getSubminor() || !Version.getMinor()) {
     D.Diag(diag::err_drv_invalid_format_dxil_validator_version)
         << ValVersionStr;

lldb/source/Plugins/ExpressionParser/Clang/CppModuleConfiguration.cpp

getTargetIncludePaths(const llvm::Triple &triple) {
   return paths;
 }
 
 /// Returns the include path matching the given pattern for the given file
 /// path (or None if the path doesn't match the pattern).
 static llvm::Optional<llvm::StringRef>
 guessIncludePath(llvm::StringRef path_to_file, llvm::StringRef pattern) {
   if (pattern.empty())
-    return llvm::NoneType();
+    return llvm::None;
   size_t pos = path_to_file.find(pattern);
   if (pos == llvm::StringRef::npos)
-    return llvm::NoneType();
+    return llvm::None;
 
   return path_to_file.substr(0, pos + pattern.size());
 }
 
 bool CppModuleConfiguration::analyzeFile(const FileSpec &f,
                                          const llvm::Triple &triple) {
   using namespace llvm::sys::path;
   // Convert to slashes to make following operations simpler.

llvm/include/llvm/Analysis/InlineAdvisor.h

public:
 
   /// NOTE pass name is annotated only when inline advisor constructor provides InlineContext.
   const char *getAnnotatedInlinePassName() const {
     return AnnotatedInlinePassName.c_str();
   }
 
 protected:
   InlineAdvisor(Module &M, FunctionAnalysisManager &FAM,
-                Optional<InlineContext> IC = NoneType::None);
+                Optional<InlineContext> IC = llvm::None);
   virtual std::unique_ptr<InlineAdvice> getAdviceImpl(CallBase &CB) = 0;
   virtual std::unique_ptr<InlineAdvice> getMandatoryAdvice(CallBase &CB,
                                                            bool Advice);
 
   Module &M;
   FunctionAnalysisManager &FAM;
   const Optional<InlineContext> IC;
   const std::string AnnotatedInlinePassName;

llvm/include/llvm/Analysis/ObjCARCAnalysisUtils.h

class ARCMDKindCache {
   llvm::Optional<unsigned> CopyOnEscapeMDKind;
 
   /// The Metadata Kind for clang.arc.no_objc_arc_exceptions metadata.
   llvm::Optional<unsigned> NoObjCARCExceptionsMDKind;
 
 public:
   void init(Module *Mod) {
     M = Mod;
-    ImpreciseReleaseMDKind = NoneType::None;
-    CopyOnEscapeMDKind = NoneType::None;
-    NoObjCARCExceptionsMDKind = NoneType::None;
+    ImpreciseReleaseMDKind = llvm::None;
+    CopyOnEscapeMDKind = llvm::None;
+    NoObjCARCExceptionsMDKind = llvm::None;
   }
 
   unsigned get(ARCMDKindID ID) {
     switch (ID) {
     case ARCMDKindID::ImpreciseRelease:
       if (!ImpreciseReleaseMDKind)
         ImpreciseReleaseMDKind =
             M->getContext().getMDKindID("clang.imprecise_release");

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   DebugVariable(const DbgVariableIntrinsic *DII);
 
   DebugVariable(const DILocalVariable *Var, Optional<FragmentInfo> FragmentInfo,
                 const DILocation *InlinedAt)
       : Variable(Var), Fragment(FragmentInfo), InlinedAt(InlinedAt) {}
 
   DebugVariable(const DILocalVariable *Var, const DIExpression *DIExpr,
                 const DILocation *InlinedAt)
-      : Variable(Var),
-        Fragment(DIExpr ? DIExpr->getFragmentInfo() : NoneType()),
+      : Variable(Var), Fragment(DIExpr ? DIExpr->getFragmentInfo() : None),
         InlinedAt(InlinedAt) {}
 
   const DILocalVariable *getVariable() const { return Variable; }
   Optional<FragmentInfo> getFragment() const { return Fragment; }
   const DILocation *getInlinedAt() const { return InlinedAt; }
 
   FragmentInfo getFragmentOrDefault() const {
     return Fragment.value_or(DefaultFragment);
public:
   }
 };
 
 template <> struct DenseMapInfo<DebugVariable> {
   using FragmentInfo = DIExpression::FragmentInfo;
 
   /// Empty key: no key should be generated that has no DILocalVariable.
   static inline DebugVariable getEmptyKey() {
-    return DebugVariable(nullptr, NoneType(), nullptr);
+    return DebugVariable(nullptr, None, nullptr);
   }
 
   /// Difference in tombstone is that the Optional is meaningful.
   static inline DebugVariable getTombstoneKey() {
     return DebugVariable(nullptr, {{0, 0}}, nullptr);
   }
 
   static unsigned getHashValue(const DebugVariable &D) {

llvm/lib/CodeGen/RemoveRedundantDebugValues.cpp

static bool reduceDbgValsForwardScan(MachineBasicBlock &MBB) {
 
   SmallVector<MachineInstr *, 8> DbgValsToBeRemoved;
   DenseMap<DebugVariable, std::pair<MachineOperand *, const DIExpression *>>
       VariableMap;
   const auto *TRI = MBB.getParent()->getSubtarget().getRegisterInfo();
 
   for (auto &MI : MBB) {
     if (MI.isDebugValue()) {
-      DebugVariable Var(MI.getDebugVariable(), NoneType(),
+      DebugVariable Var(MI.getDebugVariable(), None,
                         MI.getDebugLoc()->getInlinedAt());
       auto VMI = VariableMap.find(Var);
       // Just stop tracking this variable, until we cover DBG_VALUE_LIST.
       // 1  DBG_VALUE $rax, "x", DIExpression()
       // ...
       // 2  DBG_VALUE_LIST "x", DIExpression(...), $rax, $rbx
       // ...
       // 3  DBG_VALUE $rax, "x", DIExpression()

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

 /// Possible improvements:
 /// - Keep track of non-overlapping fragments.
 static bool removeRedundantDbgInstrsUsingForwardScan(BasicBlock *BB) {
   SmallVector<DbgValueInst *, 8> ToBeRemoved;
   DenseMap<DebugVariable, std::pair<SmallVector<Value *, 4>, DIExpression *>>
       VariableMap;
   for (auto &I : *BB) {
     if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(&I)) {
-      DebugVariable Key(DVI->getVariable(),
-                        NoneType(),
+      DebugVariable Key(DVI->getVariable(), None,
                         DVI->getDebugLoc()->getInlinedAt());
       auto VMI = VariableMap.find(Key);
       auto *DAI = dyn_cast<DbgAssignIntrinsic>(DVI);
       // A dbg.assign with no linked instructions can be treated like a
       // dbg.value (i.e. can be deleted).
       bool IsDbgValueKind = (!DAI || at::getAssignmentInsts(DAI).empty());
 
       // Update the map if we found a new value/expression describing the

 /// Possible improvements:
 /// - Keep track of non-overlapping fragments.
 static bool remomveUndefDbgAssignsFromEntryBlock(BasicBlock *BB) {
   assert(BB->isEntryBlock() && "expected entry block");
   SmallVector<DbgAssignIntrinsic *, 8> ToBeRemoved;
   DenseSet<DebugVariable> SeenDefForAggregate;
   // Returns the DebugVariable for DVI with no fragment info.
   auto GetAggregateVariable = [](DbgValueInst *DVI) {
-    return DebugVariable(DVI->getVariable(), NoneType(),
+    return DebugVariable(DVI->getVariable(), None,
                          DVI->getDebugLoc()->getInlinedAt());
   };
 
   // Remove undef dbg.assign intrinsics that are encountered before
   // any non-undef intrinsics from the entry block.
   for (auto &I : *BB) {
     DbgValueInst *DVI = dyn_cast<DbgValueInst>(&I);
     if (!DVI)

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCopyBytesTest.cpp

for (const dwarf::FrameEntry &Entry : EHFrame.entries()) {
       if (!CurFDE)
         continue;
       for (const CFIProgram::Instruction &Instr : CurFDE->cfis()) {
         if (Instr.Opcode != dwarf::DW_CFA_def_cfa_expression)
           continue;
         return Instr;
       }
     }
-    return NoneType();
+    return None;
   };
 
   std::unique_ptr<DWARFContext> Ctx = DWARFContext::create(E);
   const DWARFDebugFrame *EHFrame = cantFail(Ctx->getEHFrame());
   ASSERT_NE(nullptr, EHFrame);
   auto CfiInstr = FetchFirstCfaExpression(*EHFrame);
   ASSERT_TRUE(CfiInstr);
   DWARFExpression Expr = *(CfiInstr->Expression);

llvm/unittests/IR/MetadataTest.cpp

TEST_F(DebugVariableTest, DenseMap) {
 
   DILocation *InlinedLoc = DILocation::get(Context, 2, 7, Scope);
 
   DILocalVariable *VarA =
       DILocalVariable::get(Context, Scope, "A", File, 5, Type, 2, Flags, 8, nullptr);
   DILocalVariable *VarB =
       DILocalVariable::get(Context, Scope, "B", File, 7, Type, 3, Flags, 8, nullptr);
 
-  DebugVariable DebugVariableA(VarA, NoneType(), nullptr);
-  DebugVariable DebugVariableInlineA(VarA, NoneType(), InlinedLoc);
-  DebugVariable DebugVariableB(VarB, NoneType(), nullptr);
+  DebugVariable DebugVariableA(VarA, None, nullptr);
+  DebugVariable DebugVariableInlineA(VarA, None, InlinedLoc);
+  DebugVariable DebugVariableB(VarB, None, nullptr);
   DebugVariable DebugVariableFragB(VarB, {{16, 16}}, nullptr);
 
   DebugVariableMap.insert({DebugVariableA, 2});
   DebugVariableMap.insert({DebugVariableInlineA, 3});
   DebugVariableMap.insert({DebugVariableB, 6});
   DebugVariableMap.insert({DebugVariableFragB, 12});
 
   EXPECT_EQ(DebugVariableMap.count(DebugVariableA), 1u);

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

static ParseResult parseScheduleClause(
   case ClauseScheduleKind::Static:
   case ClauseScheduleKind::Dynamic:
   case ClauseScheduleKind::Guided:
     if (succeeded(parser.parseOptionalEqual())) {
       chunkSize = OpAsmParser::UnresolvedOperand{};
       if (parser.parseOperand(*chunkSize) || parser.parseColonType(chunkType))
         return failure();
     } else {
-      chunkSize = llvm::NoneType::None;
+      chunkSize = llvm::None;
     }
     break;
   case ClauseScheduleKind::Auto:
   case ClauseScheduleKind::Runtime:
-    chunkSize = llvm::NoneType::None;
+    chunkSize = llvm::None;
   }
 
   // If there is a comma, we have one or more modifiers..
   SmallVector<SmallString<12>> modifiers;
   while (succeeded(parser.parseOptionalComma())) {
     StringRef mod;
     if (parser.parseKeyword(&mod))
       return failure();