Return None instead of Optional<T>() (NFC)

[kazu]

Summary

This patch replaces:

return Optional<T>();

with:

return None;

to make the migration from llvm::Optional to std::optional easier.
Specifically, I can deprecate None (in my source tree, that is) to
identify all the instances of None that should be replaced with
std::nullopt.

Note that "return None" far outnumbers "return Optional<T>();". There
are more than 2000 instances of "return None" in our source tree.

All of the instances in this patch come from functions that return
Optional<T> except Archive::findSym and ASTNodeImporter::import, where
we return Expected<Optional<T>>. Note that we can construct
Expected<Optional<T>> from any parameter convertible to Optional<T>,
which None certainly is.

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

[MaskRay]

We have return llvm::None; and return None;. Shall we always prefer llvm::None?

[kazu]

Thanks for the review!

In D138464#3942626, @MaskRay wrote:

We have return llvm::None; and return None;. Shall we always prefer llvm::None?

Either one is OK (to me). I can deprecate None in my personal tree, and get a warning for both llvm::None and None.

clang/include/clang/AST/ASTImporterSharedState.h

if (LookupTable)
         LookupTable->remove(ND);
   }
 
   llvm::Optional<ASTImportError> getImportDeclErrorIfAny(Decl *ToD) const {
     auto Pos = ImportErrors.find(ToD);
     if (Pos != ImportErrors.end())
       return Pos->second;
     else
-      return Optional<ASTImportError>();
+      return None;
   }
 
   void setImportDeclError(Decl *To, ASTImportError Error) {
     ImportErrors[To] = Error;
   }
 
   bool isNewDecl(const Decl *ToD) const { return NewDecls.count(ToD); }
 
   void markAsNewDecl(Decl *ToD) { NewDecls.insert(ToD); }
 };
 
 } // namespace clang
 #endif // LLVM_CLANG_AST_ASTIMPORTERSHAREDSTATE_H

clang/lib/AST/ASTImporter.cpp

class ASTNodeImporter : public TypeVisitor<ASTNodeImporter, ExpectedType>,
     Expected<T> import(const T &From) {
       return Importer.Import(From);
     }
 
     // Import an Optional<T> by importing the contained T, if any.
     template<typename T>
     Expected<Optional<T>> import(Optional<T> From) {
       if (!From)
-        return Optional<T>();
+        return None;
       return import(*From);
     }
 
     ExplicitSpecifier importExplicitSpecifier(Error &Err,
                                               ExplicitSpecifier ESpec);
 
     // Wrapper for an overload set.
     template <typename ToDeclT> struct CallOverloadedCreateFun {

 }
 
 llvm::Optional<ASTImportError>
 ASTImporter::getImportDeclErrorIfAny(Decl *FromD) const {
   auto Pos = ImportDeclErrors.find(FromD);
   if (Pos != ImportDeclErrors.end())
     return Pos->second;
   else
-    return Optional<ASTImportError>();
+    return None;
 }
 
 void ASTImporter::setImportDeclError(Decl *From, ASTImportError Error) {
   auto InsertRes = ImportDeclErrors.insert({From, Error});
   (void)InsertRes;
   // Either we set the error for the first time, or we already had set one and
   // now we want to set the same error.
   assert(InsertRes.second || InsertRes.first->second.Error == Error.Error);

clang/lib/ASTMatchers/Dynamic/Parser.cpp

 }
 
 llvm::Optional<DynTypedMatcher>
 Parser::parseMatcherExpression(StringRef &Code, Sema *S,
                                const NamedValueMap *NamedValues,
                                Diagnostics *Error) {
   VariantValue Value;
   if (!parseExpression(Code, S, NamedValues, &Value, Error))
-    return llvm::Optional<DynTypedMatcher>();
+    return llvm::None;
   if (!Value.isMatcher()) {
     Error->addError(SourceRange(), Error->ET_ParserNotAMatcher);
-    return llvm::Optional<DynTypedMatcher>();
+    return llvm::None;
   }
   llvm::Optional<DynTypedMatcher> Result =
       Value.getMatcher().getSingleMatcher();
   if (!Result) {
     Error->addError(SourceRange(), Error->ET_ParserOverloadedType)
         << Value.getTypeAsString();
   }
   return Result;
 }
 
 } // namespace dynamic
 } // namespace ast_matchers
 } // namespace clang

clang/lib/ASTMatchers/Dynamic/VariantValue.cpp

 public:
   PolymorphicPayload(std::vector<DynTypedMatcher> MatchersIn)
       : Matchers(std::move(MatchersIn)) {}
 
   ~PolymorphicPayload() override {}
 
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
     if (Matchers.size() != 1)
-      return llvm::Optional<DynTypedMatcher>();
+      return llvm::None;
     return Matchers[0];
   }
 
   std::string getTypeAsString() const override {
     std::string Inner;
     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
       if (i != 0)
         Inner += "|";

 
 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
 public:
   VariadicOpPayload(DynTypedMatcher::VariadicOperator Op,
                     std::vector<VariantMatcher> Args)
       : Op(Op), Args(std::move(Args)) {}
 
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
-    return llvm::Optional<DynTypedMatcher>();
+    return llvm::None;
   }
 
   std::string getTypeAsString() const override {
     std::string Inner;
     for (size_t i = 0, e = Args.size(); i != e; ++i) {
       if (i != 0)
         Inner += "&";
       Inner += Args[i].getTypeAsString();

clang/lib/CodeGen/CodeGenAction.cpp

 
 Optional<FullSourceLoc>
 BackendConsumer::getFunctionSourceLocation(const Function &F) const {
   auto Hash = llvm::hash_value(F.getName());
   for (const auto &Pair : ManglingFullSourceLocs) {
     if (Pair.first == Hash)
       return Pair.second;
   }
-  return Optional<FullSourceLoc>();
+  return None;
 }
 
 void BackendConsumer::UnsupportedDiagHandler(
     const llvm::DiagnosticInfoUnsupported &D) {
   // We only support warnings or errors.
   assert(D.getSeverity() == llvm::DS_Error ||
          D.getSeverity() == llvm::DS_Warning);
 

clang/lib/Driver/ToolChains/AVR.cpp

if (MCU.Name == MCUName)
       return std::string(MCU.SubPath);
   return "";
 }
 
 llvm::Optional<StringRef> GetMCUFamilyName(StringRef MCUName) {
   for (const auto &MCU : MCUInfo)
     if (MCU.Name == MCUName)
       return Optional<StringRef>(MCU.Family);
-  return Optional<StringRef>();
+  return None;
 }
 
 llvm::Optional<unsigned> GetMCUSectionAddressData(StringRef MCUName) {
   for (const auto &MCU : MCUInfo)
     if (MCU.Name == MCUName && MCU.DataAddr > 0)
       return Optional<unsigned>(MCU.DataAddr);
-  return Optional<unsigned>();
+  return None;
 }
 
 const StringRef PossibleAVRLibcLocations[] = {
     "/avr",
     "/usr/avr",
     "/usr/lib/avr",
 };
 

clang/lib/Driver/ToolChains/Arch/CSKY.cpp

 llvm::Optional<llvm::StringRef>
 csky::getCSKYArchName(const Driver &D, const ArgList &Args,
                       const llvm::Triple &Triple) {
   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
     llvm::CSKY::ArchKind ArchKind = llvm::CSKY::parseArch(A->getValue());
 
     if (ArchKind == llvm::CSKY::ArchKind::INVALID) {
       D.Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
-      return llvm::Optional<llvm::StringRef>();
+      return llvm::None;
     }
     return llvm::Optional<llvm::StringRef>(A->getValue());
   }
 
   if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mcpu_EQ)) {
     llvm::CSKY::ArchKind ArchKind = llvm::CSKY::parseCPUArch(A->getValue());
     if (ArchKind == llvm::CSKY::ArchKind::INVALID) {
       D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args);
-      return llvm::Optional<llvm::StringRef>();
+      return llvm::None;
     }
     return llvm::Optional<llvm::StringRef>(llvm::CSKY::getArchName(ArchKind));
   }
 
   return llvm::Optional<llvm::StringRef>("ck810");
 }
 
 csky::FloatABI csky::getCSKYFloatABI(const Driver &D, const ArgList &Args) {

llvm/include/llvm/Analysis/TargetTransformInfoImpl.h

public:
   unsigned getCacheLineSize() const { return 0; }
 
   llvm::Optional<unsigned>
   getCacheSize(TargetTransformInfo::CacheLevel Level) const {
     switch (Level) {
     case TargetTransformInfo::CacheLevel::L1D:
       [[fallthrough]];
     case TargetTransformInfo::CacheLevel::L2D:
-      return llvm::Optional<unsigned>();
+      return llvm::None;
     }
     llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
   }
 
   llvm::Optional<unsigned>
   getCacheAssociativity(TargetTransformInfo::CacheLevel Level) const {
     switch (Level) {
     case TargetTransformInfo::CacheLevel::L1D:
       [[fallthrough]];
     case TargetTransformInfo::CacheLevel::L2D:
-      return llvm::Optional<unsigned>();
+      return llvm::None;
     }
 
     llvm_unreachable("Unknown TargetTransformInfo::CacheLevel");
   }
 
   unsigned getPrefetchDistance() const { return 0; }
   unsigned getMinPrefetchStride(unsigned NumMemAccesses,
                                 unsigned NumStridedMemAccesses,

llvm/lib/CodeGen/SelectOptimize.cpp

SelectOptimize::getSIset(const SelectGroups &SIGroups) {
   return SIset;
 }
 
 Optional<uint64_t> SelectOptimize::computeInstCost(const Instruction *I) {
   InstructionCost ICost =
       TTI->getInstructionCost(I, TargetTransformInfo::TCK_Latency);
   if (auto OC = ICost.getValue())
     return Optional<uint64_t>(*OC);
-  return Optional<uint64_t>();
+  return None;
 }
 
 ScaledNumber<uint64_t>
 SelectOptimize::getMispredictionCost(const SelectInst *SI,
                                      const Scaled64 CondCost) {
   uint64_t MispredictPenalty = TSchedModel.getMCSchedModel()->MispredictPenalty;
 
   // Account for the default misprediction rate when using a branch

llvm/lib/DebugInfo/PDB/DIA/DIADataStream.cpp

 }
 
 llvm::Optional<DIADataStream::RecordType>
 DIADataStream::getItemAtIndex(uint32_t Index) const {
   RecordType Record;
   DWORD RecordSize = 0;
   StreamData->Item(Index, 0, &RecordSize, nullptr);
   if (RecordSize == 0)
-    return llvm::Optional<RecordType>();
+    return llvm::None;
 
   Record.resize(RecordSize);
   if (S_OK != StreamData->Item(Index, RecordSize, &RecordSize, &Record[0]))
-    return llvm::Optional<RecordType>();
+    return llvm::None;
   return Record;
 }
 
 bool DIADataStream::getNext(RecordType &Record) {
   Record.clear();
   DWORD RecordSize = 0;
   ULONG CountFetched = 0;
   StreamData->Next(1, 0, &RecordSize, nullptr, &CountFetched);

llvm/lib/IR/BasicBlock.cpp

Optional<uint64_t> BasicBlock::getIrrLoopHeaderWeight() const {
   if (MDNode *MDIrrLoopHeader =
       TI->getMetadata(LLVMContext::MD_irr_loop)) {
     MDString *MDName = cast<MDString>(MDIrrLoopHeader->getOperand(0));
     if (MDName->getString().equals("loop_header_weight")) {
       auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
       return Optional<uint64_t>(CI->getValue().getZExtValue());
     }
   }
-  return Optional<uint64_t>();
+  return None;
 }
 
 BasicBlock::iterator llvm::skipDebugIntrinsics(BasicBlock::iterator It) {
   while (isa<DbgInfoIntrinsic>(It))
     ++It;
   return It;
 }
 

llvm/lib/LineEditor/LineEditor.cpp

 
 Optional<std::string> LineEditor::readLine() const {
   // Call el_gets to prompt the user and read the user's input.
   int LineLen = 0;
   const char *Line = ::el_gets(Data->EL, &LineLen);
 
   // Either of these may mean end-of-file.
   if (!Line || LineLen == 0)
-    return Optional<std::string>();
+    return None;
 
   // Strip any newlines off the end of the string.
   while (LineLen > 0 &&
          (Line[LineLen - 1] == '\n' || Line[LineLen - 1] == '\r'))
     --LineLen;
 
   HistEvent HE;
   if (LineLen > 0)
Optional<std::string> LineEditor::readLine() const {
   ::fprintf(Data->Out, "%s", Prompt.c_str());
 
   std::string Line;
   do {
     char Buf[64];
     char *Res = ::fgets(Buf, sizeof(Buf), Data->In);
     if (!Res) {
       if (Line.empty())
-        return Optional<std::string>();
+        return None;
       else
         return Line;
     }
     Line.append(Buf);
   } while (Line.empty() ||
            (Line[Line.size() - 1] != '\n' && Line[Line.size() - 1] != '\r'));
 
   while (!Line.empty() &&
          (Line[Line.size() - 1] == '\n' || Line[Line.size() - 1] == '\r'))
     Line.resize(Line.size() - 1);
 
   return Line;
 }
 
 #endif // HAVE_LIBEDIT

llvm/lib/MC/MCSubtargetInfo.cpp

 }
 
 void MCSubtargetInfo::initInstrItins(InstrItineraryData &InstrItins) const {
   InstrItins = InstrItineraryData(getSchedModel(), Stages, OperandCycles,
                                   ForwardingPaths);
 }
 
 Optional<unsigned> MCSubtargetInfo::getCacheSize(unsigned Level) const {
-  return Optional<unsigned>();
+  return None;
 }
 
 Optional<unsigned>
 MCSubtargetInfo::getCacheAssociativity(unsigned Level) const {
-  return Optional<unsigned>();
+  return None;
 }
 
 Optional<unsigned> MCSubtargetInfo::getCacheLineSize(unsigned Level) const {
-  return Optional<unsigned>();
+  return None;
 }
 
 unsigned MCSubtargetInfo::getPrefetchDistance() const {
   return 0;
 }
 
 unsigned MCSubtargetInfo::getMaxPrefetchIterationsAhead() const {
   return UINT_MAX;

llvm/lib/Object/Archive.cpp

for (; bs != es; ++bs) {
     StringRef SymName = bs->getName();
     if (SymName == name) {
       if (auto MemberOrErr = bs->getMember())
         return Child(*MemberOrErr);
       else
         return MemberOrErr.takeError();
     }
   }
-  return Optional<Child>();
+  return None;
 }
 
 // Returns true if archive file contains no member file.
 bool Archive::isEmpty() const {
   return Data.getBufferSize() == getArchiveMagicLen();
 }
 
 bool Archive::hasSymbolTable() const { return !SymbolTable.empty(); }

llvm/lib/Support/Z3Solver.cpp

public:
   Optional<bool> check() const override {
     Z3_lbool res = Z3_solver_check(Context.Context, Solver);
     if (res == Z3_L_TRUE)
       return true;
 
     if (res == Z3_L_FALSE)
       return false;
 
-    return Optional<bool>();
+    return None;
   }
 
   void push() override { return Z3_solver_push(Context.Context, Solver); }
 
   void pop(unsigned NumStates = 1) override {
     assert(Z3_solver_get_num_scopes(Context.Context, Solver) >= NumStates);
     return Z3_solver_pop(Context.Context, Solver, NumStates);
   }

llvm/lib/TableGen/Record.cpp

PrintFatalError(getLoc(), "Record `" + getName() +
       "' does not have a field named `" + FieldName + "'!\n");
   return S.value();
 }
 
 llvm::Optional<StringRef>
 Record::getValueAsOptionalString(StringRef FieldName) const {
   const RecordVal *R = getValue(FieldName);
   if (!R || !R->getValue())
-    return llvm::Optional<StringRef>();
+    return llvm::None;
   if (isa<UnsetInit>(R->getValue()))
-    return llvm::Optional<StringRef>();
+    return llvm::None;
 
   if (StringInit *SI = dyn_cast<StringInit>(R->getValue()))
     return SI->getValue();
 
   PrintFatalError(getLoc(),
                   "Record `" + getName() + "', ` field `" + FieldName +
                       "' exists but does not have a string initializer!");
 }

llvm/lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

Res = StringSwitch<std::pair<int, int>>(Suffix.lower())
               .Case(".q", {0, 128})
               .Default({-1, -1});
     break;
   default:
     llvm_unreachable("Unsupported RegKind");
   }
 
   if (Res == std::make_pair(-1, -1))
-    return Optional<std::pair<int, int>>();
+    return None;
 
   return Optional<std::pair<int, int>>(Res);
 }
 
 static bool isValidVectorKind(StringRef Suffix, RegKind VectorKind) {
   return parseVectorKind(Suffix, VectorKind).has_value();
 }
 

llvm/lib/Target/ARM/ARMISelDAGToDAG.cpp

void ARMDAGToDAGISel::SelectCMP_SWAP(SDNode *N) {
   CurDAG->RemoveDeadNode(N);
 }
 
 static Optional<std::pair<unsigned, unsigned>>
 getContiguousRangeOfSetBits(const APInt &A) {
   unsigned FirstOne = A.getBitWidth() - A.countLeadingZeros() - 1;
   unsigned LastOne = A.countTrailingZeros();
   if (A.countPopulation() != (FirstOne - LastOne + 1))
-    return Optional<std::pair<unsigned,unsigned>>();
+    return None;
   return std::make_pair(FirstOne, LastOne);
 }
 
 void ARMDAGToDAGISel::SelectCMPZ(SDNode *N, bool &SwitchEQNEToPLMI) {
   assert(N->getOpcode() == ARMISD::CMPZ);
   SwitchEQNEToPLMI = false;
 
   if (!Subtarget->isThumb())

llvm/lib/Target/PowerPC/PPCFastISel.cpp

switch (Pred) {
     // and ONE are tested through !lt, !gt and !eq, and these are true.
     case CmpInst::FCMP_UEQ:
     case CmpInst::FCMP_UGT:
     case CmpInst::FCMP_ULT:
     case CmpInst::FCMP_OGE:
     case CmpInst::FCMP_OLE:
     case CmpInst::FCMP_ONE:
     default:
-      return Optional<PPC::Predicate>();
+      return None;
 
     case CmpInst::FCMP_OEQ:
     case CmpInst::ICMP_EQ:
       return PPC::PRED_EQ;
 
     case CmpInst::FCMP_OGT:
     case CmpInst::ICMP_UGT:
     case CmpInst::ICMP_SGT:

llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.cpp

if (Type == "f64")
     return wasm::ValType::F64;
   if (Type == "v128" || Type == "i8x16" || Type == "i16x8" || Type == "i32x4" ||
       Type == "i64x2" || Type == "f32x4" || Type == "f64x2")
     return wasm::ValType::V128;
   if (Type == "funcref")
     return wasm::ValType::FUNCREF;
   if (Type == "externref")
     return wasm::ValType::EXTERNREF;
-  return Optional<wasm::ValType>();
+  return None;
 }
 
 WebAssembly::BlockType WebAssembly::parseBlockType(StringRef Type) {
   // Multivalue block types are handled separately in parseSignature
   return StringSwitch<WebAssembly::BlockType>(Type)
       .Case("i32", WebAssembly::BlockType::I32)
       .Case("i64", WebAssembly::BlockType::I64)
       .Case("f32", WebAssembly::BlockType::F32)

mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp

static Optional<Value> createContractArithOp(Location loc, Value x, Value y,
                                              vector::CombiningKind kind,
                                              PatternRewriter &rewriter,
                                              bool isInt) {
   using vector::CombiningKind;
   Value mul;
   if (isInt) {
     if (kind == CombiningKind::MINF || kind == CombiningKind::MAXF)
       // Only valid for floating point types.
-      return Optional<Value>();
+      return None;
     mul = rewriter.create<arith::MulIOp>(loc, x, y);
   } else {
     // Float case.
     if (kind == CombiningKind::AND || kind == CombiningKind::MINUI ||
         kind == CombiningKind::MINSI || kind == CombiningKind::MAXUI ||
         kind == CombiningKind::MAXSI || kind == CombiningKind::OR ||
         kind == CombiningKind::XOR)
       // Only valid for integer types.
-      return Optional<Value>();
+      return None;
     // Special case for fused multiply-add.
     if (acc && acc.getType().isa<VectorType>() && kind == CombiningKind::ADD) {
       return Optional<Value>(rewriter.create<vector::FMAOp>(loc, x, y, acc));
     }
     mul = rewriter.create<arith::MulFOp>(loc, x, y);
   }
   if (!acc)
     return Optional<Value>(mul);

mlir/lib/Dialect/Vector/Utils/VectorUtils.cpp

SmallVector<int64_t, 4> mlir::computeElementOffsetsFromVectorSliceOffsets(
   for (auto it : llvm::zip(vectorOffsets, sizes))
     result.push_back(std::get<0>(it) * std::get<1>(it));
   return result;
 }
 
 Optional<SmallVector<int64_t, 4>> mlir::shapeRatio(ArrayRef<int64_t> superShape,
                                                    ArrayRef<int64_t> subShape) {
   if (superShape.size() < subShape.size()) {
-    return Optional<SmallVector<int64_t, 4>>();
+    return None;
   }
 
   // Starting from the end, compute the integer divisors.
   std::vector<int64_t> result;
   result.reserve(superShape.size());
   for (auto [superSize, subSize] :
        llvm::zip(llvm::reverse(superShape), llvm::reverse(subShape))) {
     assert(superSize > 0 && "superSize must be > 0");