reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/ADT/APInt.h
   33 template <typename T> class Optional;
include/llvm/IR/Function.h
   54 template <typename T> class Optional;
tools/clang/include/clang/Basic/LLVM.h
   37   template<typename T> class Optional;

References

gen/lib/Target/AArch64/AArch64GenGICombiner.inc
   31 static Optional<uint64_t> getRuleIdxForIdentifier(StringRef RuleIdentifier) {
gen/tools/clang/include/clang/AST/Attrs.inc
  330     Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
 2289     Optional<BlockType> R = llvm::StringSwitch<Optional<BlockType>>(Val)
 3162     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
 3799     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
 4381     Optional<DiagnosticType> R = llvm::StringSwitch<Optional<DiagnosticType>>(Val)
 4613     Optional<Kind> R = llvm::StringSwitch<Optional<Kind>>(Val)
 6096     Optional<OptionType> R = llvm::StringSwitch<Optional<OptionType>>(Val)
 6139     Optional<LoopHintState> R = llvm::StringSwitch<Optional<LoopHintState>>(Val)
 6974     Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
 8379     Optional<AllocatorTypeTy> R = llvm::StringSwitch<Optional<AllocatorTypeTy>>(Val)
 8615     Optional<BranchStateTy> R = llvm::StringSwitch<Optional<BranchStateTy>>(Val)
 8796     Optional<MapTypeTy> R = llvm::StringSwitch<Optional<MapTypeTy>>(Val)
 8819     Optional<DevTypeTy> R = llvm::StringSwitch<Optional<DevTypeTy>>(Val)
 8847     static llvm::Optional<MapTypeTy>
 8856     static llvm::Optional<DevTypeTy> getDeviceType(const ValueDecl *VD) {
 8986     Optional<CtxSelectorSetType> R = llvm::StringSwitch<Optional<CtxSelectorSetType>>(Val)
 9009     Optional<ScoreType> R = llvm::StringSwitch<Optional<ScoreType>>(Val)
 9032     Optional<CtxSelectorType> R = llvm::StringSwitch<Optional<CtxSelectorType>>(Val)
10055     Optional<FamilyKind> R = llvm::StringSwitch<Optional<FamilyKind>>(Val)
11333     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
11519     Optional<PCSType> R = llvm::StringSwitch<Optional<PCSType>>(Val)
12245     Optional<InterruptType> R = llvm::StringSwitch<Optional<InterruptType>>(Val)
12737     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
13155     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
13857     Optional<ConsumedState> R = llvm::StringSwitch<Optional<ConsumedState>>(Val)
14373     Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
14936     Optional<VisibilityType> R = llvm::StringSwitch<Optional<VisibilityType>>(Val)
gen/tools/clang/include/clang/Parse/AttrSubMatchRulesParserStringSwitches.inc
    1 Optional<attr::SubjectMatchRule> defaultIsAttributeSubjectMatchSubRuleFor(StringRef, bool) {
    5 Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_function(StringRef Name, bool IsUnless) {
   14 Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_hasType(StringRef Name, bool IsUnless) {
   23 Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_record(StringRef Name, bool IsUnless) {
   32 Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_variable(StringRef Name, bool IsUnless) {
   44 Optional<attr::SubjectMatchRule> isAttributeSubjectMatchSubRuleFor_objc_method(StringRef Name, bool IsUnless) {
   53 std::pair<Optional<attr::SubjectMatchRule>, Optional<attr::SubjectMatchRule> (*)(StringRef, bool)> isAttributeSubjectMatchRule(StringRef Name) {
   53 std::pair<Optional<attr::SubjectMatchRule>, Optional<attr::SubjectMatchRule> (*)(StringRef, bool)> isAttributeSubjectMatchRule(StringRef Name) {
include/llvm/ADT/APInt.h
 2221 Optional<APInt> SolveQuadraticEquationWrap(APInt A, APInt B, APInt C,
 2226 Optional<unsigned> GetMostSignificantDifferentBit(const APInt &A,
include/llvm/ADT/BreadthFirstIterator.h
   56   using QueueElement = std::pair<NodeRef, Optional<ChildItTy>>;
   60   std::queue<Optional<QueueElement>> VisitQueue;
   78     Optional<QueueElement> Head = VisitQueue.front();
   81     Optional<ChildItTy> &ChildIt = H.second;
include/llvm/ADT/DepthFirstIterator.h
   95   using StackElement = std::pair<NodeRef, Optional<ChildItTy>>;
  122       Optional<ChildItTy> &Opt = VisitStack.back().second;
include/llvm/ADT/Optional.h
  225   Optional(const Optional &O) = default;
  228   Optional(Optional &&O) = default;
  230   Optional &operator=(T &&y) {
  234   Optional &operator=(Optional &&O) = default;
  234   Optional &operator=(Optional &&O) = default;
  241   static inline Optional create(const T *y) {
  242     return y ? Optional(*y) : Optional();
  242     return y ? Optional(*y) : Optional();
  245   Optional &operator=(const T &y) {
  249   Optional &operator=(const Optional &O) = default;
  249   Optional &operator=(const Optional &O) = default;
  282 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
  282 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
  289 bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
  289 bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
  294 bool operator<(const Optional<T> &X, const Optional<U> &Y) {
  294 bool operator<(const Optional<T> &X, const Optional<U> &Y) {
  301 bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
  301 bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
  306 bool operator>(const Optional<T> &X, const Optional<U> &Y) {
  306 bool operator>(const Optional<T> &X, const Optional<U> &Y) {
  311 bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
  311 bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
  316 bool operator==(const Optional<T> &X, NoneType) {
  321 bool operator==(NoneType, const Optional<T> &X) {
  326 bool operator!=(const Optional<T> &X, NoneType) {
  331 bool operator!=(NoneType, const Optional<T> &X) {
  335 template <typename T> bool operator<(const Optional<T> &X, NoneType) {
  339 template <typename T> bool operator<(NoneType, const Optional<T> &X) {
  343 template <typename T> bool operator<=(const Optional<T> &X, NoneType) {
  347 template <typename T> bool operator<=(NoneType, const Optional<T> &X) {
  351 template <typename T> bool operator>(const Optional<T> &X, NoneType) {
  355 template <typename T> bool operator>(NoneType, const Optional<T> &X) {
  359 template <typename T> bool operator>=(const Optional<T> &X, NoneType) {
  363 template <typename T> bool operator>=(NoneType, const Optional<T> &X) {
  367 template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
  371 template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
  375 template <typename T> bool operator!=(const Optional<T> &X, const T &Y) {
  379 template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
  383 template <typename T> bool operator<(const Optional<T> &X, const T &Y) {
  387 template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
  391 template <typename T> bool operator<=(const Optional<T> &X, const T &Y) {
  395 template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
  399 template <typename T> bool operator>(const Optional<T> &X, const T &Y) {
  403 template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
  407 template <typename T> bool operator>=(const Optional<T> &X, const T &Y) {
  411 template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
  419 raw_ostream &operator<<(raw_ostream &OS, const Optional<T> &O) {
include/llvm/ADT/PostOrderIterator.h
   63   bool insertEdge(Optional<NodeRef> From, NodeRef To) {
   83   template <class NodeRef> bool insertEdge(Optional<NodeRef> From, NodeRef To) {
  107     this->insertEdge(Optional<NodeRef>(), BB);
  116     if (this->insertEdge(Optional<NodeRef>(), BB)) {
  129       if (this->insertEdge(Optional<NodeRef>(VisitStack.back().first), BB)) {
include/llvm/ADT/STLExtras.h
  680     -> llvm::Optional<typename std::remove_const<
  689       llvm::Optional<typename std::remove_const<typename std::remove_reference<
include/llvm/ADT/StringSwitch.h
   48   Optional<T> Result;
include/llvm/Analysis/AliasAnalysis.h
  624                            const Optional<MemoryLocation> &OptLoc) {
  720                            const Optional<MemoryLocation> &OptLoc,
  796                            const Optional<MemoryLocation> &OptLoc) {
include/llvm/Analysis/BasicAliasAnalysis.h
  263   Optional<BasicAAResult> BAR;
  264   Optional<AAResults> AAR;
include/llvm/Analysis/BlockFrequencyInfo.h
   70   Optional<uint64_t> getBlockProfileCount(const BasicBlock *BB,
   76   Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
include/llvm/Analysis/BlockFrequencyInfoImpl.h
  522   Optional<uint64_t> getBlockProfileCount(const Function &F,
  525   Optional<uint64_t> getProfileCountFromFreq(const Function &F,
  972   Optional<uint64_t> getBlockProfileCount(const Function &F,
  979   Optional<uint64_t> getProfileCountFromFreq(const Function &F,
 1162     Optional<uint64_t> MinHeaderWeight;
 1169       Optional<uint64_t> HeaderWeight = Block->getIrrLoopHeaderWeight();
 1346     if (Optional<uint64_t> ProfileCount =
 1350     if (Optional<uint64_t> IrrLoopHeaderWeight =
include/llvm/Analysis/CFLAndersAliasAnalysis.h
   70   const Optional<FunctionInfo> &ensureCached(const Function &);
   85   DenseMap<const Function *, Optional<FunctionInfo>> Cache;
include/llvm/Analysis/CFLSteensAliasAnalysis.h
   65   const Optional<FunctionInfo> &ensureCached(Function *Fn);
  101   DenseMap<Function *, Optional<FunctionInfo>> Cache;
include/llvm/Analysis/DemandedBits.h
   87   mutable Optional<DemandedBits> DB;
include/llvm/Analysis/InlineCost.h
  158   Optional<int> HintThreshold;
  161   Optional<int> ColdThreshold;
  164   Optional<int> OptSizeThreshold;
  167   Optional<int> OptMinSizeThreshold;
  170   Optional<int> HotCallSiteThreshold;
  174   Optional<int> LocallyHotCallSiteThreshold;
  177   Optional<int> ColdCallSiteThreshold;
  180   Optional<bool> ComputeFullInlineCost;
  218     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
  230               Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
include/llvm/Analysis/LazyCallGraph.h
  393     Optional<EdgeSequence> Edges;
include/llvm/Analysis/LoopCacheAnalysis.h
   72   Optional<bool> hasSpacialReuse(const IndexedReference &Other, unsigned CLS,
   79   Optional<bool> hasTemporalReuse(const IndexedReference &Other,
  187             Optional<unsigned> TRT = None);
  195                Optional<unsigned> TRT = None);
  256   Optional<unsigned> TRT;
include/llvm/Analysis/LoopInfo.h
  622     static Optional<Loop::LoopBounds> getBounds(const Loop &L, PHINode &IndVar,
  708   Optional<LoopBounds> getBounds(ScalarEvolution &SE) const;
include/llvm/Analysis/LoopIterator.h
  195   bool insertEdge(Optional<BasicBlock *> From, BasicBlock *To);
  248     Optional<BasicBlock *> From, BasicBlock *To) {
include/llvm/Analysis/MemoryDependenceAnalysis.h
  531   Optional<MemoryDependenceResults> MemDep;
include/llvm/Analysis/MemoryLocation.h
  207   static Optional<MemoryLocation> getOrNone(const Instruction *Inst) {
include/llvm/Analysis/MemorySSA.h
  271   Optional<AliasResult> getOptimizedAccessType() const {
  295   void setOptimizedAccessType(Optional<AliasResult> AR) {
  300                          Optional<AliasResult> AR = MayAlias) {
  311   Optional<AliasResult> OptimizedAccessAlias;
include/llvm/Analysis/ModuleSummaryAnalysis.h
   55   Optional<ModuleSummaryIndex> Index;
include/llvm/Analysis/ObjCARCAnalysisUtils.h
  259   llvm::Optional<unsigned> ImpreciseReleaseMDKind;
  262   llvm::Optional<unsigned> CopyOnEscapeMDKind;
  265   llvm::Optional<unsigned> NoObjCARCExceptionsMDKind;
include/llvm/Analysis/OptimizationRemarkEmitter.h
  109   Optional<uint64_t> computeHotness(const Value *V);
include/llvm/Analysis/ProfileSummaryInfo.h
   50   Optional<uint64_t> HotCountThreshold, ColdCountThreshold;
   54   Optional<bool> HasHugeWorkingSetSize;
   58   Optional<bool> HasLargeWorkingSetSize;
   60   Optional<uint64_t> computeThreshold(int PercentileCutoff);
  103   Optional<uint64_t> getProfileCount(const Instruction *CallInst,
include/llvm/Analysis/ScalarEvolution.h
  564   Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 1548     Optional<ExitLimit> find(const Loop *L, Value *ExitCond, bool ExitIfTrue,
 1758   Optional<APInt> computeConstantDifference(const SCEV *LHS, const SCEV *RHS);
 1824   Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
include/llvm/Analysis/ScalarEvolutionExpander.h
  318     Optional<ScalarEvolution::ValueOffsetPair>
include/llvm/Analysis/SyntheticCountsUtils.h
   40   using GetProfCountTy = function_ref<Optional<Scaled64>(NodeRef, EdgeRef)>;
include/llvm/Analysis/TargetLibraryInfo.h
  369   Optional<TargetLibraryInfoImpl> PresetInfoImpl;
include/llvm/Analysis/TargetTransformInfo.h
  848   llvm::Optional<unsigned> getCacheSize(CacheLevel Level) const;
  851   llvm::Optional<unsigned> getCacheAssociativity(CacheLevel Level) const;
 1272   virtual llvm::Optional<unsigned> getCacheSize(CacheLevel Level) const = 0;
 1273   virtual llvm::Optional<unsigned> getCacheAssociativity(CacheLevel Level) const = 0;
 1650   llvm::Optional<unsigned> getCacheSize(CacheLevel Level) const override {
 1653   llvm::Optional<unsigned> getCacheAssociativity(CacheLevel Level) const override {
 1928   Optional<TargetTransformInfo> TTI;
include/llvm/Analysis/TargetTransformInfoImpl.h
  389   llvm::Optional<unsigned> getCacheSize(TargetTransformInfo::CacheLevel Level) const {
  399   llvm::Optional<unsigned> getCacheAssociativity(
include/llvm/Analysis/ValueLattice.h
  164   Optional<APInt> asConstantInteger() const {
include/llvm/Analysis/ValueTracking.h
  663   Optional<bool> isImpliedCondition(const Value *LHS, const Value *RHS,
  669   Optional<bool> isImpliedByDomCondition(const Value *Cond,
  676   Optional<int64_t> isPointerOffset(const Value *Ptr1, const Value *Ptr2,
include/llvm/Analysis/VectorUtils.h
  128 Optional<VFInfo> tryDemangleForVFABI(StringRef MangledName);
  409     Optional<int32_t> MaybeKey = checkedAdd(Index, SmallestKey);
  427       Optional<int32_t> MaybeLargestIndex = checkedSub(LargestKey, Key);
include/llvm/BinaryFormat/AMDGPUMetadataVerifier.h
   41                    Optional<size_t> Size = None);
include/llvm/BinaryFormat/Dwarf.h
  531 Optional<unsigned> LanguageLowerBound(SourceLanguage L);
  585 Optional<uint8_t> getFixedFormByteSize(dwarf::Form Form, FormParams Params);
include/llvm/Bitcode/BitcodeAnalyzer.h
   53   Optional<BitstreamCursor> BlockInfoStream;
   85   BitcodeAnalyzer(StringRef Buffer, Optional<StringRef> BlockInfoBuffer = None);
   87   Error analyze(Optional<BCDumpOptions> O = None,
   88                 Optional<StringRef> CheckHash = None);
   90   void printStats(BCDumpOptions O, Optional<StringRef> Filename = None);
   95                    Optional<BCDumpOptions> O = None,
   96                    Optional<StringRef> CheckHash = None);
include/llvm/Bitstream/BitstreamReader.h
  548   Expected<Optional<BitstreamBlockInfo>>
include/llvm/Bitstream/BitstreamWriter.h
  297                                 StringRef Blob, Optional<unsigned> Code) {
include/llvm/CodeGen/BasicTTIImpl.h
  518   virtual Optional<unsigned>
  520     return Optional<unsigned>(
  524   virtual Optional<unsigned>
  526     Optional<unsigned> TargetResult =
include/llvm/CodeGen/CommandFlags.inc
   59 LLVM_ATTRIBUTE_UNUSED static Optional<Reloc::Model> getRelocModel() {
   82 LLVM_ATTRIBUTE_UNUSED static Optional<CodeModel::Model> getCodeModel() {
include/llvm/CodeGen/DebugHandlerBase.h
   40   llvm::Optional<llvm::DIExpression::FragmentInfo> FragmentInfo;
   47   static Optional<DbgVariableLocation>
include/llvm/CodeGen/FunctionLoweringInfo.h
  101     using SlotMapTy = DenseMap<const Value *, Optional<int>>;
include/llvm/CodeGen/GCStrategy.h
   99   virtual Optional<bool> isGCManagedPointer(const Type *Ty) const {
include/llvm/CodeGen/GlobalISel/CSEMIRBuilder.h
   73                          ArrayRef<SrcOp> SrcOps, Optional<unsigned> Flags,
   96                                  Optional<unsigned> Flag = None) override;
include/llvm/CodeGen/GlobalISel/ConstantFoldingMIRBuilder.h
   30                                  Optional<unsigned> Flags = None) override {
include/llvm/CodeGen/GlobalISel/InstructionSelector.h
  404       Optional<SmallVector<std::function<void(MachineInstrBuilder &)>, 4>>;
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
  210   Optional<unsigned> Flags;
  215   Optional<unsigned> getFlags() const { return Flags; }
  437   Optional<MachineInstrBuilder> materializeGEP(Register &Res, Register Op0,
  522                                  Optional<unsigned> Flags = None) {
  878                                    Optional<unsigned> FLags = None);
  922                                 Optional<unsigned> Flags = None);
  936                                   Optional<unsigned> Flags = None);
 1227                                Optional<unsigned> Flags = None) {
 1244                                Optional<unsigned> Flags = None) {
 1260                                Optional<unsigned> Flags = None) {
 1266                                  Optional<unsigned> Flags = None) {
 1272                                  Optional<unsigned> Flags = None) {
 1278                                 Optional<unsigned> Flags = None) {
 1284                                Optional<unsigned> Flags = None) {
 1290                                 Optional<unsigned> Flags = None) {
 1296                                 Optional<unsigned> Flags = None) {
 1373                                 Optional<unsigned> Flags = None) {
 1392                                 Optional<unsigned> Flags = None) {
 1398                                 Optional<unsigned> Flags = None) {
 1404                                 Optional<unsigned> Flags = None) {
 1410                                          Optional<unsigned> Flags = None) {
 1474                                          Optional<unsigned> Flags = None);
include/llvm/CodeGen/GlobalISel/Utils.h
  113 Optional<int64_t> getConstantVRegVal(unsigned VReg,
  128 Optional<ValueAndVReg>
  154 Optional<APInt> ConstantFoldBinOp(unsigned Opcode, const unsigned Op1,
  158 Optional<APInt> ConstantFoldExtOp(unsigned Opcode, const unsigned Op1,
include/llvm/CodeGen/MIRYamlMapping.h
  219   Optional<int64_t> LocalOffset;
  586   Optional<std::vector<FlowStringValue>> CalleeSavedRegisters;
include/llvm/CodeGen/MachineBasicBlock.h
  100   Optional<uint64_t> IrrLoopHeaderWeight;
  806   Optional<uint64_t> getIrrLoopHeaderWeight() const {
include/llvm/CodeGen/MachineBlockFrequencyInfo.h
   64   Optional<uint64_t> getBlockProfileCount(const MachineBasicBlock *MBB) const;
   65   Optional<uint64_t> getProfileCountFromFreq(uint64_t Freq) const;
include/llvm/CodeGen/MachineInstr.h
 1489   Optional<unsigned> getSpillSize(const TargetInstrInfo *TII) const;
 1492   Optional<unsigned> getFoldedSpillSize(const TargetInstrInfo *TII) const;
 1495   Optional<unsigned> getRestoreSize(const TargetInstrInfo *TII) const;
 1498   Optional<unsigned>
include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h
  193   Optional<uint64_t> computeHotness(const MachineBasicBlock &MBB);
include/llvm/CodeGen/SelectionDAGAddressAnalysis.h
   36   Optional<int64_t> Offset;
   81                               const Optional<int64_t> NumBytes0,
   83                               const Optional<int64_t> NumBytes1,
include/llvm/CodeGen/TargetInstrInfo.h
  685     virtual Optional<bool>
 1779   virtual Optional<ParamLoadedValue>
include/llvm/DebugInfo/CodeView/AppendingTypeTableBuilder.h
   42   Optional<TypeIndex> getFirst() override;
   43   Optional<TypeIndex> getNext(TypeIndex Prev) override;
include/llvm/DebugInfo/CodeView/CodeViewRecordIO.h
   63   Error beginRecord(Optional<uint32_t> MaxLength);
  245     Optional<uint32_t> MaxLength;
  247     Optional<uint32_t> bytesRemaining(uint32_t CurrentOffset) const {
include/llvm/DebugInfo/CodeView/ContinuationRecordBuilder.h
   36   Optional<ContinuationRecordKind> Kind;
   46                              Optional<TypeIndex> RefersTo);
include/llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h
   54   Optional<TypeIndex> getFirst() override;
   55   Optional<TypeIndex> getNext(TypeIndex Prev) override;
include/llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h
   73   Optional<CVType> tryGetType(TypeIndex Index);
   80   Optional<TypeIndex> getFirst() override;
   81   Optional<TypeIndex> getNext(TypeIndex Prev) override;
include/llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h
   51   Optional<TypeIndex> getFirst() override;
   52   Optional<TypeIndex> getNext(TypeIndex Prev) override;
include/llvm/DebugInfo/CodeView/SymbolRecord.h
  327   Optional<DecodedAnnotation> Current;
include/llvm/DebugInfo/CodeView/SymbolRecordMapping.h
   38   Optional<SymbolKind> Kind;
include/llvm/DebugInfo/CodeView/SymbolSerializer.h
   37   Optional<SymbolKind> CurrentSymbol;
include/llvm/DebugInfo/CodeView/TypeCollection.h
   25   virtual Optional<TypeIndex> getFirst() = 0;
   26   virtual Optional<TypeIndex> getNext(TypeIndex Prev) = 0;
   35     Optional<TypeIndex> Next = getFirst();
include/llvm/DebugInfo/CodeView/TypeRecord.h
  355   Optional<MemberPointerInfo> MemberInfo;
include/llvm/DebugInfo/CodeView/TypeRecordMapping.h
   46   Optional<TypeLeafKind> TypeKind;
   47   Optional<TypeLeafKind> MemberKind;
include/llvm/DebugInfo/CodeView/TypeStreamMerger.h
   86                             Optional<uint32_t> &PCHSignature);
   93                             Optional<uint32_t> &PCHSignature);
   99                        Optional<uint32_t> &PCHSignature);
include/llvm/DebugInfo/CodeView/TypeTableCollection.h
   24   Optional<TypeIndex> getFirst() override;
   25   Optional<TypeIndex> getNext(TypeIndex Prev) override;
include/llvm/DebugInfo/DIContext.h
   37   Optional<StringRef> Source;
  124   Optional<int64_t> FrameOffset;
  125   Optional<uint64_t> Size;
  126   Optional<uint64_t> TagOffset;
include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h
   34     AttributeSpec(dwarf::Attribute A, dwarf::Form F, Optional<uint8_t> ByteSize)
   82     Optional<int64_t> getByteSize(const DWARFUnit &U) const;
  121   Optional<uint32_t> findAttributeIndex(dwarf::Attribute attr) const;
  133   Optional<DWARFFormValue> getAttributeValue(const uint64_t DIEOffset,
  143   Optional<size_t> getFixedAttributesByteSize(const DWARFUnit &U) const;
  178   Optional<FixedSizeInfo> FixedAttributeSize;
include/llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h
   56     virtual Optional<uint64_t> getCUOffset() const = 0;
   61     virtual Optional<dwarf::Tag> getTag() const = 0;
  102     Optional<uint64_t> extractOffset(Optional<DWARFFormValue> Value) const;
  102     Optional<uint64_t> extractOffset(Optional<DWARFFormValue> Value) const;
  125     Optional<uint64_t> getCUOffset() const override;
  131     Optional<uint64_t> getDIESectionOffset() const;
  133     Optional<dwarf::Tag> getTag() const override;
  137     Optional<DWARFFormValue> lookup(HeaderData::AtomType Atom) const;
  287     Optional<uint64_t> getCUOffset() const override;
  288     Optional<dwarf::Tag> getTag() const override { return tag(); }
  298     Optional<uint64_t> getCUIndex() const;
  305     Optional<uint64_t> getDIEUnitOffset() const;
  313     Optional<DWARFFormValue> lookup(dwarf::Index Index) const;
  406                   Optional<uint32_t> Hash) const;
  481     Optional<Entry> CurrentEntry;
  484     Optional<uint32_t> Hash; ///< Hash of Key, if it has been computed.
  487     Optional<uint64_t> findEntryOffsetInCurrentIndex();
include/llvm/DebugInfo/DWARF/DWARFContext.h
  125             std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets);
  128     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets;
include/llvm/DebugInfo/DWARF/DWARFDataExtractor.h
   56   Optional<uint64_t> getEncodedPointer(uint64_t *Offset, uint8_t Encoding,
include/llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h
   60   mutable Optional<DataExtractor> Data;
include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h
   47     Optional<DWARFExpression> Expression;
  195   Optional<uint64_t> getPersonalityAddress() const { return Personality; }
  196   Optional<uint32_t> getPersonalityEncoding() const { return PersonalityEnc; }
  219   const Optional<uint64_t> Personality;
  220   const Optional<uint32_t> PersonalityEnc;
  231       Optional<uint64_t> LSDAAddress, Triple::ArchType Arch)
  244   Optional<uint64_t> getLSDAAddress() const { return LSDAAddress; }
  257   const Optional<uint64_t> LSDAAddress;
  287             Optional<uint64_t> Offset) const;
include/llvm/DebugInfo/DWARF/DWARFDebugLine.h
  301     Optional<StringRef>
include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h
   64             Optional<uint64_t> Offset) const;
  110             DIDumpOptions DumpOpts, Optional<uint64_t> Offset) const;
include/llvm/DebugInfo/DWARF/DWARFDebugRangeList.h
   78   getAbsoluteRanges(llvm::Optional<object::SectionedAddress> BaseAddr) const;
include/llvm/DebugInfo/DWARF/DWARFDebugRnglists.h
   40             llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
   50   getAbsoluteRanges(llvm::Optional<object::SectionedAddress> BaseAddr,
include/llvm/DebugInfo/DWARF/DWARFDie.h
  141   Optional<DWARFFormValue> find(dwarf::Attribute Attr) const;
  154   Optional<DWARFFormValue> find(ArrayRef<dwarf::Attribute> Attrs) const;
  165   Optional<DWARFFormValue>
  190   Optional<uint64_t> getRangesBaseAttribute() const;
  202   Optional<uint64_t> getHighPC(uint64_t LowPC) const;
include/llvm/DebugInfo/DWARF/DWARFFormValue.h
  106   Optional<uint64_t> getAsReference() const;
  111   Optional<UnitOffset> getAsRelativeReference() const;
  112   Optional<uint64_t> getAsUnsignedConstant() const;
  113   Optional<int64_t> getAsSignedConstant() const;
  114   Optional<const char *> getAsCString() const;
  115   Optional<uint64_t> getAsAddress() const;
  116   Optional<object::SectionedAddress> getAsSectionedAddress() const;
  117   Optional<uint64_t> getAsSectionOffset() const;
  118   Optional<ArrayRef<uint8_t>> getAsBlock() const;
  119   Optional<uint64_t> getAsCStringOffset() const;
  120   Optional<uint64_t> getAsReferenceUVal() const;
  161 inline Optional<const char *> toString(const Optional<DWARFFormValue> &V) {
  161 inline Optional<const char *> toString(const Optional<DWARFFormValue> &V) {
  172 inline StringRef toStringRef(const Optional<DWARFFormValue> &V,
  186 inline const char *toString(const Optional<DWARFFormValue> &V,
  196 inline Optional<uint64_t> toUnsigned(const Optional<DWARFFormValue> &V) {
  196 inline Optional<uint64_t> toUnsigned(const Optional<DWARFFormValue> &V) {
  208 inline uint64_t toUnsigned(const Optional<DWARFFormValue> &V,
  218 inline Optional<uint64_t> toReference(const Optional<DWARFFormValue> &V) {
  218 inline Optional<uint64_t> toReference(const Optional<DWARFFormValue> &V) {
  230 inline uint64_t toReference(const Optional<DWARFFormValue> &V,
  240 inline Optional<int64_t> toSigned(const Optional<DWARFFormValue> &V) {
  240 inline Optional<int64_t> toSigned(const Optional<DWARFFormValue> &V) {
  252 inline int64_t toSigned(const Optional<DWARFFormValue> &V, int64_t Default) {
  261 inline Optional<uint64_t> toAddress(const Optional<DWARFFormValue> &V) {
  261 inline Optional<uint64_t> toAddress(const Optional<DWARFFormValue> &V) {
  267 inline Optional<object::SectionedAddress>
  268 toSectionedAddress(const Optional<DWARFFormValue> &V) {
  280 inline uint64_t toAddress(const Optional<DWARFFormValue> &V, uint64_t Default) {
  289 inline Optional<uint64_t> toSectionOffset(const Optional<DWARFFormValue> &V) {
  289 inline Optional<uint64_t> toSectionOffset(const Optional<DWARFFormValue> &V) {
  301 inline uint64_t toSectionOffset(const Optional<DWARFFormValue> &V,
  311 inline Optional<ArrayRef<uint8_t>> toBlock(const Optional<DWARFFormValue> &V) {
  311 inline Optional<ArrayRef<uint8_t>> toBlock(const Optional<DWARFFormValue> &V) {
include/llvm/DebugInfo/DWARF/DWARFListTable.h
  119   Optional<uint64_t> getOffsetEntry(uint32_t Index) const {
  173             llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
  178   Optional<uint64_t> getOffsetEntry(uint32_t Index) const {
  244     llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
include/llvm/DebugInfo/DWARF/DWARFObject.h
   80   virtual Optional<RelocAddrEntry> find(const DWARFSection &Sec,
include/llvm/DebugInfo/DWARF/DWARFRelocMap.h
   24   Optional<object::RelocationRef> Reloc2;
include/llvm/DebugInfo/DWARF/DWARFUnit.h
   62   Optional<uint64_t> DWOId;
   87   Optional<uint64_t> getDWOId() const { return DWOId; }
  219   Optional<StrOffsetsContributionDescriptor> StringOffsetsTableContribution;
  222   Optional<DWARFDebugRnglistTable> RngListTable;
  225   llvm::Optional<object::SectionedAddress> BaseAddr;
  254   Expected<Optional<StrOffsetsContributionDescriptor>>
  261   Expected<Optional<StrOffsetsContributionDescriptor>>
  312   Optional<object::SectionedAddress>
  314   Optional<uint64_t> getStringOffsetSectionItem(uint32_t Index) const;
  330   const Optional<StrOffsetsContributionDescriptor> &
  384   llvm::Optional<object::SectionedAddress> getBaseAddress();
  401   Optional<uint64_t> getDWOId() {
  419   Optional<uint64_t> getRnglistOffset(uint32_t Index) {
include/llvm/DebugInfo/GSYM/FunctionInfo.h
   89   llvm::Optional<LineTable> OptLineTable;
   90   llvm::Optional<InlineInfo> Inline;
include/llvm/DebugInfo/GSYM/GsymReader.h
  117   Optional<uint64_t> getAddress(size_t Index) const;
  128   Optional<FileEntry> getFile(uint32_t Index) const {
  162   template <class T> Optional<uint64_t>
  222   Optional<uint64_t> getAddressInfoOffset(size_t Index) const;
include/llvm/DebugInfo/GSYM/InlineInfo.h
   88   llvm::Optional<InlineArray> getInlineStack(uint64_t Addr) const;
include/llvm/DebugInfo/PDB/IPDBDataStream.h
   31   virtual Optional<RecordType> getItemAtIndex(uint32_t Index) const = 0;
include/llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h
  112   Optional<PdbRaw_DbiVer> VerHeader;
  127   Optional<codeview::DebugFrameDataSubsection> NewFpoData;
  137   std::array<Optional<DebugStream>, (int)DbgHeaderType::Max> DbgStreams;
include/llvm/DebugInfo/PDB/Native/HashTable.h
  224     Optional<uint32_t> FirstUnused;
  277                        Optional<uint32_t> InternalKey) {
include/llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h
   51   Optional<uint32_t> getSignature() const { return Signature; }
   66   Optional<uint32_t> Signature;
include/llvm/DebugInfo/PDB/Native/NativeTypeEnum.h
   66   Optional<codeview::EnumRecord> Record;
   68   Optional<codeview::ModifierRecord> Modifiers;
include/llvm/DebugInfo/PDB/Native/NativeTypePointer.h
   54   Optional<codeview::PointerRecord> Record;
include/llvm/DebugInfo/PDB/Native/NativeTypeUDT.h
   63   Optional<codeview::ClassRecord> Class;
   64   Optional<codeview::UnionRecord> Union;
   67   Optional<codeview::ModifierRecord> Modifiers;
include/llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h
   56   void addTypeRecord(ArrayRef<uint8_t> Type, Optional<uint32_t> Hash);
include/llvm/ExecutionEngine/ExecutionEngine.h
  535   Optional<Reloc::Model> RelocModel;
  536   Optional<CodeModel::Model> CMModel;
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
   77       std::function<Optional<GlobalValueSet>(GlobalValueSet Requested)>;
   81   static Optional<GlobalValueSet> compileRequested(GlobalValueSet Requested);
   85   static Optional<GlobalValueSet> compileWholeModule(GlobalValueSet Requested);
include/llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h
   77   JITTargetMachineBuilder &setRelocationModel(Optional<Reloc::Model> RM) {
   83   JITTargetMachineBuilder &setCodeModel(Optional<CodeModel::Model> CM) {
  121   Optional<Reloc::Model> RM;
  122   Optional<CodeModel::Model> CM;
include/llvm/ExecutionEngine/Orc/LLJIT.h
  195   Optional<JITTargetMachineBuilder> JTMB;
  218   Optional<JITTargetMachineBuilder> &getJITTargetMachineBuilder() {
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
  693   Optional<RemoteCompileCallbackManager> CallbackManager;
include/llvm/ExecutionEngine/Orc/SpeculateAnalyses.h
   33   using ResultTy = Optional<DenseMap<StringRef, DenseSet<StringRef>>>;
include/llvm/ExecutionEngine/Orc/Speculation.h
   51   Optional<AliaseeDetails> getImplFor(const SymbolStringPtr &StubSymbol) {
  171   using IRlikiesStrRef = Optional<DenseMap<StringRef, DenseSet<StringRef>>>;
include/llvm/ExecutionEngine/RuntimeDyldChecker.h
  176   Optional<uint64_t> getSectionLoadAddress(void *LocalAddress) const;
include/llvm/FuzzMutate/IRMutator.h
   77   Optional<fuzzerop::OpDescriptor> chooseOperation(Value *Src,
include/llvm/IR/Attributes.h
  106                                         const Optional<unsigned> &NumElemsArg);
  170   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
  293   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
  519                    const Optional<unsigned> &NumElemsArg);
  525                         const Optional<unsigned> &NumElemsArg) {
  638   std::pair<unsigned, Optional<unsigned>>
  795   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
  831                                 const Optional<unsigned> &NumElemsArg);
include/llvm/IR/BasicBlock.h
  429   Optional<uint64_t> getIrrLoopHeaderWeight() const;
include/llvm/IR/CallSite.h
  568   Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
  572   Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
include/llvm/IR/Constants.h
 1156                                     Optional<unsigned> InRangeIndex = None,
 1164                                     Optional<unsigned> InRangeIndex = None,
 1175                                     Optional<unsigned> InRangeIndex = None,
include/llvm/IR/DIBuilder.h
  158                Optional<DIFile::ChecksumInfo<StringRef>> Checksum = None,
  159                Optional<StringRef> Source = None);
  212                                      Optional<unsigned> DWARFAddressSpace =
  231                                        Optional<unsigned> DWARFAddressSpace =
include/llvm/IR/DebugInfoMetadata.h
  411   inline Optional<StringRef> getSource() const;
  489   Optional<ChecksumInfo<MDString *>> Checksum;
  490   Optional<MDString *> Source;
  493          Optional<ChecksumInfo<MDString *>> CS, Optional<MDString *> Src,
  493          Optional<ChecksumInfo<MDString *>> CS, Optional<MDString *> Src,
  501                          Optional<ChecksumInfo<StringRef>> CS,
  502                          Optional<StringRef> Source,
  504     Optional<ChecksumInfo<MDString *>> MDChecksum;
  514                          Optional<ChecksumInfo<MDString *>> CS,
  515                          Optional<MDString *> Source, StorageType Storage,
  537   Optional<ChecksumInfo<StringRef>> getChecksum() const {
  538     Optional<ChecksumInfo<StringRef>> StringRefChecksum;
  543   Optional<StringRef> getSource() const {
  549   Optional<ChecksumInfo<MDString *>> getRawChecksum() const { return Checksum; }
  550   Optional<MDString *> getRawSource() const { return Source; }
  553   static Optional<ChecksumKind> getChecksumKind(StringRef CSKindStr);
  572 Optional<StringRef> DIScope::getSource() const {
  743   Optional<Signedness> getSignedness() const;
  762   Optional<unsigned> DWARFAddressSpace;
  766                 uint64_t OffsetInBits, Optional<unsigned> DWARFAddressSpace,
  777           Optional<unsigned> DWARFAddressSpace, DIFlags Flags,
  788                                 Optional<unsigned> DWARFAddressSpace,
  828   Optional<unsigned> getDWARFAddressSpace() const { return DWARFAddressSpace; }
 1135   static Optional<DebugEmissionKind> getEmissionKind(StringRef Str);
 1137   static Optional<DebugNameTableKind> getNameTableKind(StringRef Str);
 1453   Optional<StringRef> getSource() const { return getScope()->getSource(); }
 1508   inline Optional<const DILocation *> cloneWithBaseDiscriminator(unsigned BD) const;
 1524   inline Optional<const DILocation *> cloneByMultiplyingDuplicationFactor(unsigned DF) const;
 1557   static Optional<unsigned> encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI);
 1996 Optional<const DILocation *> DILocation::cloneWithBaseDiscriminator(unsigned D) const {
 2001   if (Optional<unsigned> Encoded = encodeDiscriminator(D, DF, CI))
 2006 Optional<const DILocation *> DILocation::cloneByMultiplyingDuplicationFactor(unsigned DF) const {
 2013   if (Optional<unsigned> D = encodeDiscriminator(BD, DF, CI))
 2252   Optional<uint64_t> getSizeInBits() const;
 2256   Optional<DIBasicType::Signedness> getSignedness() const {
 2274   Optional<StringRef> getSource() const {
 2453   static Optional<FragmentInfo> getFragmentInfo(expr_op_iterator Start,
 2457   Optional<FragmentInfo> getFragmentInfo() const {
 2528   static Optional<DIExpression *>
 2972   Optional<StringRef> getSource() const {
include/llvm/IR/DiagnosticInfo.h
  472   Optional<uint64_t> getHotness() const { return Hotness; }
  473   void setHotness(Optional<uint64_t> H) { Hotness = H; }
  514   Optional<uint64_t> Hotness;
include/llvm/IR/Function.h
  320   Optional<StringRef> getSectionPrefix() const;
include/llvm/IR/GlobalValue.h
  565   Optional<ConstantRange> getAbsoluteSymbolRange() const;
include/llvm/IR/IRBuilder.h
 1101       Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding) {
 1108     Optional<StringRef> RoundingStr =
 1117       Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except) {
 1124     Optional<StringRef> ExceptStr =
 1486       Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding = None,
 1487       Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
 2081       Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding = None,
 2082       Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
include/llvm/IR/InstrTypes.h
 1819   Optional<OperandBundleUse> getOperandBundle(StringRef Name) const {
 1835   Optional<OperandBundleUse> getOperandBundle(uint32_t ID) const {
include/llvm/IR/Instructions.h
  102   Optional<uint64_t> getAllocationSizeInBits(const DataLayout &DL) const;
 3467   Optional<SmallVector<uint32_t, 8> > Weights = None;
 3478   using CaseWeightOpt = Optional<uint32_t>;
include/llvm/IR/IntrinsicInst.h
  118     Optional<uint64_t> getFragmentSizeInBits() const;
  233     Optional<RoundingMode> getRoundingMode() const;
  234     Optional<ExceptionBehavior> getExceptionBehavior() const;
  239     static Optional<RoundingMode> StrToRoundingMode(StringRef);
  243     static Optional<StringRef> RoundingModeToStr(RoundingMode);
  247     static Optional<ExceptionBehavior> StrToExceptionBehavior(StringRef);
  251     static Optional<StringRef> ExceptionBehaviorToStr(ExceptionBehavior);
include/llvm/IR/Intrinsics.h
  195   llvm::Optional<Function*> remangleIntrinsicFunction(Function *F);
include/llvm/IR/Module.h
  863   Optional<CodeModel::Model> getCodeModel() const;
include/llvm/IR/ModuleSummaryIndex.h
 1319   Optional<TypeIdCompatibleVtableInfo>
include/llvm/IR/Operator.h
  472   Optional<unsigned> getInRangeIndex() const {
include/llvm/IR/RemarkStreamer.h
   29   Optional<Regex> PassFilter;
   33   const Optional<std::string> Filename;
   42                  Optional<StringRef> Filename = None);
   44   Optional<StringRef> getFilename() const {
include/llvm/IR/Statepoint.h
  438   Optional<uint32_t> NumPatchBytes;
  439   Optional<uint64_t> StatepointID;
include/llvm/IR/ValueMap.h
   94   Optional<MDMapT> MDMap;
  120   Optional<MDMapT> &getMDMap() { return MDMap; }
  123   Optional<Metadata *> getMappedMD(const Metadata *MD) const {
include/llvm/LTO/Config.h
   41   Optional<Reloc::Model> RelocModel = Reloc::PIC_;
   42   Optional<CodeModel::Model> CodeModel = None;
include/llvm/LTO/LTO.h
  428   Optional<bool> EnableSplitLTOUnit;
include/llvm/LTO/legacy/LTOCodeGenerator.h
   87   void setCodePICModel(Optional<Reloc::Model> Model) { RelocModel = Model; }
  222   Optional<Reloc::Model> RelocModel;
include/llvm/LTO/legacy/ThinLTOCodeGenerator.h
   41   Optional<Reloc::Model> RelocModel;
  215   void setCodePICModel(Optional<Reloc::Model> Model) {
include/llvm/LineEditor/LineEditor.h
   40   llvm::Optional<std::string> readLine() const;
include/llvm/MC/MCAsmBackend.h
   78   virtual Optional<MCFixupKind> getFixupKind(StringRef Name) const;
include/llvm/MC/MCContext.h
  549                                     Optional<MD5::MD5Result> Checksum,
  550                                     Optional<StringRef> Source, unsigned CUID);
  586                                 Optional<MD5::MD5Result> Checksum,
  587                                 Optional<StringRef> Source) {
include/llvm/MC/MCDwarf.h
   61   Optional<MD5::MD5Result> Checksum;
   65   Optional<StringRef> Source;
  229                                 Optional<MD5::MD5Result> Checksum,
  230                                 Optional<StringRef> Source,
  235        Optional<MCDwarfLineStr> &LineStr) const;
  239        Optional<MCDwarfLineStr> &LineStr) const;
  253                    Optional<MD5::MD5Result> Checksum,
  254                    Optional<StringRef> Source) {
  274   void emitV5FileDirTables(MCStreamer *MCOS, Optional<MCDwarfLineStr> &LineStr) const;
  283                         Optional<MD5::MD5Result> Checksum,
  284                         Optional<StringRef> Source) {
  291                    Optional<MD5::MD5Result> Checksum, uint16_t DwarfVersion,
  292                    Optional<StringRef> Source) {
  312               Optional<MCDwarfLineStr> &LineStr) const;
  315                                 Optional<MD5::MD5Result> Checksum,
  316                                 Optional<StringRef> Source,
  320                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source,
  320                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source,
  327                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
  327                    Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source) {
include/llvm/MC/MCInstrAnalysis.h
  157   virtual Optional<uint64_t> evaluateMemoryOperandAddress(const MCInst &Inst,
include/llvm/MC/MCRegisterInfo.h
  400   Optional<unsigned> getLLVMRegNum(unsigned RegNum, bool isEH) const;
include/llvm/MC/MCStreamer.h
  806                                   Optional<MD5::MD5Result> Checksum = None,
  807                                   Optional<StringRef> Source = None,
  821       Optional<MD5::MD5Result> Checksum = None, Optional<StringRef> Source = None,
  821       Optional<MD5::MD5Result> Checksum = None, Optional<StringRef> Source = None,
  826                                        Optional<MD5::MD5Result> Checksum,
  827                                        Optional<StringRef> Source,
include/llvm/MC/MCSubtargetInfo.h
  231   virtual Optional<unsigned> getCacheSize(unsigned Level) const;
  237   virtual Optional<unsigned> getCacheAssociativity(unsigned Level) const;
  241   virtual Optional<unsigned> getCacheLineSize(unsigned Level) const;
  250     Optional<unsigned> Size = getCacheLineSize(0);
include/llvm/MC/MCSymbolWasm.h
   22   Optional<std::string> ImportModule;
   23   Optional<std::string> ImportName;
   25   Optional<wasm::WasmGlobalType> GlobalType;
   26   Optional<wasm::WasmEventType> EventType;
include/llvm/MC/MCSymbolXCOFF.h
   52   Optional<XCOFF::StorageClass> StorageClass;
include/llvm/Object/Archive.h
  258   Expected<Optional<Child>> findSym(StringRef name) const;
include/llvm/Object/Minidump.h
   45   Optional<ArrayRef<uint8_t>> getRawStream(minidump::StreamType Type) const;
  191   if (Optional<ArrayRef<uint8_t>> Stream = getRawStream(Type)) {
include/llvm/Object/Wasm.h
  276   llvm::Optional<size_t> DataCount;
include/llvm/ObjectYAML/COFFYAML.h
   66   Optional<uint32_t> SymbolTableIndex;
   76   Optional<CodeViewYAML::DebugHSection> DebugH;
   87   Optional<COFF::AuxiliaryFunctionDefinition> FunctionDefinition;
   88   Optional<COFF::AuxiliarybfAndefSymbol> bfAndefSymbol;
   89   Optional<COFF::AuxiliaryWeakExternal> WeakExternal;
   91   Optional<COFF::AuxiliarySectionDefinition> SectionDefinition;
   92   Optional<COFF::AuxiliaryCLRToken> CLRToken;
  100   Optional<COFF::DataDirectory> DataDirectories[COFF::NUM_DATA_DIRECTORIES];
  104   Optional<PEHeader> OptionalHeader;
include/llvm/ObjectYAML/ELFYAML.h
   79   Optional<llvm::yaml::Hex16> SHEntSize;
   80   Optional<llvm::yaml::Hex64> SHOff;
   81   Optional<llvm::yaml::Hex16> SHNum;
   82   Optional<llvm::yaml::Hex16> SHStrNdx;
   94   Optional<llvm::yaml::Hex64> Align;
   95   Optional<llvm::yaml::Hex64> FileSize;
   96   Optional<llvm::yaml::Hex64> MemSize;
   97   Optional<llvm::yaml::Hex64> Offset;
  103   Optional<uint32_t> NameIndex;
  106   Optional<ELF_SHN> Index;
  110   Optional<uint8_t> Other;
  153   Optional<ELF_SHF> Flags;
  157   Optional<llvm::yaml::Hex64> EntSize;
  172   Optional<llvm::yaml::Hex64> ShName;
  176   Optional<llvm::yaml::Hex64> ShOffset;
  180   Optional<llvm::yaml::Hex64> ShSize;
  184   Optional<yaml::BinaryRef> Content;
  185   Optional<llvm::yaml::Hex64> Size;
  186   Optional<std::vector<StackSizeEntry>> Entries;
  201   Optional<yaml::BinaryRef> Content;
  211   Optional<yaml::BinaryRef> Content;
  212   Optional<llvm::yaml::Hex64> Size;
  213   Optional<llvm::yaml::Hex64> Info;
  233   Optional<yaml::BinaryRef> Content;
  234   Optional<llvm::yaml::Hex64> Size;
  235   Optional<std::vector<ELFYAML::NoteEntry>> Notes;
  242   Optional<yaml::BinaryRef> Content;
  243   Optional<llvm::yaml::Hex64> Size;
  244   Optional<std::vector<uint32_t>> Bucket;
  245   Optional<std::vector<uint32_t>> Chain;
  281   Optional<StringRef> Name;
  282   Optional<llvm::yaml::Hex32> Index;
  286   Optional<yaml::BinaryRef> Content;
  287   Optional<llvm::yaml::Hex64> Size;
  288   Optional<std::vector<AddrsigSymbol>> Symbols;
  342   Optional<StringRef> Symbol;
  395   Optional<std::vector<Symbol>> Symbols;
include/llvm/ObjectYAML/MachOYAML.h
   43   Optional<llvm::yaml::BinaryRef> content;
include/llvm/Passes/PassBuilder.h
  113   Optional<PGOOptions> PGOOpt;
  230                        Optional<PGOOptions> PGOOpt = None,
  639   static Optional<std::vector<PipelineElement>>
include/llvm/Remarks/BitstreamRemarkParser.h
   36   Optional<uint64_t> ContainerVersion;
   37   Optional<uint8_t> ContainerType;
   38   Optional<StringRef> StrTabBuf;
   39   Optional<StringRef> ExternalFilePath;
   40   Optional<uint64_t> RemarkVersion;
   58   Optional<uint8_t> Type;
   59   Optional<uint64_t> RemarkNameIdx;
   60   Optional<uint64_t> PassNameIdx;
   61   Optional<uint64_t> FunctionNameIdx;
   62   Optional<uint64_t> SourceFileNameIdx;
   63   Optional<uint32_t> SourceLine;
   64   Optional<uint32_t> SourceColumn;
   65   Optional<uint64_t> Hotness;
   67     Optional<uint64_t> KeyIdx;
   68     Optional<uint64_t> ValueIdx;
   69     Optional<uint64_t> SourceFileNameIdx;
   70     Optional<uint32_t> SourceLine;
   71     Optional<uint32_t> SourceColumn;
   73   Optional<ArrayRef<Argument>> Args;
include/llvm/Remarks/BitstreamRemarkSerializer.h
  107                      Optional<uint64_t> RemarkVersion,
  108                      Optional<const StringTable *> StrTab = None,
  109                      Optional<StringRef> Filename = None);
  150                  Optional<StringRef> ExternalFilename = None) override;
  163   Optional<BitstreamRemarkSerializerHelper> TmpHelper;
  168   Optional<const StringTable *> StrTab;
  169   Optional<StringRef> ExternalFilename;
  174                           Optional<const StringTable *> StrTab = None,
  175                           Optional<StringRef> ExternalFilename = None)
  185                           Optional<const StringTable *> StrTab = None,
  186                           Optional<StringRef> ExternalFilename = None)
include/llvm/Remarks/Remark.h
   47   Optional<RemarkLocation> Loc;
   83   Optional<RemarkLocation> Loc;
   87   Optional<uint64_t> Hotness;
include/llvm/Remarks/RemarkParser.h
   87                            Optional<ParsedStringTable> StrTab = None,
   88                            Optional<StringRef> ExternalFilePrependPath = None);
include/llvm/Remarks/RemarkSerializer.h
   47   Optional<StringTable> StrTab;
   60                  Optional<StringRef> ExternalFilename = None) = 0;
include/llvm/Remarks/YAMLRemarkSerializer.h
   38                        Optional<StringTable> StrTab = None);
   43                  Optional<StringRef> ExternalFilename = None) override;
   52                        Optional<StringTable> StrTab = None);
   56   Optional<StringRef> ExternalFilename;
   58   YAMLMetaSerializer(raw_ostream &OS, Optional<StringRef> ExternalFilename)
   86                  Optional<StringRef> ExternalFilename = None) override;
   98                            Optional<StringRef> ExternalFilename,
include/llvm/Support/Alignment.h
  117 struct MaybeAlign : public llvm::Optional<Align> {
  119   using UP = llvm::Optional<Align>;
include/llvm/Support/Allocator.h
  296   llvm::Optional<int64_t> identifyObject(const void *Ptr) {
  323     Optional<int64_t> Out = identifyObject(Ptr);
include/llvm/Support/BinaryStreamRef.h
   34                       Optional<uint32_t> Length)
   38                       Optional<uint32_t> Length)
  146   Optional<uint32_t> Length;
  161                   Optional<uint32_t> Length)
  168                   Optional<uint32_t> Length);
  227                           uint32_t ViewOffset, Optional<uint32_t> Length)
  243                           Optional<uint32_t> Length);
include/llvm/Support/CachePruning.h
   31   llvm::Optional<std::chrono::seconds> Interval = std::chrono::seconds(1200);
include/llvm/Support/CheckedArithmetic.h
   29                         llvm::Optional<T>>::type
   47 typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
   56 typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
   65 typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
   74 typename std::enable_if<std::is_signed<T>::value, llvm::Optional<T>>::type
   85 typename std::enable_if<std::is_unsigned<T>::value, llvm::Optional<T>>::type
   94 typename std::enable_if<std::is_unsigned<T>::value, llvm::Optional<T>>::type
  103 typename std::enable_if<std::is_unsigned<T>::value, llvm::Optional<T>>::type
include/llvm/Support/Error.h
 1012 template <typename T> Optional<T> expectedToOptional(Expected<T> &&E) {
 1243   FileError(const Twine &F, Optional<size_t> LineNum,
 1253   static Error build(const Twine &F, Optional<size_t> Line, Error E) {
 1259   Optional<size_t> Line;
include/llvm/Support/Format.h
  219   Optional<uint64_t> FirstByteOffset;
  228   FormattedBytes(ArrayRef<uint8_t> B, uint32_t IL, Optional<uint64_t> O,
  239 format_bytes(ArrayRef<uint8_t> Bytes, Optional<uint64_t> FirstByteOffset = None,
  248                         Optional<uint64_t> FirstByteOffset = None,
include/llvm/Support/FormatProviders.h
   62   static Optional<size_t> parseNumericPrecision(StringRef Str) {
   64     Optional<size_t> Result;
  315     Optional<size_t> Precision = parseNumericPrecision(Style);
include/llvm/Support/FormatVariadic.h
  126   static Optional<ReplacementItem> parseReplacementItem(StringRef Spec);
include/llvm/Support/GlobPattern.h
   41   Optional<StringRef> Exact;
   42   Optional<StringRef> Prefix;
   43   Optional<StringRef> Suffix;
include/llvm/Support/JSON.h
   86 template <typename T> Value toJSON(const llvm::Optional<T> &Opt);
  137   llvm::Optional<std::nullptr_t> getNull(StringRef K) const;
  138   llvm::Optional<bool> getBoolean(StringRef K) const;
  139   llvm::Optional<double> getNumber(StringRef K) const;
  140   llvm::Optional<int64_t> getInteger(StringRef K) const;
  141   llvm::Optional<llvm::StringRef> getString(StringRef K) const;
  393   llvm::Optional<std::nullptr_t> getAsNull() const {
  398   llvm::Optional<bool> getAsBoolean() const {
  403   llvm::Optional<double> getAsNumber() const {
  411   llvm::Optional<int64_t> getAsInteger() const {
  423   llvm::Optional<llvm::StringRef> getAsString() const {
  596 template <typename T> bool fromJSON(const Value &E, llvm::Optional<T> &Out) {
  631 template <typename T> Value toJSON(const llvm::Optional<T> &Opt) {
  665   template <typename T> bool map(StringRef Prop, llvm::Optional<T> &Out) {
include/llvm/Support/LockFileManager.h
   57   Optional<std::pair<std::string, int> > Owner;
   64   static Optional<std::pair<std::string, int> >
include/llvm/Support/NativeFormatting.h
   42                Optional<size_t> Width = None);
   44                   Optional<size_t> Precision = None);
include/llvm/Support/Process.h
   95   static Optional<std::string> GetEnv(StringRef name);
  103   static Optional<std::string> FindInEnvPath(StringRef EnvName,
  107   static Optional<std::string> FindInEnvPath(StringRef EnvName,
include/llvm/Support/Program.h
   94       Optional<ArrayRef<StringRef>> Env = None, ///< An optional vector of
   98       ArrayRef<Optional<StringRef>> Redirects = {}, ///<
  127                             Optional<ArrayRef<StringRef>> Env,
  128                             ArrayRef<Optional<StringRef>> Redirects = {},
include/llvm/Support/SMTAPI.h
  422   virtual Optional<bool> check() const = 0;
include/llvm/Support/TargetRegistry.h
  141            const TargetOptions &Options, Optional<Reloc::Model> RM,
  142            Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT);
  396                                      Optional<Reloc::Model> RM,
  397                                      Optional<CodeModel::Model> CM = None,
 1119             const TargetOptions &Options, Optional<Reloc::Model> RM,
 1120             Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT) {
include/llvm/Support/Threading.h
   69     llvm::Optional<unsigned> StackSizeInBytes = llvm::None);
   84     llvm::Optional<unsigned> StackSizeInBytes = llvm::None);
include/llvm/Support/VersionTuple.h
   70   Optional<unsigned> getMinor() const {
   77   Optional<unsigned> getSubminor() const {
   84   Optional<unsigned> getBuild() const {
include/llvm/Support/VirtualFileSystem.h
  424                Optional<uint32_t> User, Optional<uint32_t> Group,
  424                Optional<uint32_t> User, Optional<uint32_t> Group,
  425                Optional<llvm::sys::fs::file_type> Type,
  426                Optional<llvm::sys::fs::perms> Perms,
  441                Optional<uint32_t> User = None, Optional<uint32_t> Group = None,
  441                Optional<uint32_t> User = None, Optional<uint32_t> Group = None,
  442                Optional<llvm::sys::fs::file_type> Type = None,
  443                Optional<llvm::sys::fs::perms> Perms = None);
  466                     llvm::MemoryBuffer *Buffer, Optional<uint32_t> User = None,
  467                     Optional<uint32_t> Group = None,
  468                     Optional<llvm::sys::fs::file_type> Type = None,
  469                     Optional<llvm::sys::fs::perms> Perms = None);
  761   Optional<bool> IsCaseSensitive;
  762   Optional<bool> IsOverlayRelative;
  763   Optional<bool> UseExternalNames;
include/llvm/Support/YAMLTraits.h
  880   void mapOptionalWithContext(const char *Key, Optional<T> &Val, Context &Ctx) {
  881     this->processKeyWithDefault(Key, Val, Optional<T>(), /*Required=*/false,
  902   void processKeyWithDefault(const char *Key, Optional<T> &Val,
  903                              const Optional<T> &DefaultValue, bool Required,
include/llvm/Target/CodeGenCWrappers.h
   25 inline Optional<CodeModel::Model> unwrap(LLVMCodeModel Model, bool &JIT) {
include/llvm/Target/TargetMachine.h
  390 inline CodeModel::Model getEffectiveCodeModel(Optional<CodeModel::Model> CM,
include/llvm/Testing/Support/Error.h
   87   explicit ErrorMatchesMono(Optional<testing::Matcher<InfoT &>> Matcher)
  129   Optional<testing::Matcher<InfoT &>> Matcher;
include/llvm/Testing/Support/SupportHelpers.h
   65   operator ::testing::Matcher<const llvm::Optional<T> &>() const {
   71   class Impl : public ::testing::MatcherInterface<const llvm::Optional<T> &> {
   76     bool MatchAndExplain(const llvm::Optional<T> &Input,
include/llvm/TextAPI/ELF/ELFStub.h
   44   Optional<std::string> Warning;
   56   Optional<std::string> SoName;
include/llvm/Transforms/IPO/Attributor.h
  680   Optional<DenseMap<const Function *, unsigned>> SccSizeOpt;
 1538   Optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;
 1967   virtual Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const = 0;
include/llvm/Transforms/Scalar/LoopUnrollPass.h
   61   Optional<bool> AllowPartial;
   62   Optional<bool> AllowPeeling;
   63   Optional<bool> AllowRuntime;
   64   Optional<bool> AllowUpperBound;
   65   Optional<bool> AllowProfileBasedPeeling;
   66   Optional<unsigned> FullUnrollMaxCount;
include/llvm/Transforms/Utils/LoopUtils.h
  180 Optional<const MDOperand *> findStringMetadataForLoop(const Loop *TheLoop,
  184 llvm::Optional<int> getOptionalIntLoopAttribute(Loop *TheLoop, StringRef Name);
  210 Optional<MDNode *>
  266 Optional<unsigned> getLoopEstimatedTripCount(Loop *L);
include/llvm/Transforms/Utils/SimplifyLibCalls.h
   92                                Optional<unsigned> SizeOp = None,
   93                                Optional<unsigned> StrOp = None,
   94                                Optional<unsigned> FlagsOp = None);
include/llvm/Transforms/Utils/UnrollLoop.h
  133     Optional<unsigned> UserThreshold, Optional<unsigned> UserCount,
  133     Optional<unsigned> UserThreshold, Optional<unsigned> UserCount,
  134     Optional<bool> UserAllowPartial, Optional<bool> UserRuntime,
  134     Optional<bool> UserAllowPartial, Optional<bool> UserRuntime,
  135     Optional<bool> UserUpperBound, Optional<bool> UserAllowPeeling,
  135     Optional<bool> UserUpperBound, Optional<bool> UserAllowPeeling,
  136     Optional<bool> UserAllowProfileBasedPeeling,
  137     Optional<unsigned> UserFullUnrollMaxCount);
include/llvm/XRay/InstrumentationMap.h
   90   Optional<int32_t> getFunctionId(uint64_t Addr) const;
   93   Optional<uint64_t> getFunctionAddr(int32_t FuncId) const;
lib/Analysis/AliasAnalysisSummary.cpp
   75 Optional<InstantiatedValue> instantiateInterfaceValue(InterfaceValue IValue,
   84 Optional<InstantiatedRelation>
   95 Optional<InstantiatedAttr> instantiateExternalAttribute(ExternalAttribute EAttr,
lib/Analysis/AliasAnalysisSummary.h
  203 Optional<InstantiatedValue> instantiateInterfaceValue(InterfaceValue IValue,
  232 Optional<InstantiatedRelation>
  241 Optional<InstantiatedAttr> instantiateExternalAttribute(ExternalAttribute EAttr,
lib/Analysis/BlockFrequencyInfo.cpp
  205 Optional<uint64_t>
  214 Optional<uint64_t>
lib/Analysis/BlockFrequencyInfoImpl.cpp
  558 Optional<uint64_t>
  566 Optional<uint64_t>
lib/Analysis/CFLAndersAliasAnalysis.cpp
  335   Optional<AliasAttrs> getAttrs(const Value *) const;
  353 static Optional<InterfaceValue>
  358   Optional<unsigned> Index;
  509 Optional<AliasAttrs>
  628 static Optional<InstantiatedValue> getNodeBelow(const CFLGraph &Graph,
  827 const Optional<CFLAndersAAResult::FunctionInfo> &
lib/Analysis/CFLSteensAliasAnalysis.cpp
  245 const Optional<CFLSteensAAResult::FunctionInfo> &
lib/Analysis/CGSCCPassManager.cpp
  167       Optional<PreservedAnalyses> InnerPA;
  271     Optional<PreservedAnalyses> FunctionPA;
lib/Analysis/ConstantFolding.cpp
  765                          Type *ResultTy, Optional<unsigned> InRangeIndex,
  986   Optional<unsigned> InRangeIndex;
  987   if (Optional<unsigned> LastIRIndex = InnermostGEP->getInRangeIndex())
lib/Analysis/InlineCost.cpp
  107   Optional<function_ref<BlockFrequencyInfo &(Function &)>> &GetBFI;
  239   Optional<int> getHotCallSiteThreshold(CallBase &Call,
  295                Optional<function_ref<BlockFrequencyInfo &(Function &)>> &GetBFI,
  831 Optional<int>
 2006     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
 2016     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
lib/Analysis/InstructionSimplify.cpp
 3974   Optional<bool> Imp = isImpliedByDomCondition(Cond, Q.CxtI, Q.DL);
lib/Analysis/LazyValueInfo.cpp
  423   Optional<ConstantRange> getRangeForOperand(unsigned Op, Instruction *I,
  996 Optional<ConstantRange> LazyValueInfoImpl::getRangeForOperand(unsigned Op,
 1045   Optional<ConstantRange> LHSRes = getRangeForOperand(0, CI, BB);
 1069   Optional<ConstantRange> LHSRes = getRangeForOperand(0, I, BB);
 1070   Optional<ConstantRange> RHSRes = getRangeForOperand(1, I, BB);
 1436               if (Optional<APInt> OpConst = OpLatticeVal.asConstantInteger()) {
lib/Analysis/LoopAnalysisManager.cpp
   94     Optional<PreservedAnalyses> InnerPA;
lib/Analysis/LoopCacheAnalysis.cpp
  140 Optional<bool> IndexedReference::hasSpacialReuse(const IndexedReference &Other,
  195 Optional<bool> IndexedReference::hasTemporalReuse(const IndexedReference &Other,
  471                         DependenceInfo &DI, Optional<unsigned> TRT) {
  536         Optional<bool> HasTemporalReuse =
  538         Optional<bool> HasSpacialReuse =
lib/Analysis/LoopInfo.cpp
  197 Optional<Loop::LoopBounds> Loop::LoopBounds::getBounds(const Loop &L,
  283 Optional<Loop::LoopBounds> Loop::getBounds(ScalarEvolution &SE) const {
lib/Analysis/MemoryBuiltins.cpp
  134 static Optional<AllocFnsTy>
  172 static Optional<AllocFnsTy> getAllocationData(const Value *V, AllocType AllocTy,
  183 static Optional<AllocFnsTy>
  196 static Optional<AllocFnsTy> getAllocationSize(const Value *V,
  207     if (Optional<AllocFnsTy> Data =
  215   std::pair<unsigned, Optional<unsigned>> Args = Attr.getAllocSizeArgs();
  665   Optional<AllocFnsTy> FnData = getAllocationSize(CS.getInstruction(), TLI);
  930   Optional<AllocFnsTy> FnData = getAllocationSize(CS.getInstruction(), TLI);
lib/Analysis/MemorySSA.cpp
  253   Optional<AliasResult> AR;
  267   Optional<AliasResult> AR;
  345   Optional<AliasResult> AR = MayAlias;
  503     Optional<ListIndex> Previous;
  506             Optional<ListIndex> Previous)
  510             Optional<ListIndex> Previous)
  545     Optional<AliasResult> AR;
  621   Optional<TerminatedPath>
  719     Optional<ListIndex> N = None;
  808       if (Optional<TerminatedPath> Blocker = getBlockingAccess(
 1297     Optional<AliasResult> AR;
 2195     if (Optional<AliasResult> AR = getOptimizedAccessType())
 2235   if (Optional<AliasResult> AR = getOptimizedAccessType())
lib/Analysis/OptimizationRemarkEmitter.cpp
   58 Optional<uint64_t> OptimizationRemarkEmitter::computeHotness(const Value *V) {
lib/Analysis/ProfileSummaryInfo.cpp
  102 Optional<uint64_t>
  261 Optional<uint64_t> ProfileSummaryInfo::computeThreshold(int PercentileCutoff) {
lib/Analysis/ScalarEvolution.cpp
 4352         Optional<const SCEV *> Res =
 4361         Optional<const SCEV *> Res = compareWithBackedgeCondition(I);
 4377   Optional<const SCEV *> compareWithBackedgeCondition(Value *IC);
 4386 Optional<const SCEV *>
 4498 static Optional<BinaryOp> MatchBinaryOp(Value *V, DominatorTree &DT) {
 4683 Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 4894 Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 4916   Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
 5525 static Optional<ConstantRange> GetRangeFromMetadata(Value *V) {
 5701     Optional<ConstantRange> MDRange = GetRangeFromMetadata(U->getValue());
 5865       Optional<unsigned> CastOp;
 7177 Optional<ScalarEvolution::ExitLimit>
 7610     Optional<Instruction::BinaryOps> PostShiftOpCode;
 8441 static Optional<std::tuple<APInt, APInt, APInt, APInt, unsigned>>
 8495 static Optional<APInt> MinOptional(Optional<APInt> X, Optional<APInt> Y) {
 8495 static Optional<APInt> MinOptional(Optional<APInt> X, Optional<APInt> Y) {
 8495 static Optional<APInt> MinOptional(Optional<APInt> X, Optional<APInt> Y) {
 8518 static Optional<APInt> TruncIfPossible(Optional<APInt> X, unsigned BitWidth) {
 8518 static Optional<APInt> TruncIfPossible(Optional<APInt> X, unsigned BitWidth) {
 8541 static Optional<APInt>
 8551   Optional<APInt> X = APIntOps::SolveQuadraticEquationWrap(A, B, C, BitWidth+1);
 8573 static Optional<APInt>
 8606     Optional<APInt> SO = None;
 8614     Optional<APInt> UO = APIntOps::SolveQuadraticEquationWrap(A, B, -Bound,
 8638     Optional<APInt> Min = MinOptional(SO, UO);
 8641     Optional<APInt> Max = Min == SO ? UO : SO;
 9868 Optional<APInt> ScalarEvolution::computeConstantDifference(const SCEV *More,
 9981   Optional<APInt> LDiff = computeConstantDifference(LHS, FoundLHS);
 9982   Optional<APInt> RDiff = computeConstantDifference(RHS, FoundRHS);
10455   Optional<APInt> Addend = computeConstantDifference(LHS, FoundLHS);
12192     Optional<std::pair<const SCEV *, SmallVector<const SCEVPredicate *, 3>>>
lib/Analysis/ScalarEvolutionExpander.cpp
 2086   Optional<ScalarEvolution::ValueOffsetPair> VO =
 2093 Optional<ScalarEvolution::ValueOffsetPair>
lib/Analysis/StratifiedSets.h
   94   Optional<StratifiedInfo> find(const T &Elem) const {
  547   Optional<const StratifiedInfo *> get(const T &Val) const {
  554   Optional<StratifiedInfo *> get(const T &Val) {
  561   Optional<StratifiedIndex> indexOf(const T &Val) {
lib/Analysis/TargetTransformInfo.cpp
  509 llvm::Optional<unsigned> TargetTransformInfo::getCacheSize(CacheLevel Level)
  514 llvm::Optional<unsigned> TargetTransformInfo::getCacheAssociativity(
  894 static Optional<ReductionData> getReductionData(Instruction *I) {
  931   Optional<ReductionData> RD = getReductionData(I);
  975     Optional<ReductionData> NextLevelRD =
 1016   Optional<ReductionData> RD = getReductionData(RdxStart);
 1081   Optional<ReductionData> RD = getReductionData(RdxStart);
 1109     Optional<ReductionData> RDLevel = getReductionData(RdxOp);
lib/Analysis/VFABIDemangling.cpp
  288 Optional<VFInfo> VFABI::tryDemangleForVFABI(StringRef MangledName) {
lib/Analysis/ValueTracking.cpp
  936   Optional<bool> ShifterOperandIsNonZero;
 5194 static Optional<bool>
 5232 static Optional<bool> isImpliedCondMatchingOperands(CmpInst::Predicate APred,
 5250 static Optional<bool>
 5270 static Optional<bool> isImpliedCondICmps(const ICmpInst *LHS,
 5288     if (Optional<bool> Implication = isImpliedCondMatchingOperands(
 5299     if (Optional<bool> Implication = isImpliedCondMatchingImmOperands(
 5315 static Optional<bool> isImpliedCondAndOr(const BinaryOperator *LHS,
 5333     if (Optional<bool> Implication =
 5336     if (Optional<bool> Implication =
 5344 Optional<bool> llvm::isImpliedCondition(const Value *LHS, const Value *RHS,
 5386 Optional<bool> llvm::isImpliedByDomCondition(const Value *Cond,
 5714 static Optional<int64_t>
 5745 Optional<int64_t> llvm::isPointerOffset(const Value *Ptr1, const Value *Ptr2,
lib/AsmParser/LLParser.cpp
 1262       Optional<unsigned> NumElemsArg;
 2172                                        Optional<unsigned> &HowManyArg) {
 3565     Optional<unsigned> InRangeOp;
 3703                                       Optional<unsigned> *InRangeOp) {
 4322   Optional<DIFile::ChecksumKind> CSKind =
 4526   Optional<unsigned> DWARFAddressSpace;
 4612   Optional<DIFile::ChecksumInfo<MDString *>> OptChecksum;
 4618   Optional<MDString *> OptSource;
lib/AsmParser/LLParser.h
  296                                  Optional<unsigned> &HowManyArg);
  514                                 Optional<unsigned> *InRangeOp = nullptr);
lib/BinaryFormat/AMDGPUMetadataVerifier.cpp
   53     Optional<size_t> Size) {
lib/BinaryFormat/Dwarf.cpp
  349 Optional<unsigned> llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) {
  645 Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,
lib/Bitcode/Reader/BitcodeAnalyzer.cpp
   24 static Optional<const char *> GetBlockName(unsigned BlockID,
   87 static Optional<const char *> GetCodeName(unsigned CodeID, unsigned BlockID,
  460 static Expected<CurStreamTypeType> analyzeHeader(Optional<BCDumpOptions> O,
  541                                  Optional<StringRef> BlockInfoBuffer)
  547 Error BitcodeAnalyzer::analyze(Optional<BCDumpOptions> O,
  548                                Optional<StringRef> CheckHash) {
  576         Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo =
  580         Optional<BitstreamBlockInfo> NewBlockInfo =
  614                                  Optional<StringRef> Filename) {
  650     if (Optional<const char *> BlockName =
  713         if (Optional<const char *> CodeName = GetCodeName(
  725                                   Optional<BCDumpOptions> O,
  726                                   Optional<StringRef> CheckHash) {
  740     Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo =
  744     Optional<BitstreamBlockInfo> NewBlockInfo =
  763   Optional<const char *> BlockName = None;
  859       Optional<const char *> CodeName =
lib/Bitcode/Reader/BitcodeReader.cpp
  499   Optional<MetadataLoader> MDLoader;
 2589       Optional<unsigned> InRangeIndex;
 3042   Expected<Optional<BitstreamBlockInfo>> MaybeNewBlockInfo =
 3046   Optional<BitstreamBlockInfo> NewBlockInfo =
lib/Bitcode/Reader/MetadataLoader.cpp
 1314     Optional<unsigned> DWARFAddressSpace;
 1440     Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
lib/Bitcode/Writer/BitcodeWriter.cpp
  489   Optional<unsigned> getValueId(GlobalValue::GUID ValGUID) {
 2461         if (Optional<unsigned> Idx = GO->getInRangeIndex()) {
lib/Bitstream/Reader/BitstreamReader.cpp
  431 Expected<Optional<BitstreamBlockInfo>>
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
  772   Optional<unsigned> Size;
 1361   Optional<SmallString<128>> Filename;
 1362   if (Optional<StringRef> FilenameRef = RS.getFilename()) {
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
  653   Optional<TypeIndex> B = Table.getFirst();
 1222     Optional<DbgVariableLocation> Location =
lib/CodeGen/AsmPrinter/DIE.cpp
  436   if (Optional<uint8_t> FixedSize = dwarf::getFixedFormByteSize(Form, Params))
lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp
   29 Optional<DbgVariableLocation>
lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp
  180   Optional<unsigned> NVPTXAddressSpace;
  636   Optional<unsigned> NVPTXAddressSpace;
lib/CodeGen/AsmPrinter/DwarfExpression.cpp
  372   Optional<DIExpression::ExprOperand> PrevConvertOp = None;
lib/CodeGen/AsmPrinter/DwarfExpression.h
   55   Optional<DIExpression::ExprOperand> take() {
   65   Optional<DIExpression::ExprOperand> peek() const {
   72   Optional<DIExpression::ExprOperand> peekNext() const {
   90   Optional<DIExpression::FragmentInfo> getFragmentInfo() const {
  164   Optional<uint8_t> TagOffset;
lib/CodeGen/AsmPrinter/DwarfUnit.cpp
  233                         Optional<dwarf::Form> Form, uint64_t Integer) {
  247                         Optional<dwarf::Form> Form, int64_t Integer) {
  253 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
  311 Optional<MD5::MD5Result> DwarfUnit::getMD5AsBytes(const DIFile *File) const {
  315   Optional<DIFile::ChecksumInfo<StringRef>> Checksum = File->getChecksum();
lib/CodeGen/AsmPrinter/DwarfUnit.h
  137                Optional<dwarf::Form> Form, uint64_t Integer);
  143                Optional<dwarf::Form> Form, int64_t Integer);
  145   void addSInt(DIELoc &Die, Optional<dwarf::Form> Form, int64_t Integer);
  290   Optional<MD5::MD5Result> getMD5AsBytes(const DIFile *File) const;
lib/CodeGen/BuiltinGCs.cpp
   75   Optional<bool> isGCManagedPointer(const Type *Ty) const override {
  107   Optional<bool> isGCManagedPointer(const Type *Ty) const override {
lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp
   92                                       Optional<unsigned> Flags,
  140                                               Optional<unsigned> Flag) {
  160     if (Optional<APInt> Cst = ConstantFoldBinOp(Opc, SrcOps[0].getReg(),
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp
  232 Optional<MachineInstrBuilder>
  702                                                    Optional<unsigned> Flags) {
  717                                                 Optional<unsigned> Flags) {
  726                                                   Optional<unsigned> Flags) {
  956                                                  Optional<unsigned> Flags) {
lib/CodeGen/GlobalISel/Utils.cpp
  207 Optional<int64_t> llvm::getConstantVRegVal(unsigned VReg,
  209   Optional<ValueAndVReg> ValAndVReg =
  218 Optional<ValueAndVReg> llvm::getConstantVRegValWithLookThrough(
  270   Optional<APInt> MaybeVal = GetImmediateValue(*MI);
  338 Optional<APInt> llvm::ConstantFoldBinOp(unsigned Opcode, const unsigned Op1,
  414 Optional<APInt> llvm::ConstantFoldExtOp(unsigned Opcode, const unsigned Op1,
lib/CodeGen/ImplicitNullChecks.cpp
  100     Optional<ArrayRef<MachineInstr *>::iterator> PotentialDependence;
  104         Optional<ArrayRef<MachineInstr *>::iterator> PotentialDependence)
  251   Optional<ArrayRef<MachineInstr *>::iterator> Dep;
lib/CodeGen/LiveDebugValues.cpp
  124   using OptFragmentInfo = Optional<DIExpression::FragmentInfo>;
  461   Optional<VarLoc::SpillLoc> isRestoreInstruction(const MachineInstr &MI,
  898 Optional<LiveDebugValues::VarLoc::SpillLoc>
  927   Optional<VarLoc::SpillLoc> Loc;
lib/CodeGen/MIRParser/MIParser.cpp
  354   Optional<unsigned> TiedDefIdx;
  357                        StringRef::iterator End, Optional<unsigned> &TiedDefIdx)
  421                             Optional<unsigned> &TiedDefIdx, bool IsDef = false);
  459                            Optional<unsigned> &TiedDefIdx);
  461                                          Optional<unsigned> &TiedDefIdx);
  890     Optional<unsigned> TiedDefIdx;
  912     Optional<unsigned> TiedDefIdx;
 1394                                     Optional<unsigned> &TiedDefIdx,
 2406                                    Optional<unsigned> &TiedDefIdx) {
 2502     MachineOperand &Dest, Optional<unsigned> &TiedDefIdx) {
lib/CodeGen/MachineBlockFrequencyInfo.cpp
  231 Optional<uint64_t> MachineBlockFrequencyInfo::getBlockProfileCount(
  237 Optional<uint64_t>
lib/CodeGen/MachineInstr.cpp
 2158 Optional<unsigned>
 2169 Optional<unsigned>
 2177 Optional<unsigned>
 2188 Optional<unsigned>
lib/CodeGen/MachineOperand.cpp
  432   if (Optional<unsigned> Reg = TRI->getLLVMRegNum(DwarfReg, true))
  445   Optional<int> Slot;
lib/CodeGen/MachineOptimizationRemarkEmitter.cpp
   33 Optional<uint64_t>
lib/CodeGen/MachineTraceMetrics.cpp
  451   bool insertEdge(Optional<const MachineBasicBlock *> From,
lib/CodeGen/ModuloSchedule.cpp
  868     Optional<bool> StaticallyGreater =
 1267   Register phi(Register LoopReg, Optional<Register> InitReg = {},
 1375   SmallVector<Optional<Register>, 4> Defaults;
 1386   Optional<Register> IllegalPhiDefault;
 1448 Register KernelRewriter::phi(Register LoopReg, Optional<Register> InitReg,
 1776     Optional<bool> StaticallyGreater =
lib/CodeGen/PeepholeOptimizer.cpp
  272     Optional<IndexPair> getCommutePair() const { return CommutePair; }
  276     Optional<IndexPair> CommutePair;
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
 6323 static const Optional<ByteProvider>
 6421 static Optional<bool> isBigEndian(const SmallVector<int64_t, 4> &ByteOffsets,
 6505   Optional<BaseIndexOffset> Base;
 6575   Optional<bool> IsBigEndian = isBigEndian(ByteOffsets, FirstOffset);
 6677   Optional<BaseIndexOffset> Base;
 6681   Optional<ByteProvider> FirstByteProvider;
 6732   Optional<bool> IsBigEndian = isBigEndian(ByteOffsets, FirstOffset);
20482     Optional<int64_t> NumBytes;
lib/CodeGen/SelectionDAG/FastISel.cpp
 1366     Optional<MachineOperand> Op;
lib/CodeGen/SelectionDAG/SelectionDAGAddressAnalysis.cpp
   86                                       const Optional<int64_t> NumBytes0,
   88                                       const Optional<int64_t> NumBytes1,
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
  167 static Optional<CallingConv::ID> getABIRegCopyCC(const Value *V) {
  193                                       Optional<CallingConv::ID> CC);
  203                                 Optional<CallingConv::ID> CC = None,
  204                                 Optional<ISD::NodeType> AssertOp = None) {
  360                                       Optional<CallingConv::ID> CallConv) {
  493                                  Optional<CallingConv::ID> CallConv);
  501                            Optional<CallingConv::ID> CallConv = None,
  661                                  Optional<CallingConv::ID> CallConv) {
  777                            Optional<CallingConv::ID> CC) {
 5497   Optional<MachineOperand> Op;
 9326     Optional<ISD::NodeType> AssertOp;
 9761     Optional<ISD::NodeType> AssertOp = None;
 9823         Optional<ISD::NodeType> AssertOp;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h
  836   Optional<CallingConv::ID> CallConv;
  843                Optional<CallingConv::ID> CC);
lib/CodeGen/SelectionDAG/StatepointLowering.cpp
  144 static Optional<int> findPreviousSpillSlot(const Value *Val,
  171     Optional<int> MergedResult = None;
  174       Optional<int> SpillSlot =
  239   Optional<int> Index =
 1010   Optional<int> DerivedPtrLocation = SlotIt->second;
lib/CodeGen/TargetInstrInfo.cpp
 1123 Optional<ParamLoadedValue>
lib/DebugInfo/CodeView/AppendingTypeTableBuilder.cpp
   39 Optional<TypeIndex> AppendingTypeTableBuilder::getFirst() {
   46 Optional<TypeIndex> AppendingTypeTableBuilder::getNext(TypeIndex Prev) {
lib/DebugInfo/CodeView/CVTypeVisitor.cpp
  159   Optional<TypeIndex> I = Types.getFirst();
lib/DebugInfo/CodeView/CodeViewRecordIO.cpp
   18 Error CodeViewRecordIO::beginRecord(Optional<uint32_t> MaxLength) {
   68   Optional<uint32_t> Min = Limits.front().bytesRemaining(Offset);
   70     Optional<uint32_t> ThisMin = X.bytesRemaining(Offset);
lib/DebugInfo/CodeView/ContinuationRecordBuilder.cpp
  150     uint32_t OffBegin, uint32_t OffEnd, Optional<TypeIndex> RefersTo) {
  231   Optional<TypeIndex> RefersTo;
lib/DebugInfo/CodeView/GlobalTypeTableBuilder.cpp
   41 Optional<TypeIndex> GlobalTypeTableBuilder::getFirst() {
   48 Optional<TypeIndex> GlobalTypeTableBuilder::getNext(TypeIndex Prev) {
lib/DebugInfo/CodeView/LazyRandomTypeCollection.cpp
  100 Optional<CVType> LazyRandomTypeCollection::tryGetType(TypeIndex Index) {
  204 Optional<TypeIndex> LazyRandomTypeCollection::getFirst() {
  213 Optional<TypeIndex> LazyRandomTypeCollection::getNext(TypeIndex Prev) {
lib/DebugInfo/CodeView/MergingTypeTableBuilder.cpp
   41 Optional<TypeIndex> MergingTypeTableBuilder::getFirst() {
   48 Optional<TypeIndex> MergingTypeTableBuilder::getNext(TypeIndex Prev) {
lib/DebugInfo/CodeView/TypeRecordMapping.cpp
  194   Optional<uint32_t> MaxLen;
lib/DebugInfo/CodeView/TypeStreamMerger.cpp
   79                          const CVTypeArray &IdsAndTypes, Optional<uint32_t> &S);
   91                          Optional<uint32_t> &S);
   98                          Optional<uint32_t> &S);
  168   Optional<Error> LastError;
  198   Optional<uint32_t> PCHSignature;
  276                                          Optional<uint32_t> &S) {
  289                                          Optional<uint32_t> &S) {
  314                                          Optional<uint32_t> &S) {
  446     Optional<uint32_t> &PCHSignature) {
  454     ArrayRef<GloballyHashedType> Hashes, Optional<uint32_t> &PCHSignature) {
  464                                        Optional<uint32_t> &PCHSignature) {
lib/DebugInfo/CodeView/TypeTableCollection.cpp
   23 Optional<TypeIndex> TypeTableCollection::getFirst() {
   29 Optional<TypeIndex> TypeTableCollection::getNext(TypeIndex Prev) {
lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp
   72       Optional<uint8_t> ByteSize;
  141 Optional<uint32_t>
  150 Optional<DWARFFormValue> DWARFAbbreviationDeclaration::getAttributeValue(
  153   Optional<uint32_t> MatchAttrIndex = findAttributeIndex(Attr);
  197 Optional<int64_t> DWARFAbbreviationDeclaration::AttributeSpec::getByteSize(
  203   Optional<int64_t> S;
  210 Optional<size_t> DWARFAbbreviationDeclaration::getFixedAttributesByteSize(
lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
  147 Optional<uint64_t> AppleAcceleratorTable::HeaderData::extractOffset(
  148     Optional<DWARFFormValue> Value) const {
  189         if (Optional<uint64_t> Val = Atom.getAsUnsignedConstant()) {
  276 Optional<DWARFFormValue>
  287 Optional<uint64_t> AppleAcceleratorTable::Entry::getDIESectionOffset() const {
  291 Optional<uint64_t> AppleAcceleratorTable::Entry::getCUOffset() const {
  295 Optional<dwarf::Tag> AppleAcceleratorTable::Entry::getTag() const {
  296   Optional<DWARFFormValue> Tag = lookup(dwarf::DW_ATOM_die_tag);
  299   if (Optional<uint64_t> Value = Tag->getAsUnsignedConstant())
  531 Optional<DWARFFormValue>
  541 Optional<uint64_t> DWARFDebugNames::Entry::getDIEUnitOffset() const {
  542   if (Optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_die_offset))
  547 Optional<uint64_t> DWARFDebugNames::Entry::getCUIndex() const {
  548   if (Optional<DWARFFormValue> Off = lookup(dwarf::DW_IDX_compile_unit))
  557 Optional<uint64_t> DWARFDebugNames::Entry::getCUOffset() const {
  558   Optional<uint64_t> Index = getCUIndex();
  672                                           Optional<uint32_t> Hash) const {
  782 Optional<uint64_t>
  826   Optional<uint64_t> Offset = findEntryOffsetInCurrentIndex();
lib/DebugInfo/DWARF/DWARFContext.cpp
   97     std::vector<Optional<StrOffsetsContributionDescriptor>>;
  267     llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
  291                                 Optional<uint64_t> DumpOffset) {
  315     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets) {
  628       if (Optional<uint64_t> DWOId =
  973 static Optional<uint64_t> getTypeSize(DWARFDie Type, uint64_t PointerSize) {
  975     if (Optional<uint64_t> Size = SizeAttr->getAsUnsignedConstant())
 1001     Optional<uint64_t> BaseSize = getTypeSize(BaseType, PointerSize);
 1010         if (Optional<uint64_t> ElemCount =
 1014         if (Optional<int64_t> UpperBound =
 1036       if (Optional<const char *> Name = NameAttr->getAsCString())
 1039       if (Optional<ArrayRef<uint8_t>> Location = LocationAttr->getAsBlock())
 1050       if (Optional<const char *> Name = NameAttr->getAsCString())
 1703   Optional<RelocAddrEntry> find(const DWARFSection &S,
lib/DebugInfo/DWARF/DWARFDataExtractor.cpp
   22   Optional<RelocAddrEntry> E = Obj->find(*Section, *Off);
   34 Optional<uint64_t>
lib/DebugInfo/DWARF/DWARFDebugFrame.cpp
  404       Optional<uint64_t> Personality;
  405       Optional<uint32_t> PersonalityEncoding;
  407         Optional<uint64_t> AugmentationLength;
  476       Optional<uint64_t> LSDAAddress;
  544                            Optional<uint64_t> Offset) const {
lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp
   49   if (Optional<size_t> FixedSize = AbbrevDecl->getFixedAttributesByteSize(U)) {
lib/DebugInfo/DWARF/DWARFDebugLine.cpp
 1025 Optional<StringRef> DWARFDebugLine::LineTable::getSourceByIndex(uint64_t FileIndex,
 1030   if (Optional<const char *> source = Entry.Source.getAsCString())
lib/DebugInfo/DWARF/DWARFDebugLoc.cpp
   67                          Optional<uint64_t> Offset) const {
  320                               Optional<uint64_t> Offset) const {
lib/DebugInfo/DWARF/DWARFDebugRangeList.cpp
   71     llvm::Optional<object::SectionedAddress> BaseAddr) const {
lib/DebugInfo/DWARF/DWARFDebugRnglists.cpp
  116     llvm::Optional<object::SectionedAddress> BaseAddr, DWARFUnit &U) const {
  176     llvm::function_ref<Optional<object::SectionedAddress>(uint32_t)>
lib/DebugInfo/DWARF/DWARFDie.cpp
   98       if (Optional<object::SectionedAddress> BA = U->getBaseAddress())
  148   Optional<uint64_t> Bound;
  151       Optional<uint64_t> LB;
  152       Optional<uint64_t> Count;
  153       Optional<uint64_t> UB;
  154       Optional<unsigned> DefaultLB;
  155       if (Optional<DWARFFormValue> L = C.find(DW_AT_lower_bound))
  157       if (Optional<DWARFFormValue> CountV = C.find(DW_AT_count))
  159       if (Optional<DWARFFormValue> UpperV = C.find(DW_AT_upper_bound))
  161       if (Optional<DWARFFormValue> LV =
  163         if (Optional<uint64_t> LC = LV->getAsUnsignedConstant())
  297   } else if (Optional<uint64_t> Val = FormValue.getAsUnsignedConstant())
  334     if (Optional<uint64_t> OptVal = FormValue.getAsUnsignedConstant())
  365 Optional<DWARFFormValue> DWARFDie::find(dwarf::Attribute Attr) const {
  374 Optional<DWARFFormValue>
  388 Optional<DWARFFormValue>
  424   if (Optional<DWARFFormValue> F = find(Attr))
  440 Optional<uint64_t> DWARFDie::getRangesBaseAttribute() const {
  444 Optional<uint64_t> DWARFDie::getHighPC(uint64_t LowPC) const {
  481   Optional<DWARFFormValue> Value = find(DW_AT_ranges);
lib/DebugInfo/DWARF/DWARFExpression.cpp
  221   if (Optional<unsigned> LLVMRegNum = MRI->getLLVMRegNum(DwarfRegNum, isEH)) {
lib/DebugInfo/DWARF/DWARFFormValue.cpp
  171       if (Optional<uint8_t> FixedSize =
  408     Optional<object::SectionedAddress> A = U->getAddrOffsetSectionItem(UValue);
  576   Optional<const char *> DbgStr = getAsCString();
  585 Optional<const char *> DWARFFormValue::getAsCString() const {
  605     Optional<uint64_t> StrOffset = U->getStringOffsetSectionItem(Offset);
  622 Optional<uint64_t> DWARFFormValue::getAsAddress() const {
  628 Optional<object::SectionedAddress>
  636     Optional<object::SectionedAddress> SA = U->getAddrOffsetSectionItem(Index);
  644 Optional<uint64_t> DWARFFormValue::getAsReference() const {
  650 Optional<DWARFFormValue::UnitOffset> DWARFFormValue::getAsRelativeReference() const {
  671 Optional<uint64_t> DWARFFormValue::getAsSectionOffset() const {
  677 Optional<uint64_t> DWARFFormValue::getAsUnsignedConstant() const {
  684 Optional<int64_t> DWARFFormValue::getAsSignedConstant() const {
  703 Optional<ArrayRef<uint8_t>> DWARFFormValue::getAsBlock() const {
  710 Optional<uint64_t> DWARFFormValue::getAsCStringOffset() const {
  716 Optional<uint64_t> DWARFFormValue::getAsReferenceUVal() const {
lib/DebugInfo/DWARF/DWARFUnit.cpp
  200 Optional<object::SectionedAddress>
  222 Optional<uint64_t> DWARFUnit::getStringOffsetSectionItem(uint32_t Index) const {
  427   if (Optional<uint64_t> DWOId = toUnsigned(UnitDie.find(DW_AT_GNU_dwo_id)))
  767 llvm::Optional<object::SectionedAddress> DWARFUnit::getBaseAddress() {
  772   Optional<DWARFFormValue> PC = UnitDie.find({DW_AT_low_pc, DW_AT_entry_pc});
  856 Expected<Optional<StrOffsetsContributionDescriptor>>
  875 Expected<Optional<StrOffsetsContributionDescriptor>>
lib/DebugInfo/DWARF/DWARFVerifier.cpp
  224   Optional<DWARFFormValue> CallAttr =
  482     if (Optional<ArrayRef<uint8_t>> Expr = AttrValue.Value.getAsBlock()) {
  543     Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
  567     Optional<uint64_t> RefVal = AttrValue.Value.getAsReference();
 1281   Optional<DWARFFormValue> Location = Die.findRecursively(DW_AT_location);
 1296   if (Optional<ArrayRef<uint8_t>> Expr = Location->getAsBlock()) {
 1300   } else if (Optional<uint64_t> Offset = Location->getAsSectionOffset()) {
lib/DebugInfo/GSYM/GsymReader.cpp
  210 Optional<uint64_t> GsymReader::getAddress(size_t Index) const {
  220 Optional<uint64_t> GsymReader::getAddressInfoOffset(size_t Index) const {
  253   if (Optional<uint64_t> OptAddr = getAddress(*AddressIndex)) {
lib/DebugInfo/GSYM/InlineInfo.cpp
   56 llvm::Optional<InlineInfo::InlineArray> InlineInfo::getInlineStack(uint64_t Addr) const {
lib/DebugInfo/PDB/Native/NativeEnumTypes.cpp
   27   Optional<TypeIndex> TI = Types.getFirst();
lib/DebugInfo/PDB/Native/NativeTypeEnum.cpp
   58   Optional<TypeIndex> ContinuationIndex;
lib/DebugInfo/PDB/Native/PDBFileBuilder.cpp
  352     Optional<uint32_t> Sig = Info->getSignature();
lib/DebugInfo/PDB/Native/TpiStreamBuilder.cpp
   45                                      Optional<uint32_t> Hash) {
lib/ExecutionEngine/ExecutionEngineBindings.cpp
  203   if (Optional<CodeModel::Model> CM = unwrap(options.CodeModel, JIT))
lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp
  238     Optional<StringRef> Name;
  475       Optional<JITTargetAddress> LastCanonicalAddr;
lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.h
  106     NormalizedSymbol(Optional<StringRef> Name, uint64_t Value, uint8_t Type,
  119     Optional<StringRef> Name;
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp
  101 Optional<CompileOnDemandLayer::GlobalValueSet>
  106 Optional<CompileOnDemandLayer::GlobalValueSet>
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldCheckerImpl.h
   60   Optional<uint64_t> getSectionLoadAddress(void *LocalAddr) const;
lib/FuzzMutate/IRMutator.cpp
   95 Optional<fuzzerop::OpDescriptor>
lib/IR/AsmWriter.cpp
 1515     Optional<unsigned> InRangeOp;
 1614   void printBool(StringRef Name, bool Value, Optional<bool> Default = None);
 1690                                Optional<bool> Default) {
 4215   Optional<SlotTracker> LocalST;
lib/IR/AttributeImpl.h
  215   std::pair<unsigned, Optional<unsigned>> getAllocSizeArgs() const;
lib/IR/Attributes.cpp
   60                                   const Optional<unsigned> &NumElemsArg) {
   69 static std::pair<unsigned, Optional<unsigned>>
   74   Optional<unsigned> NumElemsArg;
  173                                 const Optional<unsigned> &NumElemsArg) {
  270 std::pair<unsigned, Optional<unsigned>> Attribute::getAllocSizeArgs() const {
  447     Optional<unsigned> NumElems;
  690 std::pair<unsigned, Optional<unsigned>> AttributeSet::getAllocSizeArgs() const {
  873 std::pair<unsigned, Optional<unsigned>>
 1277                                 const Optional<unsigned> &NumElemsArg) {
 1375 std::pair<unsigned, Optional<unsigned>>
 1516 std::pair<unsigned, Optional<unsigned>> AttrBuilder::getAllocSizeArgs() const {
 1561                                            const Optional<unsigned> &NumElems) {
lib/IR/BasicBlock.cpp
  479 Optional<uint64_t> BasicBlock::getIrrLoopHeaderWeight() const {
lib/IR/ConstantFold.cpp
 2166                                           Optional<unsigned> InRangeIndex,
 2290         Optional<unsigned> IRIndex = cast<GEPOperator>(CE)->getInRangeIndex();
lib/IR/ConstantFold.h
   52                                       Optional<unsigned> InRangeIndex,
lib/IR/Constants.cpp
 2009                                          Optional<unsigned> InRangeIndex,
lib/IR/DIBuilder.cpp
  214                               Optional<DIFile::ChecksumInfo<StringRef>> CS,
  215                               Optional<StringRef> Source) {
  276     Optional<unsigned> DWARFAddressSpace,
  299     Optional<unsigned> DWARFAddressSpace) {
lib/IR/DebugInfoMetadata.cpp
  117 Optional<unsigned> DILocation::encodeDiscriminator(unsigned BD, unsigned DF, unsigned CI) {
  354 Optional<DIBasicType::Signedness> DIBasicType::getSignedness() const {
  371     Optional<unsigned> DWARFAddressSpace, DIFlags Flags, Metadata *ExtraData,
  491 Optional<DIFile::ChecksumKind> DIFile::getChecksumKind(StringRef CSKindStr) {
  500                         Optional<DIFile::ChecksumInfo<MDString *>> CS,
  501                         Optional<MDString *> Source, StorageType Storage,
  539 Optional<DICompileUnit::DebugEmissionKind>
  549 Optional<DICompileUnit::DebugNameTableKind>
  788 Optional<uint64_t> DIVariable::getSizeInBits() const {
  967 Optional<DIExpression::FragmentInfo>
 1117   Optional<FragmentInfo> FI = Expr->getFragmentInfo();
 1136 Optional<DIExpression *> DIExpression::createFragmentExpression(
lib/IR/Function.cpp
 1389 Optional<Function*> Intrinsic::remangleIntrinsicFunction(Function *F) {
 1587 Optional<StringRef> Function::getSectionPrefix() const {
lib/IR/Globals.cpp
  302 Optional<ConstantRange> GlobalValue::getAbsoluteSymbolRange() const {
lib/IR/Instructions.cpp
   53 Optional<uint64_t>
lib/IR/IntrinsicInst.cpp
   53 Optional<uint64_t> DbgVariableIntrinsic::getFragmentSizeInBits() const {
  105 Optional<ConstrainedFPIntrinsic::RoundingMode>
  115 Optional<ConstrainedFPIntrinsic::RoundingMode>
  128 Optional<StringRef>
  130   Optional<StringRef> RoundingStr = None;
  151 Optional<ConstrainedFPIntrinsic::ExceptionBehavior>
  161 Optional<ConstrainedFPIntrinsic::ExceptionBehavior>
  170 Optional<StringRef>
  172   Optional<StringRef> ExceptStr = None;
lib/IR/LLVMContextImpl.h
  415   Optional<unsigned> DWARFAddressSpace;
  422                 Optional<unsigned> DWARFAddressSpace, unsigned Flags,
  582   Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
  583   Optional<MDString *> Source;
  586                 Optional<DIFile::ChecksumInfo<MDString *>> Checksum,
  587                 Optional<MDString *> Source)
 1283   Optional<DenseMap<const MDString *, DICompositeType *>> DITypeMap;
lib/IR/Module.cpp
  516 Optional<CodeModel::Model> Module::getCodeModel() const {
lib/IR/PassManager.cpp
   56     Optional<PreservedAnalyses> FunctionPA;
lib/IR/RemarkStreamer.cpp
   33     Optional<StringRef> FilenameIn)
   71 static Optional<remarks::RemarkLocation>
  104   if (Optional<Regex> &Filter = PassFilter)
lib/IR/Verifier.cpp
 1026   Optional<DIFile::ChecksumInfo<StringRef>> Checksum = N.getChecksum();
 1820     std::pair<unsigned, Optional<unsigned>> Args =
 5268   Optional<APInt> PrevOffset;
lib/LTO/LTO.cpp
 1058   Optional<Error> Err;
lib/LTO/LTOBackend.cpp
  142   Optional<CodeModel::Model> CodeModel;
  157   Optional<PGOOptions> PGOOpt;
lib/LineEditor/LineEditor.cpp
  256 Optional<std::string> LineEditor::readLine() const {
lib/Linker/IRMover.cpp
  426   Optional<Error> FoundError;
lib/MC/MCAsmBackend.cpp
   65 Optional<MCFixupKind> MCAsmBackend::getFixupKind(StringRef Name) const {
lib/MC/MCAsmStreamer.cpp
  231                                                Optional<MD5::MD5Result> Checksum = None,
  232                                                Optional<StringRef> Source = None,
  235                                Optional<MD5::MD5Result> Checksum,
  236                                Optional<StringRef> Source,
 1210                                     Optional<MD5::MD5Result> Checksum,
 1211                                     Optional<StringRef> Source,
 1243     Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source, unsigned CUID) {
 1243     Optional<MD5::MD5Result> Checksum, Optional<StringRef> Source, unsigned CUID) {
 1272                                             Optional<MD5::MD5Result> Checksum,
 1273                                             Optional<StringRef> Source,
 1538     if (Optional<unsigned> LLVMRegister = MRI->getLLVMRegNum(Register, true)) {
lib/MC/MCContext.cpp
  610   Optional<MD5::MD5Result> Cksum;
  650                                            Optional<MD5::MD5Result> Checksum,
  651                                            Optional<StringRef> Source,
lib/MC/MCDwarf.cpp
  244   Optional<MCDwarfLineStr> LineStr;
  264   Optional<MCDwarfLineStr> NoLineStr(None);
  271                              Optional<MCDwarfLineStr> &LineStr) const {
  354                                Optional<MCDwarfLineStr> &LineStr) {
  381     MCStreamer *MCOS, Optional<MCDwarfLineStr> &LineStr) const {
  450                              Optional<MCDwarfLineStr> &LineStr) const {
  525                               Optional<MCDwarfLineStr> &LineStr) const {
  539                                                 Optional<MD5::MD5Result> Checksum,
  540                                                 Optional<StringRef> Source,
  548                        StringRef &FileName, Optional<MD5::MD5Result> Checksum) {
  557                                    Optional<MD5::MD5Result> Checksum,
  558                                    Optional<StringRef> Source,
lib/MC/MCInstrAnalysis.cpp
   37 Optional<uint64_t>
lib/MC/MCObjectStreamer.cpp
   84 static Optional<uint64_t>
  100   if (Optional<uint64_t> Diff = absoluteSymbolDiff(getAssembler(), Hi, Lo)) {
  109   if (Optional<uint64_t> Diff = absoluteSymbolDiff(getAssembler(), Hi, Lo)) {
  630   Optional<MCFixupKind> MaybeKind = Assembler->getBackend().getFixupKind(Name);
lib/MC/MCParser/AsmParser.cpp
 3395   Optional<StringRef> Source;
 3439     Optional<MD5::MD5Result> CKMem;
lib/MC/MCRegisterInfo.cpp
   81 Optional<unsigned> MCRegisterInfo::getLLVMRegNum(unsigned RegNum,
  104   if (Optional<unsigned> LRegNum = getLLVMRegNum(RegNum, true))
lib/MC/MCSchedule.cpp
   90   Optional<double> Throughput;
  136   Optional<double> Throughput;
lib/MC/MCStreamer.cpp
  215                                       Optional<MD5::MD5Result> Checksum,
  216                                       Optional<StringRef> Source,
  224                                          Optional<MD5::MD5Result> Checksum,
  225                                          Optional<StringRef> Source,
lib/MC/MCSubtargetInfo.cpp
  319 Optional<unsigned> MCSubtargetInfo::getCacheSize(unsigned Level) const {
  323 Optional<unsigned>
  328 Optional<unsigned> MCSubtargetInfo::getCacheLineSize(unsigned Level) const {
lib/Object/Archive.cpp
  976 Expected<Optional<Archive::Child>> Archive::findSym(StringRef name) const {
lib/Object/ELFObjectFile.cpp
  408   Optional<SectionRef> Plt = None, RelaPlt = None, GotPlt = None;
lib/Object/Minidump.cpp
   17 Optional<ArrayRef<uint8_t>>
   58   Optional<ArrayRef<uint8_t>> Stream = getRawStream(StreamType::MemoryInfoList);
   76   Optional<ArrayRef<uint8_t>> Stream = getRawStream(Type);
lib/ObjectYAML/COFFEmitter.cpp
  459     for (const Optional<COFF::DataDirectory> &DD :
lib/ObjectYAML/ELFEmitter.cpp
  474                              const Optional<yaml::BinaryRef> &Content,
  475                              const Optional<llvm::yaml::Hex64> &Size) {
lib/ObjectYAML/ELFYAML.cpp
  870   NormalizedOther(IO &IO, Optional<uint8_t> Original) : YamlIO(IO) {
  910   Optional<uint8_t> denormalize(IO &) {
  953   Optional<std::vector<StOtherPiece>> Other;
  974   MappingNormalization<NormalizedOther, Optional<uint8_t>> Keys(IO,
lib/ObjectYAML/MinidumpEmitter.cpp
  176   Optional<size_t> DataEnd;
lib/Passes/PassBuilder.cpp
 1385 static Optional<int> parseRepeatPassName(StringRef Name) {
 1394 static Optional<int> parseDevirtPassName(StringRef Name) {
 1750 Optional<std::vector<PassBuilder::PipelineElement>>
lib/Passes/StandardInstrumentations.cpp
   34 Optional<std::pair<const Module *, std::string>> unwrapModule(Any IR) {
lib/ProfileData/Coverage/CoverageMapping.cpp
  412   void completeRegionsUntil(Optional<LineColPair> Loc,
  623 static Optional<unsigned> findMainViewFileID(const FunctionRecord &Function) {
  636 static Optional<unsigned> findMainViewFileID(StringRef SourceFile,
  638   Optional<unsigned> I = findMainViewFileID(Function);
lib/Remarks/BitstreamRemarkParser.cpp
  233   Expected<Optional<BitstreamBlockInfo>> MaybeBlockInfo =
  309     StringRef Buf, Optional<ParsedStringTable> StrTab,
  310     Optional<StringRef> ExternalFilePrependPath) {
  368   if (Optional<uint64_t> Version = MetaHelper.ContainerVersion)
  375   if (Optional<uint8_t> Type = MetaHelper.ContainerType) {
  392                            Optional<StringRef> StrTabBuf) {
  403                                   Optional<uint64_t> RemarkVersion) {
  413     Optional<StringRef> ExternalFilePath) {
lib/Remarks/BitstreamRemarkParser.h
   32   Optional<ParsedStringTable> StrTab;
   73   Error processExternalFilePath(Optional<StringRef> ExternalFilePath);
   77     StringRef Buf, Optional<ParsedStringTable> StrTab = None,
   78     Optional<StringRef> ExternalFilePrependPath = None);
lib/Remarks/BitstreamRemarkSerializer.cpp
  234     uint64_t ContainerVersion, Optional<uint64_t> RemarkVersion,
  235     Optional<const StringTable *> StrTab, Optional<StringRef> Filename) {
  235     Optional<const StringTable *> StrTab, Optional<StringRef> Filename) {
  280   if (const Optional<RemarkLocation> &Loc = Remark.Loc) {
  289   if (Optional<uint64_t> Hotness = Remark.Hotness) {
  369     raw_ostream &OS, Optional<StringRef> ExternalFilename) {
lib/Remarks/Remark.cpp
   64   if (const Optional<RemarkLocation> &Loc = unwrap(Arg)->Loc)
   95   if (const Optional<RemarkLocation> &Loc = unwrap(Remark)->Loc)
  101   if (const Optional<uint64_t> &Hotness = unwrap(Remark)->Hotness)
lib/Remarks/RemarkParser.cpp
   90     Format ParserFormat, StringRef Buf, Optional<ParsedStringTable> StrTab,
   91     Optional<StringRef> ExternalFilePrependPath) {
  113   Optional<std::string> Err;
  116           Optional<ParsedStringTable> StrTab = None)
lib/Remarks/YAMLRemarkParser.cpp
  113                                   Optional<ParsedStringTable> StrTab,
  114                                   Optional<StringRef> ExternalFilePrependPath) {
  174                                    Optional<ParsedStringTable> StrTab)
  326   Optional<StringRef> File;
  327   Optional<unsigned> Line;
  328   Optional<unsigned> Column;
  368   Optional<StringRef> KeyStr;
  369   Optional<StringRef> ValueStr;
  370   Optional<RemarkLocation> Loc;
lib/Remarks/YAMLRemarkParser.h
   52   Optional<ParsedStringTable> StrTab;
   75   YAMLRemarkParser(StringRef Buf, Optional<ParsedStringTable> StrTab);
  114                          Optional<ParsedStringTable> StrTab = None,
  115                          Optional<StringRef> ExternalFilePrependPath = None);
lib/Remarks/YAMLRemarkSerializer.cpp
   24                             Optional<RemarkLocation> RL, T FunctionName,
   25                             Optional<uint64_t> Hotness,
  162                                            Optional<StringTable> StrTabIn)
  167                                            Optional<StringTable> StrTabIn)
  182                                      Optional<StringRef> ExternalFilename) {
  201     raw_ostream &OS, Optional<StringRef> ExternalFilename) {
  221 static void emitStrTab(raw_ostream &OS, Optional<const StringTable *> StrTab) {
lib/Support/APInt.cpp
 2840 Optional<APInt>
 3030 Optional<unsigned>
lib/Support/BinaryStreamRef.cpp
   70                                  Optional<uint32_t> Length)
  108                                                  Optional<uint32_t> Length)
lib/Support/CommandLine.cpp
 1202   llvm::Optional<std::string> envValue = sys::Process::GetEnv(StringRef(envVar));
 1231     if (llvm::Optional<std::string> EnvValue =
lib/Support/DJB.cpp
   60 static Optional<uint32_t> fastCaseFoldingDjbHash(StringRef Buffer, uint32_t H) {
   72   if (Optional<uint32_t> Result = fastCaseFoldingDjbHash(Buffer, H))
lib/Support/FileCheck.cpp
   29   Optional<uint64_t> Value = NumericVariable->getValue();
  119     Optional<size_t> LineNumber, const SourceMgr &SM) {
  153                                           Optional<size_t> LineNumber,
  177   Optional<size_t> DefLineNumber = NumericVariable->getDefLineNumber();
  189                                       Optional<size_t> LineNumber,
  225     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
  269     Optional<FileCheckNumericVariable *> &DefinedNumericVariable,
  270     bool IsLegacyLineExpr, Optional<size_t> LineNumber,
  491       Optional<FileCheckNumericVariable *> DefinedNumericVariable;
 1833       Optional<FileCheckNumericVariable *> DefinedNumericVariable;
lib/Support/FileCheckImpl.h
   88   Optional<uint64_t> Value;
   93   Optional<size_t> DefLineNumber;
   99                                     Optional<size_t> DefLineNumber = None)
  106   Optional<uint64_t> getValue() const { return Value; }
  117   Optional<size_t> getDefLineNumber() { return DefLineNumber; }
  429   Optional<size_t> LineNumber;
  436                    Optional<size_t> Line = None)
  475       Optional<FileCheckNumericVariable *> &DefinedNumericVariable,
  476       bool IsLegacyLineExpr, Optional<size_t> LineNumber,
  538       Optional<size_t> LineNumber, const SourceMgr &SM);
  547                           Optional<size_t> LineNumber,
  560                       Optional<size_t> LineNumber,
  571              bool IsLegacyLineExpr, Optional<size_t> LineNumber,
lib/Support/FormatVariadic.cpp
   12 static Optional<AlignStyle> translateLocChar(char C) {
   56 Optional<ReplacementItem>
lib/Support/JSON.cpp
   35 llvm::Optional<std::nullptr_t> Object::getNull(StringRef K) const {
   40 llvm::Optional<bool> Object::getBoolean(StringRef K) const {
   45 llvm::Optional<double> Object::getNumber(StringRef K) const {
   50 llvm::Optional<int64_t> Object::getInteger(StringRef K) const {
   55 llvm::Optional<llvm::StringRef> Object::getString(StringRef K) const {
  250   Optional<Error> Err;
lib/Support/LockFileManager.cpp
   50 Optional<std::pair<std::string, int> >
lib/Support/NativeFormatting.cpp
  134                      Optional<size_t> Width) {
  164                         Optional<size_t> Precision) {
lib/Support/Process.cpp
   30 Optional<std::string> Process::FindInEnvPath(StringRef EnvName,
   35 Optional<std::string> Process::FindInEnvPath(StringRef EnvName,
   39   Optional<std::string> FoundPath;
   40   Optional<std::string> OptPath = Process::GetEnv(EnvName);
lib/Support/Program.cpp
   26                     ArrayRef<StringRef> Args, Optional<ArrayRef<StringRef>> Env,
   27                     ArrayRef<Optional<StringRef>> Redirects,
   31                         Optional<ArrayRef<StringRef>> Env,
   32                         ArrayRef<Optional<StringRef>> Redirects,
   52                                Optional<ArrayRef<StringRef>> Env,
   53                                ArrayRef<Optional<StringRef>> Redirects,
lib/Support/Signals.cpp
  158   Optional<StringRef> Redirects[] = {StringRef(InputFile),
lib/Support/SymbolRemappingReader.cpp
   50     Optional<FK> FragmentKind = StringSwitch<Optional<FK>>(Parts[0])
lib/Support/Threading.cpp
  127                                   llvm::Optional<unsigned> StackSizeInBytes) {
  136     llvm::Optional<unsigned> StackSizeInBytes) {
lib/Support/Unix/Process.inc
  166 Optional<std::string> Process::GetEnv(StringRef Name) {
lib/Support/Unix/Program.inc
   96 static bool RedirectIO(Optional<StringRef> Path, int FD, std::string* ErrMsg) {
  177                     ArrayRef<StringRef> Args, Optional<ArrayRef<StringRef>> Env,
  178                     ArrayRef<Optional<StringRef>> Redirects,
lib/Support/Unix/Threading.inc
   59                             llvm::Optional<unsigned> StackSizeInBytes,
lib/Support/VersionTuple.cpp
   29   if (Optional<unsigned> Minor = V.getMinor())
   31   if (Optional<unsigned> Subminor = V.getSubminor())
   33   if (Optional<unsigned> Build = V.getBuild())
lib/Support/VirtualFileSystem.cpp
  282   Optional<WorkingDirectory> WD;
  694                                  Optional<uint32_t> User,
  695                                  Optional<uint32_t> Group,
  696                                  Optional<llvm::sys::fs::file_type> Type,
  697                                  Optional<llvm::sys::fs::perms> Perms,
  785                                  Optional<uint32_t> User,
  786                                  Optional<uint32_t> Group,
  787                                  Optional<llvm::sys::fs::file_type> Type,
  788                                  Optional<llvm::sys::fs::perms> Perms) {
  795                                       Optional<uint32_t> User,
  796                                       Optional<uint32_t> Group,
  797                                       Optional<llvm::sys::fs::file_type> Type,
  798                                       Optional<llvm::sys::fs::perms> Perms) {
 1899   void write(ArrayRef<YAMLVFSEntry> Entries, Optional<bool> UseExternalNames,
 1900              Optional<bool> IsCaseSensitive, Optional<bool> IsOverlayRelative,
 1900              Optional<bool> IsCaseSensitive, Optional<bool> IsOverlayRelative,
 1956                        Optional<bool> UseExternalNames,
 1957                        Optional<bool> IsCaseSensitive,
 1958                        Optional<bool> IsOverlayRelative,
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp
  236 static Optional<LoadInfo> getLoadInfo(const MachineInstr &MI) {
  658 static Optional<unsigned> getTag(const TargetRegisterInfo *TRI,
  681       Optional<LoadInfo> LInfo = getLoadInfo(MI);
  684       Optional<unsigned> Tag = getTag(TRI, MI, *LInfo);
  721       Optional<LoadInfo> OptLdI = getLoadInfo(MI);
  725       Optional<unsigned> OptOldTag = getTag(TRI, MI, LdI);
lib/Target/AArch64/AArch64InstrInfo.cpp
 1742 Optional<unsigned> AArch64InstrInfo::getUnscaledLdSt(unsigned Opc) {
 3421   Optional<unsigned> UnscaledOp =
lib/Target/AArch64/AArch64InstrInfo.h
   90   static Optional<unsigned> getUnscaledLdSt(unsigned Opc);
lib/Target/AArch64/AArch64InstructionSelector.cpp
  109   MachineInstr *emitLaneInsert(Optional<Register> DstReg, Register SrcReg,
  138   MachineInstr *emitVectorConcat(Optional<Register> Dst, Register Op1,
  150   MachineInstr *emitExtractVectorElt(Optional<Register> DstReg,
 2805     Optional<Register> DstReg, const RegisterBank &DstRB, LLT ScalarTy,
 3272     Optional<Register> Dst, Register Op1, Register Op2,
 3743     Optional<Register> DstReg, Register SrcReg, Register EltReg,
 4014 static Optional<uint64_t> getImmedFromMO(const MachineOperand &Root) {
 4536   Optional<uint64_t> MaybeAndMask = getImmedFromMO(MI.getOperand(2));
 4591     Optional<uint64_t> MaybeShiftVal = getImmedFromMO(RHS);
 4639   Optional<int64_t> CstVal = getConstantVRegVal(MI.getOperand(0).getReg(), MRI);
lib/Target/AArch64/AArch64MachineFunctionInfo.h
  112   Optional<bool> HasRedZone;
  226   Optional<bool> hasRedZone() const { return HasRedZone; }
lib/Target/AArch64/AArch64StackTagging.cpp
  362       Optional<int64_t> Offset =
  380       Optional<int64_t> Offset = isPointerOffset(StartPtr, MSI->getDest(), *DL);
lib/Target/AArch64/AArch64TargetMachine.cpp
  220                                            Optional<Reloc::Model> RM) {
  233 getEffectiveAArch64CodeModel(const Triple &TT, Optional<CodeModel::Model> CM,
  261                                            Optional<Reloc::Model> RM,
  262                                            Optional<CodeModel::Model> CM,
  333     const TargetOptions &Options, Optional<Reloc::Model> RM,
  334     Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT)
  341     const TargetOptions &Options, Optional<Reloc::Model> RM,
  342     Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT)
lib/Target/AArch64/AArch64TargetMachine.h
   33                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   33                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   63                          Optional<Reloc::Model> RM,
   64                          Optional<CodeModel::Model> CM, CodeGenOpt::Level OL,
   75                          Optional<Reloc::Model> RM,
   76                          Optional<CodeModel::Model> CM, CodeGenOpt::Level OL,
lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
  772   Optional<std::pair<int64_t, unsigned> > getShiftedVal() const {
 2128 static Optional<std::pair<int, int>> parseVectorKind(StringRef Suffix,
lib/Target/AArch64/MCTargetDesc/AArch64AsmBackend.cpp
   47   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
  323 Optional<MCFixupKind> AArch64AsmBackend::getFixupKind(StringRef Name) const {
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
  345   Optional<uint32_t> NumAGPR,
lib/Target/AMDGPU/AMDGPUAsmPrinter.h
   82                                   Optional<uint32_t> NumAGPR,
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp
  515 Optional<StringRef>
  524 Optional<StringRef>
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h
   61   Optional<StringRef> getAccessQualifier(StringRef AccQual) const;
   63   Optional<StringRef> getAddressSpaceQualifier(unsigned AddressSpace) const;
lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp
 1967   Optional<int64_t> Offset =
 2041   Optional<int> FI;
 2181   Optional<int64_t> CstVal = getConstantVRegVal(MI.getOperand(0).getReg(), MRI);
lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp
 1497   Optional<int64_t> IdxVal = getConstantVRegVal(MI.getOperand(2).getReg(), MRI);
 1526   Optional<int64_t> IdxVal = getConstantVRegVal(MI.getOperand(3).getReg(), MRI);
lib/Target/AMDGPU/AMDGPUMachineModuleInfo.h
   55   Optional<uint8_t> getSyncScopeInclusionOrdering(SyncScope::ID SSID) const {
  129   Optional<bool> isSyncScopeInclusion(SyncScope::ID A, SyncScope::ID B) const {
lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
  347 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
  356                                          Optional<Reloc::Model> RM,
  357                                          Optional<CodeModel::Model> CM,
  461                                      Optional<Reloc::Model> RM,
  462                                      Optional<CodeModel::Model> CM,
  505                                    Optional<Reloc::Model> RM,
  506                                    Optional<CodeModel::Model> CM,
lib/Target/AMDGPU/AMDGPUTargetMachine.h
   45                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   45                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   76                     Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   76                     Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
  101                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
  101                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp
 1037                           Optional<bool> EnableWavefrontSize32, unsigned NextFreeVGPR,
 1083   Optional<StringRef> getGprCountSymbolName(RegisterKind RegKind);
 2268 Optional<StringRef>
 3609     bool XNACKUsed, Optional<bool> EnableWavefrontSize32, unsigned NextFreeVGPR,
 3672   Optional<bool> EnableWavefrontSize32;
lib/Target/AMDGPU/SIFrameLowering.cpp
  929                                  Optional<int> FramePointerSaveIndex) {
lib/Target/AMDGPU/SILoadStoreOptimizer.cpp
  237   Optional<int32_t> extractConstOffset(const MachineOperand &Op) const;
 1436 Optional<int32_t>
lib/Target/AMDGPU/SIMachineFunctionInfo.cpp
  299       Optional<int> CSRSpillFI;
  428 static Optional<yaml::SIArgumentInfo>
lib/Target/AMDGPU/SIMachineFunctionInfo.h
  124   Optional<unsigned> Mask;
  187   Optional<SIArgument> PrivateSegmentBuffer;
  188   Optional<SIArgument> DispatchPtr;
  189   Optional<SIArgument> QueuePtr;
  190   Optional<SIArgument> KernargSegmentPtr;
  191   Optional<SIArgument> DispatchID;
  192   Optional<SIArgument> FlatScratchInit;
  193   Optional<SIArgument> PrivateSegmentSize;
  195   Optional<SIArgument> WorkGroupIDX;
  196   Optional<SIArgument> WorkGroupIDY;
  197   Optional<SIArgument> WorkGroupIDZ;
  198   Optional<SIArgument> WorkGroupInfo;
  199   Optional<SIArgument> PrivateSegmentWaveByteOffset;
  201   Optional<SIArgument> ImplicitArgPtr;
  202   Optional<SIArgument> ImplicitBufferPtr;
  204   Optional<SIArgument> WorkItemIDX;
  205   Optional<SIArgument> WorkItemIDY;
  206   Optional<SIArgument> WorkItemIDZ;
  275   Optional<SIArgumentInfo> ArgInfo;
  443     Optional<int> FI;
  445     SGPRSpillVGPRCSR(unsigned V, Optional<int> F) : VGPR(V), FI(F) {}
  479   Optional<int> FramePointerSaveIndex;
lib/Target/AMDGPU/SIMemoryLegalizer.cpp
  214   Optional<std::tuple<SIAtomicScope, SIAtomicAddrSpace, bool>>
  222   Optional<SIMemOpInfo> constructFromMIWithMMO(
  231   Optional<SIMemOpInfo> getLoadInfo(
  235   Optional<SIMemOpInfo> getStoreInfo(
  240   Optional<SIMemOpInfo> getAtomicFenceInfo(
  245   Optional<SIMemOpInfo> getAtomicCmpxchgOrRmwInfo(
  451 Optional<std::tuple<SIAtomicScope, SIAtomicAddrSpace, bool>>
  516 Optional<SIMemOpInfo> SIMemOpAccess::constructFromMIWithMMO(
  575 Optional<SIMemOpInfo> SIMemOpAccess::getLoadInfo(
  589 Optional<SIMemOpInfo> SIMemOpAccess::getStoreInfo(
  603 Optional<SIMemOpInfo> SIMemOpAccess::getAtomicFenceInfo(
  636 Optional<SIMemOpInfo> SIMemOpAccess::getAtomicCmpxchgOrRmwInfo(
lib/Target/AMDGPU/SIPeepholeSDWA.cpp
   80   Optional<int64_t> foldToImm(const MachineOperand &Op) const;
  522 Optional<int64_t> SIPeepholeSDWA::foldToImm(const MachineOperand &Op) const {
  728     using CheckRetType = Optional<std::pair<MachineOperand *, MachineOperand *>>;
lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
  427                              Optional<bool> EnableWavefrontSize32) {
  435                                 Optional<bool> EnableWavefrontSize32) {
  470                           Optional<bool> EnableWavefrontSize32) {
lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h
  157                              Optional<bool> EnableWavefrontSize32 = None);
  164                                 Optional<bool> EnableWavefrontSize32 = None);
  186                           Optional<bool> EnableWavefrontSize32 = None);
lib/Target/ARC/ARCTargetMachine.cpp
   23 static Reloc::Model getRelocModel(Optional<Reloc::Model> RM) {
   33                                    Optional<Reloc::Model> RM,
   34                                    Optional<CodeModel::Model> CM,
lib/Target/ARC/ARCTargetMachine.h
   30                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   30                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/ARM/ARMISelDAGToDAG.cpp
 2836 static Optional<std::pair<unsigned, unsigned>>
lib/Target/ARM/ARMTargetMachine.cpp
  189                                            Optional<Reloc::Model> RM) {
  210                                            Optional<Reloc::Model> RM,
  211                                            Optional<CodeModel::Model> CM,
  306                                        Optional<Reloc::Model> RM,
  307                                        Optional<CodeModel::Model> CM,
  314                                        Optional<Reloc::Model> RM,
  315                                        Optional<CodeModel::Model> CM,
lib/Target/ARM/ARMTargetMachine.h
   44                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   44                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   81                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   81                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   91                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   91                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
   50 Optional<MCFixupKind> ARMAsmBackend::getFixupKind(StringRef Name) const {
lib/Target/ARM/MCTargetDesc/ARMAsmBackend.h
   40   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
lib/Target/AVR/AVRTargetMachine.cpp
   39 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
   46                                    Optional<Reloc::Model> RM,
   47                                    Optional<CodeModel::Model> CM,
lib/Target/AVR/AVRTargetMachine.h
   32                    Optional<Reloc::Model> RM,
   33                    Optional<CodeModel::Model> CM,
lib/Target/BPF/BPFTargetMachine.cpp
   50 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
   59                                    Optional<Reloc::Model> RM,
   60                                    Optional<CodeModel::Model> CM,
lib/Target/BPF/BPFTargetMachine.h
   27                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   27                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/Hexagon/HexagonFrameLowering.cpp
  840 static Optional<MachineBasicBlock::iterator>
lib/Target/Hexagon/HexagonInstrInfo.cpp
  705   Optional<bool>
lib/Target/Hexagon/HexagonTargetMachine.cpp
  177 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
  207                                            Optional<Reloc::Model> RM,
  208                                            Optional<CodeModel::Model> CM,
lib/Target/Hexagon/HexagonTargetMachine.h
   32                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   32                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/Lanai/LanaiTargetMachine.cpp
   50 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
   59                                        Optional<Reloc::Model> RM,
   60                                        Optional<CodeModel::Model> CodeModel,
lib/Target/Lanai/LanaiTargetMachine.h
   35                      Optional<Reloc::Model> RelocationModel,
   36                      Optional<CodeModel::Model> CodeModel,
lib/Target/MSP430/MSP430TargetMachine.cpp
   29 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
   43                                          Optional<Reloc::Model> RM,
   44                                          Optional<CodeModel::Model> CM,
lib/Target/MSP430/MSP430TargetMachine.h
   32                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   32                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/Mips/MCTargetDesc/MipsAsmBackend.cpp
  303 Optional<MCFixupKind> MipsAsmBackend::getFixupKind(StringRef Name) const {
lib/Target/Mips/MCTargetDesc/MipsAsmBackend.h
   48   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
lib/Target/Mips/MipsTargetMachine.cpp
   99                                            Optional<Reloc::Model> RM) {
  113                                      Optional<Reloc::Model> RM,
  114                                      Optional<CodeModel::Model> CM,
  142                                          Optional<Reloc::Model> RM,
  143                                          Optional<CodeModel::Model> CM,
  152                                          Optional<Reloc::Model> RM,
  153                                          Optional<CodeModel::Model> CM,
lib/Target/Mips/MipsTargetMachine.h
   42                     Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   42                     Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   78                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   78                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   90                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   90                       Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/Mips/MipsTargetStreamer.h
  187   llvm::Optional<MipsABIInfo> ABI;
lib/Target/NVPTX/NVPTXISelDAGToDAG.cpp
  811 static Optional<unsigned> pickOpcodeForVT(
  813     unsigned Opcode_i32, Optional<unsigned> Opcode_i64, unsigned Opcode_f16,
  814     unsigned Opcode_f16x2, unsigned Opcode_f32, Optional<unsigned> Opcode_f64) {
  913   Optional<unsigned> Opcode;
  996   Optional<unsigned> Opcode;
 1262   Optional<unsigned> Opcode;
 1771   Optional<unsigned> Opcode;
 1874   Optional<unsigned> Opcode;
 2119   Optional<unsigned> Opcode;
 2204   Optional<unsigned> Opcode = 0;
 2281   Optional<unsigned> Opcode = 0;
lib/Target/NVPTX/NVPTXISelLowering.cpp
 1761   SmallVector<Optional<MVT>, 16> ProxyRegTruncates;
lib/Target/NVPTX/NVPTXTargetMachine.cpp
  110                                        Optional<Reloc::Model> RM,
  111                                        Optional<CodeModel::Model> CM,
  137                                            Optional<Reloc::Model> RM,
  138                                            Optional<CodeModel::Model> CM,
  147                                            Optional<Reloc::Model> RM,
  148                                            Optional<CodeModel::Model> CM,
lib/Target/NVPTX/NVPTXTargetMachine.h
   40                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   40                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   80                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   80                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   89                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   89                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp
  229   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
  245 Optional<MCFixupKind> ELFPPCAsmBackend::getFixupKind(StringRef Name) const {
lib/Target/PowerPC/PPCFastISel.cpp
  205 static Optional<PPC::Predicate> getComparePred(CmpInst::Predicate Pred) {
  778       Optional<PPC::Predicate> OptPPCPred = getComparePred(CI->getPredicate());
lib/Target/PowerPC/PPCInstrInfo.cpp
 4184   Optional<bool>
lib/Target/PowerPC/PPCTargetMachine.cpp
  226                                            Optional<Reloc::Model> RM) {
  243                                                  Optional<CodeModel::Model> CM,
  297                                    Optional<Reloc::Model> RM,
  298                                    Optional<CodeModel::Model> CM,
lib/Target/PowerPC/PPCTargetMachine.h
   37                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   37                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/RISCV/RISCVTargetMachine.cpp
   51                                            Optional<Reloc::Model> RM) {
   60                                        Optional<Reloc::Model> RM,
   61                                        Optional<CodeModel::Model> CM,
lib/Target/RISCV/RISCVTargetMachine.h
   30                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   30                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/Sparc/SparcTargetMachine.cpp
   57 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
   74 getEffectiveSparcCodeModel(Optional<CodeModel::Model> CM, Reloc::Model RM,
   94     const TargetOptions &Options, Optional<Reloc::Model> RM,
   95     Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT, bool is64bit)
  195                                            Optional<Reloc::Model> RM,
  196                                            Optional<CodeModel::Model> CM,
  205                                            Optional<Reloc::Model> RM,
  206                                            Optional<CodeModel::Model> CM,
  215                                            Optional<Reloc::Model> RM,
  216                                            Optional<CodeModel::Model> CM,
lib/Target/Sparc/SparcTargetMachine.h
   30                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   30                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   51                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   51                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   62                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   62                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   72                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   72                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/SystemZ/SystemZTargetMachine.cpp
   94 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
  132 getEffectiveSystemZCodeModel(Optional<CodeModel::Model> CM, Reloc::Model RM,
  149                                            Optional<Reloc::Model> RM,
  150                                            Optional<CodeModel::Model> CM,
lib/Target/SystemZ/SystemZTargetMachine.h
   34                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   34                        Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/TargetMachineC.cpp
  106   Optional<Reloc::Model> RM;
  131   Optional<CodeModel::Model> CM = unwrap(CodeModel, JIT);
lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp
  296   Optional<wasm::ValType> parseType(const StringRef &Type) {
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp
  420     Optional<unsigned> NEltArg;
lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
   86 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM,
  109     const TargetOptions &Options, Optional<Reloc::Model> RM,
  110     Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT)
lib/Target/WebAssembly/WebAssemblyTargetMachine.h
   30                            Optional<Reloc::Model> RM,
   31                            Optional<CodeModel::Model> CM, CodeGenOpt::Level OL,
lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
   82   Optional<MCFixupKind> getFixupKind(StringRef Name) const override;
  246 Optional<MCFixupKind> X86AsmBackend::getFixupKind(StringRef Name) const {
  446   Optional<MCFixupKind> getFixupKind(StringRef Name) const override {
lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp
  407   Optional<uint64_t> evaluateMemoryOperandAddress(const MCInst &Inst,
  525 Optional<uint64_t> X86MCInstrAnalysis::evaluateMemoryOperandAddress(
lib/Target/X86/X86DiscriminateMemOps.cpp
  145         Optional<unsigned> EncodedDiscriminator = DILocation::encodeDiscriminator(
lib/Target/X86/X86ISelDAGToDAG.cpp
 2386   Optional<ConstantRange> CR =
 2575   Optional<ConstantRange> CR = GA->getGlobal()->getAbsoluteSymbolRange();
 2632   Optional<ConstantRange> CR = GA->getGlobal()->getAbsoluteSymbolRange();
lib/Target/X86/X86InstrInfo.cpp
 7561 Optional<ParamLoadedValue>
lib/Target/X86/X86InstrInfo.h
  525   Optional<ParamLoadedValue>
lib/Target/X86/X86MCInstLower.cpp
   62   Optional<MCOperand> LowerMachineOperand(const MachineInstr *MI,
  397 Optional<MCOperand>
lib/Target/X86/X86SpeculativeLoadHardening.cpp
  166   Optional<PredState> PS;
 2227   while (Optional<MachineInstr *> SingleUse = SinkCheckToSingleUse(*MI)) {
lib/Target/X86/X86Subtarget.cpp
  130     if (Optional<ConstantRange> CR = GV->getAbsoluteSymbolRange()) {
lib/Target/X86/X86TargetMachine.cpp
  160                                            Optional<Reloc::Model> RM) {
  200 static CodeModel::Model getEffectiveX86CodeModel(Optional<CodeModel::Model> CM,
  217                                    Optional<Reloc::Model> RM,
  218                                    Optional<CodeModel::Model> CM,
lib/Target/X86/X86TargetMachine.h
   37                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   37                    Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Target/X86/X86TargetTransformInfo.cpp
   68 llvm::Optional<unsigned> X86TTIImpl::getCacheSize(
   98 llvm::Optional<unsigned> X86TTIImpl::getCacheAssociativity(
lib/Target/X86/X86TargetTransformInfo.h
  111   llvm::Optional<unsigned> getCacheSize(
  113   llvm::Optional<unsigned> getCacheAssociativity(
lib/Target/XCore/XCoreTargetMachine.cpp
   28 static Reloc::Model getEffectiveRelocModel(Optional<Reloc::Model> RM) {
   35 getEffectiveXCoreCodeModel(Optional<CodeModel::Model> CM) {
   49                                        Optional<Reloc::Model> RM,
   50                                        Optional<CodeModel::Model> CM,
lib/Target/XCore/XCoreTargetMachine.h
   33                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
   33                      Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM,
lib/Testing/Support/Annotations.cpp
   30   llvm::Optional<llvm::StringRef> Name;
lib/ToolDrivers/llvm-lib/LibDriver.cpp
   82   Optional<std::string> EnvOpt = sys::Process::GetEnv("LIB");
lib/Transforms/IPO/ArgumentPromotion.cpp
  107             Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
  868                  Optional<function_ref<void(CallSite OldCS, CallSite NewCS)>>
lib/Transforms/IPO/Attributor.cpp
  549   Optional<StateType> T;
  620   Optional<StateType> T;
  933   Optional<Value *> getAssumedUniqueReturnValue(Attributor &A) const;
  971   Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(A);
 1024 Optional<Value *>
 1031   Optional<Value *> UniqueRV;
 3321   Optional<Value *> getAssumedSimplifiedValue(Attributor &A) const override {
 3333                              Optional<Value *> &AccumulatedSimplifiedValue) {
 3339     Optional<Value *> QueryingValueSimplified =
 3392   Optional<Value *> SimplifiedAssociatedValue;
lib/Transforms/IPO/Inliner.cpp
  418 static Optional<InlineCost>
  653       Optional<InlineCost> OIC = shouldInline(CS, GetInlineCost, ORE);
 1051       Optional<InlineCost> OIC = shouldInline(CS, GetInlineCost, ORE);
lib/Transforms/IPO/PartialInlining.cpp
  204       Optional<function_ref<BlockFrequencyInfo &(Function &)>> GBFI,
  275   Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI;
lib/Transforms/IPO/SyntheticCountsPropagation.cpp
  110     Optional<Scaled64> Res = None;
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
  310 Optional<std::pair<unsigned, unsigned>>
  610   Optional<std::pair<unsigned, unsigned>> MaskPair =
lib/Transforms/InstCombine/InstCombineCalls.cpp
 1529     Optional<Intrinsic::ID> IID;
 1530     Optional<Instruction::CastOps> CastOp;
 1531     Optional<Instruction::BinaryOps> BinaryOp;
 1532     Optional<SpecialCase> Special;
lib/Transforms/InstCombine/InstCombineCompares.cpp
 1479   Optional<bool> Imp = isImpliedCondition(DomCond, &Cmp, DL, TrueBB == CmpBB);
 5151 llvm::Optional<std::pair<CmpInst::Predicate, Constant *>>
lib/Transforms/InstCombine/InstCombineInternal.h
  155 llvm::Optional<std::pair<CmpInst::Predicate, Constant *>>
lib/Transforms/Instrumentation/CGProfile.cpp
   48       Optional<uint64_t> BBCount = BFI.getBlockProfileCount(&BB);
lib/Transforms/Instrumentation/ControlHeightReduction.cpp
 1703   Optional<uint64_t> ProfileCount = BFI.getBlockProfileCount(EntryBlock);
lib/Transforms/Instrumentation/MemorySanitizer.cpp
  631   Optional<MemorySanitizer> MSan;
lib/Transforms/Instrumentation/ThreadSanitizer.cpp
  140   Optional<ThreadSanitizer> TSan;
lib/Transforms/Scalar/ConstantHoisting.cpp
  511 static Optional<APInt> calculateOffsetDiff(const APInt &V1, const APInt &V2) {
  512   Optional<APInt> Res = None;
  582         Optional<APInt> Diff = calculateOffsetDiff(
lib/Transforms/Scalar/DivRemPairs.cpp
   50 static llvm::Optional<ExpandedMatch> matchExpandedRem(Instruction &I) {
lib/Transforms/Scalar/GVNSink.cpp
  589   Optional<SinkingInstructionCandidate> analyzeInstructionForSinking(
  629 Optional<SinkingInstructionCandidate> GVNSink::analyzeInstructionForSinking(
lib/Transforms/Scalar/GuardWidening.cpp
  312   Optional<BranchProbability> LikelyTaken = None;
lib/Transforms/Scalar/IndVarSimplify.cpp
 1005   Optional<ConstantRange> getPostIncRangeInfo(Value *Def,
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
  214   Optional<Range> computeSafeIterationSpace(ScalarEvolution &SE,
  490   static Optional<LoopStructure> parseLoopStructure(ScalarEvolution &,
  535     Optional<const SCEV *> LowLimit;
  536     Optional<const SCEV *> HighLimit;
  542   Optional<SubRanges> calculateSubRanges(bool IsSignedPredicate) const;
  735 Optional<LoopStructure>
 1046 Optional<LoopConstrainer::SubRanges>
 1397   Optional<SubRanges> MaybeSR = calculateSubRanges(IsSignedPredicate);
 1565 Optional<InductiveRangeCheck::Range>
 1691 static Optional<InductiveRangeCheck::Range>
 1693                      const Optional<InductiveRangeCheck::Range> &R1,
 1720 static Optional<InductiveRangeCheck::Range>
 1722                        const Optional<InductiveRangeCheck::Range> &R1,
 1822   Optional<LoopStructure> MaybeLoopStructure =
 1833   Optional<InductiveRangeCheck::Range> SafeIterRange;
lib/Transforms/Scalar/InferAddressSpaces.cpp
  166   Optional<unsigned>
  664     Optional<unsigned> NewAS = updateAddressSpace(*V, *InferredAddrSpace);
  694 Optional<unsigned> InferAddressSpaces::updateAddressSpace(
lib/Transforms/Scalar/JumpThreading.cpp
 1262     Optional<bool> Implication =
lib/Transforms/Scalar/LoopDistribute.cpp
  599     Optional<MDNode *> PartitionID = makeFollowupLoopID(
  897   const Optional<bool> &isForced() const { return IsForced; }
  942     Optional<const MDOperand *> Value =
  968   Optional<bool> IsForced;
lib/Transforms/Scalar/LoopInstSimplify.cpp
  198     Optional<MemorySSAUpdater> MSSAU;
  226   Optional<MemorySSAUpdater> MSSAU;
lib/Transforms/Scalar/LoopPredication.cpp
  260   Optional<LoopICmp> parseLoopICmp(ICmpInst *ICI);
  261   Optional<LoopICmp> parseLoopLatchICmp();
  283   Optional<Value *> widenICmpRangeCheck(ICmpInst *ICI, SCEVExpander &Expander,
  285   Optional<Value *> widenICmpRangeCheckIncrementingLoop(LoopICmp LatchCheck,
  289   Optional<Value *> widenICmpRangeCheckDecrementingLoop(LoopICmp LatchCheck,
  362 Optional<LoopICmp>
  460 static Optional<LoopICmp> generateLoopLatchCheck(const DataLayout &DL,
  551 Optional<Value *> LoopPredication::widenICmpRangeCheckIncrementingLoop(
  600 Optional<Value *> LoopPredication::widenICmpRangeCheckDecrementingLoop(
  663 Optional<Value *> LoopPredication::widenICmpRangeCheck(ICmpInst *ICI,
  834 Optional<LoopICmp> LoopPredication::parseLoopLatchICmp() {
lib/Transforms/Scalar/LoopRotation.cpp
   44   Optional<MemorySSAUpdater> MSSAU;
  100     Optional<MemorySSAUpdater> MSSAU;
lib/Transforms/Scalar/LoopSimplifyCFG.cpp
  692   Optional<MemorySSAUpdater> MSSAU;
  725     Optional<MemorySSAUpdater> MSSAU;
lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp
  366   Optional<MDNode *> NewInnerEpilogueLoopID = makeFollowupLoopID(
  394     Optional<MDNode *> NewOuterEpilogueLoopID = makeFollowupLoopID(
  401   Optional<MDNode *> NewInnerLoopID =
  410     Optional<MDNode *> NewOuterLoopID = makeFollowupLoopID(
lib/Transforms/Scalar/LoopUnrollPass.cpp
  179     Optional<unsigned> UserThreshold, Optional<unsigned> UserCount,
  179     Optional<unsigned> UserThreshold, Optional<unsigned> UserCount,
  180     Optional<bool> UserAllowPartial, Optional<bool> UserRuntime,
  180     Optional<bool> UserAllowPartial, Optional<bool> UserRuntime,
  181     Optional<bool> UserUpperBound, Optional<bool> UserAllowPeeling,
  181     Optional<bool> UserUpperBound, Optional<bool> UserAllowPeeling,
  182     Optional<bool> UserAllowProfileBasedPeeling,
  183     Optional<unsigned> UserFullUnrollMaxCount) {
  333 static Optional<EstimatedUnrollCost> analyzeLoopUnrollCost(
  826       if (Optional<EstimatedUnrollCost> Cost = analyzeLoopUnrollCost(
 1016     bool OnlyWhenForced, bool ForgetAllSCEV, Optional<unsigned> ProvidedCount,
 1017     Optional<unsigned> ProvidedThreshold, Optional<bool> ProvidedAllowPartial,
 1017     Optional<unsigned> ProvidedThreshold, Optional<bool> ProvidedAllowPartial,
 1018     Optional<bool> ProvidedRuntime, Optional<bool> ProvidedUpperBound,
 1018     Optional<bool> ProvidedRuntime, Optional<bool> ProvidedUpperBound,
 1019     Optional<bool> ProvidedAllowPeeling,
 1020     Optional<bool> ProvidedAllowProfileBasedPeeling,
 1021     Optional<unsigned> ProvidedFullUnrollMaxCount) {
 1143     Optional<MDNode *> RemainderLoopID =
 1151     Optional<MDNode *> NewLoopID =
 1192   Optional<unsigned> ProvidedCount;
 1193   Optional<unsigned> ProvidedThreshold;
 1194   Optional<bool> ProvidedAllowPartial;
 1195   Optional<bool> ProvidedRuntime;
 1196   Optional<bool> ProvidedUpperBound;
 1197   Optional<bool> ProvidedAllowPeeling;
 1198   Optional<bool> ProvidedAllowProfileBasedPeeling;
 1199   Optional<unsigned> ProvidedFullUnrollMaxCount;
 1202              bool ForgetAllSCEV = false, Optional<unsigned> Threshold = None,
 1203              Optional<unsigned> Count = None,
 1204              Optional<bool> AllowPartial = None, Optional<bool> Runtime = None,
 1204              Optional<bool> AllowPartial = None, Optional<bool> Runtime = None,
 1205              Optional<bool> UpperBound = None,
 1206              Optional<bool> AllowPeeling = None,
 1207              Optional<bool> AllowProfileBasedPeeling = None,
 1208              Optional<unsigned> ProvidedFullUnrollMaxCount = None)
 1457     Optional<bool> LocalAllowPeeling = UnrollOpts.AllowPeeling;
lib/Transforms/Scalar/MemCpyOptimizer.cpp
  338       Optional<int64_t> Offset =
  352       Optional<int64_t> Offset = isPointerOffset(StartPtr, MSI->getDest(), DL);
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
  288   Optional<OperandBundleUse> DeoptBundle =
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp
 2870   Optional<MemorySSAUpdater> MSSAU;
 2936   Optional<MemorySSAUpdater> MSSAU;
lib/Transforms/Scalar/WarnMissedTransforms.cpp
   49     Optional<int> VectorizeWidth =
   51     Optional<int> InterleaveCount =
lib/Transforms/Utils/BypassSlowDivision.cpp
   90   Optional<QuotRemPair> insertFastDivAndRem();
  164     Optional<QuotRemPair> OptResult = insertFastDivAndRem();
  350 Optional<QuotRemPair> FastDivInsertionTask::insertFastDivAndRem() {
lib/Transforms/Utils/InlineFunction.cpp
 1621       Optional<OperandBundleUse> ParentFunclet =
 1732     Optional<OperandBundleUse> ParentDeopt =
lib/Transforms/Utils/Local.cpp
 1727 using DbgValReplacement = Optional<DIExpression *>;
 2676 static const Optional<BitPart> &
 2678                 std::map<Value *, Optional<BitPart>> &BPS, int Depth) {
 2839   std::map<Value *, Optional<BitPart>> BPS;
lib/Transforms/Utils/LoopUnrollPeel.cpp
  355     Optional<unsigned> PeelCount = getLoopEstimatedTripCount(L);
lib/Transforms/Utils/LoopUnrollRuntime.cpp
  407     Optional<MDNode *> NewLoopID = makeFollowupLoopID(
lib/Transforms/Utils/LoopUtils.cpp
  251 Optional<const MDOperand *> llvm::findStringMetadataForLoop(const Loop *TheLoop,
  266 static Optional<bool> getOptionalBoolLoopAttribute(const Loop *TheLoop,
  288 llvm::Optional<int> llvm::getOptionalIntLoopAttribute(Loop *TheLoop,
  302 Optional<MDNode *> llvm::makeFollowupLoopID(
  395   Optional<int> Count =
  416   Optional<int> Count =
  431   Optional<bool> Enable =
  437   Optional<int> VectorizeWidth =
  439   Optional<int> InterleaveCount =
  679 Optional<unsigned> llvm::getLoopEstimatedTripCount(Loop *L) {
lib/Transforms/Utils/SimplifyCFG.cpp
 5894   Optional<bool> Imp = isImpliedByDomCondition(BI->getCondition(), BI, DL);
lib/Transforms/Utils/SimplifyLibCalls.cpp
 3182                                                     Optional<unsigned> SizeOp,
 3183                                                     Optional<unsigned> StrOp,
 3184                                                     Optional<unsigned> FlagOp) {
lib/Transforms/Utils/ValueMapper.cpp
  184   Optional<Metadata *> mapSimpleMetadata(const Metadata *MD);
  275   Optional<Metadata *> tryToMapOperand(const Metadata *Op);
  287   Optional<Metadata *> getMappedOp(const Metadata *Op) const;
  516 Optional<Metadata *> MDNodeMapper::tryToMapOperand(const Metadata *Op) {
  520   if (Optional<Metadata *> MappedOp = M.mapSimpleMetadata(Op)) {
  566 Optional<Metadata *> MDNodeMapper::getMappedOp(const Metadata *Op) const {
  570   if (Optional<Metadata *> MappedOp = M.getVM().getMappedMD(Op))
  661     if (Optional<Metadata *> MappedOp = tryToMapOperand(Op)) {
  714       if (Optional<Metadata *> MappedOp = getMappedOp(Old))
  748       if (Optional<Metadata *> MappedOp = tryToMapOperand(Old))
  777 Optional<Metadata *> Mapper::mapSimpleMetadata(const Metadata *MD) {
  779   if (Optional<Metadata *> NewMD = getVM().getMappedMD(MD))
  807   if (Optional<Metadata *> NewMD = mapSimpleMetadata(MD))
lib/Transforms/Vectorize/LoopVectorizationPlanner.h
  231   Optional<VectorizationFactor> plan(unsigned UserVF);
lib/Transforms/Vectorize/LoopVectorize.cpp
  365 static Optional<unsigned> getSmallBestKnownTC(ScalarEvolution &SE, Loop *L) {
  968   Optional<unsigned> computeMaxVF();
 3079   Optional<MDNode *> VectorizedLoopID =
 4855 Optional<unsigned> LoopVectorizationCostModel::computeMaxVF() {
 6431 Optional<VectorizationFactor> LoopVectorizationPlanner::plan(unsigned UserVF) {
 6433   Optional<unsigned> MaybeMaxVF = CM.computeMaxVF();
 7640   Optional<VectorizationFactor> MaybeVF = LVP.plan(UserVF);
 7784   Optional<MDNode *> RemainderLoopID =
lib/Transforms/Vectorize/SLPVectorizer.cpp
  264 static Optional<TargetTransformInfo::ShuffleKind>
  420 static Optional<unsigned> getExtractIndex(Instruction *E) {
  577   Optional<ArrayRef<unsigned>> bestOrder() const {
  752     Optional<unsigned>
  773         Optional<unsigned> Idx = None;
 1055               Optional<unsigned> BestIdx =
 1385   TreeEntry *newTreeEntry(ArrayRef<Value *> VL, Optional<ScheduleData *> Bundle,
 1483     Optional<bool> &result = AliasCache[key];
 1502   DenseMap<AliasCacheKey, Optional<bool>> AliasCache;
 1825     Optional<ScheduleData *>
 2300   Optional<ScheduleData *> Bundle = BS.tryScheduleBundle(VL, this, S);
 2877     Optional<unsigned> Idx = getExtractIndex(Inst);
 2939       Optional<TargetTransformInfo::ShuffleKind> ShuffleKind = isShuffle(VL);
 4478 Optional<BoUpSLP::ScheduleData *>
 5581       Optional<ArrayRef<unsigned>> Order = R.bestOrder();
 6412       Optional<ArrayRef<unsigned>> Order = V.bestOrder();
lib/Transforms/Vectorize/VPlan.h
  247   Optional<VPIteration> Instance;
lib/Transforms/Vectorize/VPlanSLP.cpp
  196 static Optional<unsigned> getOpcode(ArrayRef<VPValue *> Values) {
lib/XRay/InstrumentationMap.cpp
   36 Optional<int32_t> InstrumentationMap::getFunctionId(uint64_t Addr) const {
   43 Optional<uint64_t> InstrumentationMap::getFunctionAddr(int32_t FuncId) const {
tools/bugpoint/OptimizerDriver.cpp
  232   Optional<StringRef> Redirects[3] = {None, None, None};
tools/bugpoint/ToolRunner.cpp
   61   Optional<StringRef> Redirects[3] = {StdInFile, StdOutFile, StdErrFile};
   76   Optional<StringRef> Redirects[3] = {StdInFile, StdOutFile, StdErrFile};
tools/clang/include/clang/AST/ASTContext.h
 1490                                 Optional<unsigned> NumExpansions);
 2107   Optional<CharUnits> getTypeSizeInCharsIfKnown(QualType Ty) const {
 2113   Optional<CharUnits> getTypeSizeInCharsIfKnown(const Type *Ty) const {
tools/clang/include/clang/AST/ASTImporter.h
  391     llvm::Optional<DeclT *> getImportedFromDecl(const DeclT *ToD) const {
  581     llvm::Optional<ImportError> getImportDeclErrorIfAny(Decl *FromD) const;
  595     static llvm::Optional<unsigned> getFieldIndex(Decl *F);
tools/clang/include/clang/AST/ASTImporterSharedState.h
   67   llvm::Optional<ImportError> getImportDeclErrorIfAny(Decl *ToD) const {
tools/clang/include/clang/AST/ASTStructuralEquivalence.h
  110   static llvm::Optional<unsigned>
tools/clang/include/clang/AST/Decl.h
  421   Optional<Visibility>
tools/clang/include/clang/AST/ExprCXX.h
 2168              SourceRange TypeIdParens, Optional<Expr *> ArraySize,
 2183          SourceRange TypeIdParens, Optional<Expr *> ArraySize,
 2225   Optional<Expr *> getArraySize() {
 2230   Optional<const Expr *> getArraySize() const {
 4032                     Optional<unsigned> NumExpansions)
 4055   Optional<unsigned> getNumExpansions() const {
 4126                  Optional<unsigned> Length, ArrayRef<TemplateArgument> PartialArgs)
 4147                                 Optional<unsigned> Length = None,
 4551               SourceLocation RParenLoc, Optional<unsigned> NumExpansions)
 4583   Optional<unsigned> getNumExpansions() const {
 4891                             Optional<bool> IsSatisfied);
 4902          ArrayRef<TemplateArgument> ConvertedArgs, Optional<bool> IsSatisfied);
tools/clang/include/clang/AST/ExprObjC.h
  273   Optional<unsigned> NumExpansions;
tools/clang/include/clang/AST/ExternalASTSource.h
  195   virtual llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID);
tools/clang/include/clang/AST/FormatString.h
  240   Optional<ConversionSpecifier> getStandardSpecifier() const;
  459   Optional<LengthModifier> getCorrectedLengthModifier() const;
tools/clang/include/clang/AST/NSAPI.h
   92   Optional<NSArrayMethodKind> getNSArrayMethodKind(Selector Sel);
  117   Optional<NSDictionaryMethodKind> getNSDictionaryMethodKind(Selector Sel);
  134   Optional<NSSetMethodKind> getNSSetMethodKind(Selector Sel);
  206   Optional<NSNumberLiteralMethodKind>
  211   Optional<NSNumberLiteralMethodKind>
tools/clang/include/clang/AST/TemplateBase.h
  195   TemplateArgument(TemplateName Name, Optional<unsigned> NumExpansions) {
  296   Optional<unsigned> getNumTemplateExpansions() const;
tools/clang/include/clang/AST/Type.h
 2367   Optional<NullabilityKind> getNullability(const ASTContext &context) const;
 2391   Optional<ArrayRef<QualType>>
 4551   llvm::Optional<NullabilityKind> getImmediateNullability() const;
 4578   static Optional<NullabilityKind> stripOuterNullability(QualType &T);
 5438                     Optional<unsigned> NumExpansions)
 5456   Optional<unsigned> getNumExpansions() const {
 5470                       Optional<unsigned> NumExpansions) {
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h
  134     llvm::Optional<Profiling> CheckProfiling;
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
  405   llvm::Optional<DynTypedMatcher> tryBind(StringRef ID) const;
tools/clang/include/clang/ASTMatchers/Dynamic/Parser.h
  100     virtual llvm::Optional<MatcherCtor>
  133     llvm::Optional<MatcherCtor>
  166   static llvm::Optional<DynTypedMatcher>
  170   static llvm::Optional<DynTypedMatcher>
  175   static llvm::Optional<DynTypedMatcher>
tools/clang/include/clang/ASTMatchers/Dynamic/Registry.h
   73   static llvm::Optional<MatcherCtor> lookupMatcherCtor(StringRef MatcherName);
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
  109     llvm::Optional<DynTypedMatcher>
  126     virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const = 0;
  128     virtual llvm::Optional<DynTypedMatcher>
  165   llvm::Optional<DynTypedMatcher> getSingleMatcher() const;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h
  958   mutable llvm::Optional<std::string> SlotName;
tools/clang/include/clang/Analysis/AnyCall.h
  106   static Optional<AnyCall> forExpr(const Expr *E) {
  125   static Optional<AnyCall> forDecl(const Decl *D) {
tools/clang/include/clang/Analysis/BodyFarm.h
   45   typedef llvm::DenseMap<const Decl *, Optional<Stmt *>> BodyMap;
tools/clang/include/clang/Analysis/CFG.h
  109   Optional<T> getAs() const {
 1383         if (Optional<CFGStmt> stmt = BI->getAs<CFGStmt>())
tools/clang/include/clang/Analysis/PathDiagnostic.h
  497   Optional<bool> IsPrunable;
tools/clang/include/clang/Analysis/ProgramPoint.h
  151   Optional<T> getAs() const {
  237   Optional<CFGElement> getFirstElement() const {
tools/clang/include/clang/Analysis/RetainSummaryManager.h
  651   Optional<BehaviorSummary> canEval(const CallExpr *CE, const FunctionDecl *FD,
  689   Optional<RetEffect> getRetEffectFromAnnotations(QualType RetTy,
  726   Optional<ObjKind> hasAnyEnabledAttrOf(const Decl *D, QualType QT);
  729   Optional<ObjKind> hasAnyEnabledAttrOf(const Decl *D, QualType QT);
tools/clang/include/clang/Basic/DiagnosticError.h
   39   static Optional<PartialDiagnosticAt> take(llvm::Error &Err) {
   40     Optional<PartialDiagnosticAt> Result;
tools/clang/include/clang/Basic/FileManager.h
  287   llvm::Optional<DirectoryEntryRef>
  344   llvm::Optional<FileEntryRef> getOptionalFileRef(StringRef Filename,
  376   llvm::Optional<FileEntryRef> getBypassFile(FileEntryRef VFE);
tools/clang/include/clang/Basic/Module.h
  184     Optional<off_t> Size;
  185     Optional<time_t> ModTime;
tools/clang/include/clang/Basic/SourceManager.h
 1027   Optional<FileEntryRef> getFileEntryRefForID(FileID FID) const {
tools/clang/include/clang/Basic/TargetInfo.h
 1243   virtual llvm::Optional<LangAS> getConstantAddressSpace() const {
 1357   virtual Optional<unsigned> getDWARFAddressSpace(unsigned AddressSpace) const {
tools/clang/include/clang/CrossTU/CrossTranslationUnit.h
  163   static llvm::Optional<std::string> getLookupName(const NamedDecl *ND);
  176   llvm::Optional<std::pair<SourceLocation /*FromLoc*/, ASTUnit *>>
tools/clang/include/clang/Driver/Compilation.h
  116   std::vector<Optional<StringRef>> Redirects;
  305   void Redirect(ArrayRef<Optional<StringRef>> Redirects);
tools/clang/include/clang/Driver/DarwinSDKInfo.h
   35 Expected<Optional<DarwinSDKInfo>> parseDarwinSDKInfo(llvm::vfs::FileSystem &VFS,
tools/clang/include/clang/Driver/Job.h
  100   virtual int Execute(ArrayRef<Optional<StringRef>> Redirects,
  148   int Execute(ArrayRef<Optional<StringRef>> Redirects, std::string *ErrMsg,
  166   int Execute(ArrayRef<Optional<StringRef>> Redirects, std::string *ErrMsg,
tools/clang/include/clang/Driver/ToolChain.h
  397   virtual Optional<std::string> getRuntimePath() const;
  400   virtual Optional<std::string> getCXXStdlibPath() const;
tools/clang/include/clang/Format/Format.h
 2133   llvm::Optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const;
 2145     llvm::Optional<FormatStyle> Get(FormatStyle::LanguageKind Language) const;
tools/clang/include/clang/Frontend/ASTUnit.h
  225   llvm::Optional<PrecompiledPreamble> Preamble;
  836       llvm::Optional<StringRef> ModuleFormat = llvm::None,
tools/clang/include/clang/Frontend/CommandLineSourceLoc.h
   72   static Optional<ParsedSourceRange> fromString(StringRef Str) {
tools/clang/include/clang/Frontend/PrecompiledPreamble.h
  162     llvm::Optional<std::string> FilePath;
tools/clang/include/clang/Lex/DirectoryLookup.h
  101   Optional<DirectoryEntryRef> getFrameworkDirRef() const {
  180   Optional<FileEntryRef>
  189   Optional<FileEntryRef> DoFrameworkLookup(
tools/clang/include/clang/Lex/HeaderMap.h
   58   Optional<StringRef> getString(unsigned StrTabIdx) const;
   80   Optional<FileEntryRef> LookupFile(StringRef Filename, FileManager &FM) const;
tools/clang/include/clang/Lex/HeaderSearch.h
  392   Optional<FileEntryRef> LookupFile(
  407   Optional<FileEntryRef> LookupSubframeworkHeader(
  644   Optional<FileEntryRef>
tools/clang/include/clang/Lex/Lexer.h
  519   static Optional<Token> findNextToken(SourceLocation Loc,
tools/clang/include/clang/Lex/PPCallbacks.h
  310                           Optional<FileEntryRef> File,
  492                   Optional<FileEntryRef> File,
tools/clang/include/clang/Lex/PreprocessingRecord.h
  296     virtual Optional<bool> isPreprocessedEntityInFileID(unsigned Index,
tools/clang/include/clang/Lex/Preprocessor.h
  473     llvm::Optional<PreambleSkipInfo> SkipInfo;
 1957   Optional<FileEntryRef>
 2206   Optional<FileEntryRef> LookupHeaderIncludeOrImport(
 2275                                              llvm::Optional<PreambleSkipInfo> SkipInfo) {
 2281   llvm::Optional<PreambleSkipInfo> getPreambleSkipInfo() const {
 2328   Optional<unsigned>
tools/clang/include/clang/Parse/Parser.h
 2581   Optional<AvailabilitySpec> ParseAvailabilitySpec();
 2692       Optional<llvm::function_ref<void()>> CodeCompletionHandler = None);
tools/clang/include/clang/Sema/CodeCompleteConsumer.h
  359   llvm::Optional<CXXScopeSpec> ScopeSpecifier;
  422   llvm::Optional<const CXXScopeSpec *> getCXXScopeSpecifier() {
tools/clang/include/clang/Sema/Lookup.h
  484       llvm::Optional<AmbiguityKind> SavedAK;
tools/clang/include/clang/Sema/Sema.h
 5514                               Optional<unsigned> NumExpansions);
 5628                          Optional<Expr *> ArraySize,
 6002       Optional<std::tuple<unsigned, bool, Decl *>> Mangling = None);
 6026       Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool DirectInit,
 7324                                      Optional<unsigned> NumExpansions);
 7331                               Optional<unsigned> NumExpansions);
 7350                                 Optional<unsigned> NumExpansions);
 7392                                        Optional<unsigned> &NumExpansions);
 7401   Optional<unsigned> getNumArgumentsInExpansion(QualType T,
 7432       Optional<unsigned> &NumExpansions) const;
 7440   Optional<unsigned> getFullyPackExpandedSize(TemplateArgument Arg);
 7601                  Optional<unsigned> DependentDeductionDepth = None);
 7604                  Optional<unsigned> DependentDeductionDepth = None);
 8095   Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const;
 8331                                 Optional<unsigned> NumExpansions,
 9786   Optional<std::pair<FunctionDecl *, Expr *>> checkOpenMPDeclareVariantFunction(
10620     llvm::Optional<bool> getKnownValue() const {
10847     llvm::Optional<SemaDiagnosticBuilder> ImmediateDiag;
10848     llvm::Optional<unsigned> PartialDiagId;
11199   void CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
tools/clang/include/clang/Sema/SemaLambda.h
   33 Optional<unsigned> getStackIndexOfNearestEnclosingCaptureCapableLambda(
tools/clang/include/clang/Sema/Template.h
  478                              Optional<const ASTTemplateArgumentListInfo *>
tools/clang/include/clang/Sema/TemplateDeduction.h
  263   llvm::Optional<unsigned> getCallArgIndex();
tools/clang/include/clang/Serialization/ASTReader.h
  867   Optional<unsigned> PragmaPackCurrentValue;
 1721   Optional<bool> isPreprocessedEntityInFileID(unsigned Index,
 2109   llvm::Optional<ASTSourceDescriptor> getSourceDescriptor(unsigned ID) override;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h
  453   Optional<bugreporter::TrackingKind>
  456   Optional<bugreporter::TrackingKind>
  459   Optional<bugreporter::TrackingKind> getInterestingnessKind(SVal V) const;
  741   Optional<std::string> generateMessage(BugReporterContext &BRC,
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h
  288                     Optional<bool> &prunable,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h
  412   virtual Optional<unsigned>
  749   Optional<unsigned>
 1066   Optional<unsigned> RequiredArgs;
 1067   Optional<size_t> RequiredParams;
 1071   static Optional<size_t> readRequiredParams(Optional<unsigned> RequiredArgs,
 1071   static Optional<size_t> readRequiredParams(Optional<unsigned> RequiredArgs,
 1072                                              Optional<size_t> RequiredParams) {
 1092                   Optional<unsigned> RequiredArgs = None,
 1093                   Optional<size_t> RequiredParams = None)
 1100                   Optional<unsigned> RequiredArgs = None,
 1101                   Optional<size_t> RequiredParams = None)
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h
  138     if (Optional<PostStore> PSL = L.getAs<PostStore>())
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h
   39   Optional<bool> Val;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h
  172   Optional<T> getLocationAs() const LLVM_LVALUE_FUNCTION {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h
  603   static Optional<SVal>
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/FunctionSummary.h
   89   Optional<bool> mayInline(const Decl *D) {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h
  104   mutable Optional<RegionOffset> cachedOffset;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h
  702   if (Optional<Loc> L = LV.getAs<Loc>())
  752   if (Optional<NonLoc> N = Idx.getAs<NonLoc>())
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h
  130       Optional<bool> isSat = Solver->check();
  147       Optional<bool> isNotSat = Solver->check();
  248     Optional<nonloc::SymbolVal> SymVal = X.getAs<nonloc::SymbolVal>();
  342     Optional<bool> res = Solver->check();
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h
  248   Optional<SVal> getConstantVal(const Expr *E);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h
  111   Optional<T> getAs() const {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h
   86   virtual Optional<SVal> getDefaultBinding(Store store, const MemRegion *R) = 0;
   96   Optional<SVal> getDefaultBinding(nonloc::LazyCompoundVal lcv) {
tools/clang/include/clang/Tooling/ASTDiff/ASTDiff.h
   47   llvm::Optional<StringRef> getIdentifier() const;
   48   llvm::Optional<std::string> getQualifiedIdentifier() const;
tools/clang/include/clang/Tooling/AllTUsExecution.h
   64   llvm::Optional<CommonOptionsParser> OptionsParser;
tools/clang/include/clang/Tooling/Core/Replacement.h
  176   const llvm::Optional<Replacement> &getNewReplacement() const {
  180   const llvm::Optional<Replacement> &getExistingReplacement() const {
  194   llvm::Optional<Replacement> NewReplacement;
  197   llvm::Optional<Replacement> ExistingReplacement;
tools/clang/include/clang/Tooling/Inclusions/HeaderIncludes.h
   75   llvm::Optional<tooling::Replacement> insert(llvm::StringRef Header,
tools/clang/include/clang/Tooling/Refactoring/ASTSelection.h
   69 Optional<SelectedASTNode> findSelectedASTNodes(const ASTContext &Context,
  132   static Optional<CodeRangeASTSelection>
tools/clang/include/clang/Tooling/Refactoring/Extract/Extract.h
   29                                             Optional<std::string> DeclName);
   34   ExtractFunction(CodeRangeASTSelection Code, Optional<std::string> DeclName)
tools/clang/include/clang/Tooling/Refactoring/RefactoringOptionVisitor.h
   30                      Optional<std::string> &Value) = 0;
   41           std::declval<RefactoringOption>(), *std::declval<Optional<T> *>())),
tools/clang/include/clang/Tooling/Refactoring/RefactoringOptions.h
   33   using ValueType = Optional<T>;
   38   Optional<T> Value;
tools/clang/include/clang/Tooling/StandaloneExecution.h
   86   llvm::Optional<CommonOptionsParser> OptionsParser;
tools/clang/include/clang/Tooling/Syntax/Tokens.h
  209   llvm::Optional<llvm::ArrayRef<syntax::Token>>
  228   llvm::Optional<Expansion>
tools/clang/include/clang/Tooling/Transformer/SourceCode.h
   79 llvm::Optional<CharSourceRange>
   83 inline llvm::Optional<CharSourceRange>
tools/clang/include/clang/Tooling/Transformer/SourceCodeBuilders.h
   53 llvm::Optional<std::string> buildParens(const Expr &E,
   58 llvm::Optional<std::string> buildDereference(const Expr &E,
   63 llvm::Optional<std::string> buildAddressOf(const Expr &E,
   72 llvm::Optional<std::string> buildDot(const Expr &E, const ASTContext &Context);
   80 llvm::Optional<std::string> buildArrow(const Expr &E,
tools/clang/lib/ARCMigrate/Internals.h
  153   Optional<bool> EnableCFBridgeFns;
tools/clang/lib/AST/ASTContext.cpp
 2429 static llvm::Optional<int64_t>
 2445         llvm::Optional<int64_t> Size = structHasUniqueObjectRepresentations(
 2545     Optional<int64_t> StructSize =
 4479                                           Optional<unsigned> NumExpansions) {
tools/clang/lib/AST/ASTImporter.cpp
  182     Expected<Optional<T>> import(Optional<T> From) {
  182     Expected<Optional<T>> import(Optional<T> From) {
  184         return Optional<T>();
 6925     Optional<ParmVarDecl *> FromParam = Importer.getImportedFromDecl(ToParam);
 7037   Optional<unsigned> Length;
 7067   Optional<Expr *> ToArraySize;
 7798 Optional<unsigned> ASTImporter::getFieldIndex(Decl *F) {
 8775 llvm::Optional<ImportError>
tools/clang/lib/AST/ASTStructuralEquivalence.cpp
 1118     if (Optional<unsigned> Index1 =
 1120       if (Optional<unsigned> Index2 =
 1616 Optional<unsigned>
tools/clang/lib/AST/Decl.cpp
  170 static Optional<Visibility> getExplicitVisibility(const NamedDecl *D,
  220 static Optional<Visibility> getVisibilityOf(const NamedDecl *D,
  711     if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) {
  721         if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) {
  933     if (Optional<Visibility> Vis = getExplicitVisibility(D, computation))
 1097 static Optional<Visibility>
 1104   if (Optional<Visibility> V = getVisibilityOf(ND, kind))
 1176 Optional<Visibility>
 1228       if (Optional<Visibility> Vis =
 1249         if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation))
 1462   if (llvm::Optional<LinkageInfo> LI = lookup(D, computation))
tools/clang/lib/AST/ExprCXX.cpp
  170                        Optional<Expr *> ArraySize,
  261                    Optional<Expr *> ArraySize,
 1599                        Optional<unsigned> Length,
 1758     ArrayRef<TemplateArgument> ConvertedArgs, Optional<bool> IsSatisfied)
 1816                                   Optional<bool> IsSatisfied) {
tools/clang/lib/AST/ExprConstant.cpp
  989     Optional<DynAlloc*> lookupDynamicAlloc(DynamicAllocLValue DA) {
  990       Optional<DynAlloc*> Result;
 1973     if (Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA))
 3634     Optional<DynAlloc*> Alloc = Info.lookupDynamicAlloc(DA);
 5026 static Optional<DynamicType> ComputeDynamicType(EvalInfo &Info, const Expr *E,
 5083   Optional<DynamicType> DynType = ComputeDynamicType(
 5201   Optional<DynamicType> DynType =
 6041 static Optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E,
 6057   Optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA);
 6131   SmallVector<Optional<unsigned char>, 32> Bytes;
 6316   static Optional<BitCastBuffer> convert(EvalInfo &Info, const APValue &Src,
 6346   Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
 6392   Optional<APValue> visit(const RecordType *RTy, CharUnits Offset) {
 6412         Optional<APValue> SubObj = visitType(
 6438       Optional<APValue> SubObj = visitType(FieldTy, FieldOffset);
 6448   Optional<APValue> visit(const EnumType *Ty, CharUnits Offset) {
 6459   Optional<APValue> visit(const ConstantArrayType *Ty, CharUnits Offset) {
 6465       Optional<APValue> ElementValue =
 6475   Optional<APValue> visit(const Type *Ty, CharUnits Offset) {
 6479   Optional<APValue> visitType(QualType Ty, CharUnits Offset) {
 6504   static Optional<APValue> convert(EvalInfo &Info, BitCastBuffer &Buffer,
 6594   Optional<BitCastBuffer> Buffer =
 6600   Optional<APValue> MaybeDestValue =
 7555     Optional<DynamicType> DynType =
 8516   if (Optional<const Expr*> ArraySize = E->getArraySize()) {
13221   Optional<DynAlloc *> Alloc = CheckDeleteKind(
tools/clang/lib/AST/ExternalASTSource.cpp
   29 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
tools/clang/lib/AST/FormatString.cpp
  672 Optional<ConversionSpecifier>
  965 Optional<LengthModifier> FormatSpecifier::getCorrectedLengthModifier() const {
tools/clang/lib/AST/Interp/Block.h
   40   Block(const llvm::Optional<unsigned> &DeclID, Descriptor *Desc,
   61   llvm::Optional<unsigned> getDeclID() const { return DeclID; }
   97   llvm::Optional<unsigned> DeclID;
tools/clang/lib/AST/Interp/ByteCodeEmitter.cpp
   43     if (llvm::Optional<PrimType> T = Ctx.classify(PD->getType())) {
tools/clang/lib/AST/Interp/ByteCodeEmitter.h
   86   llvm::Optional<SourceLocation> BailLocation;
tools/clang/lib/AST/Interp/ByteCodeExprGen.cpp
   23 template <typename T> using Optional = llvm::Optional<T>;
   53     Ctx->InitFn = llvm::Optional<InitFnRef>{};
   83   llvm::Optional<InitFnRef> OldInitFn;
  135   if (Optional<PrimType> T = classify(LitTy))
  163   Optional<PrimType> LT = classify(LHS->getType());
  164   Optional<PrimType> RT = classify(RHS->getType());
  169   if (Optional<PrimType> T = classify(BO->getType())) {
  222   if (Optional<PrimType> T = classify(E->getType())) {
  260   if (Optional<PrimType> T = classify(LV->getType())) {
  436 llvm::Optional<unsigned>
  473   if (Optional<unsigned> Idx = getGlobalIdx(VD)) {
  483 llvm::Optional<unsigned>
  524   if (Optional<PrimType> T = classify(Exp))
  534   if (Optional<unsigned> I = P.createGlobal(VD)) {
  535     if (Optional<PrimType> T = classify(VD->getType())) {
tools/clang/lib/AST/Interp/ByteCodeExprGen.h
  102   llvm::Optional<PrimType> classify(const Expr *E) const {
  105   llvm::Optional<PrimType> classify(QualType Ty) const {
  156   llvm::Optional<unsigned> allocateLocal(DeclTy &&Decl,
  208   llvm::Optional<unsigned> getGlobalIdx(const VarDecl *VD);
  227   llvm::Optional<uint64_t> ArrayIndex;
  233   llvm::Optional<InitFnRef> InitFn = {};
  304   Optional<unsigned> Idx;
tools/clang/lib/AST/Interp/ByteCodeStmtGen.cpp
   22 template <typename T> using Optional = llvm::Optional<T>;
  239   if (Optional<PrimType> T = this->classify(DT)) {
tools/clang/lib/AST/Interp/ByteCodeStmtGen.h
   43   using OptLabelTy = llvm::Optional<LabelTy>;
   71   llvm::Optional<PrimType> ReturnType;
tools/clang/lib/AST/Interp/Context.cpp
   68 llvm::Optional<PrimType> Context::classify(QualType T) {
tools/clang/lib/AST/Interp/Context.h
   77   llvm::Optional<PrimType> classify(QualType T);
tools/clang/lib/AST/Interp/EvalEmitter.cpp
  126             if (llvm::Optional<PrimType> T = Ctx.classify(FieldTy)) {
  148           if (llvm::Optional<PrimType> T = Ctx.classify(FieldTy)) {
  180         if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
tools/clang/lib/AST/Interp/EvalEmitter.h
  100   llvm::Optional<SourceLocation> BailLocation;
tools/clang/lib/AST/Interp/InterpFrame.cpp
  125     if (llvm::Optional<PrimType> T = S.Ctx.classify(Ty)) {
tools/clang/lib/AST/Interp/Pointer.h
  252   llvm::Optional<unsigned> getDeclID() const { return Pointee->getDeclID(); }
tools/clang/lib/AST/Interp/Program.cpp
   87 llvm::Optional<unsigned> Program::getGlobal(const ValueDecl *VD) {
   93   llvm::Optional<unsigned> Index;
  111 llvm::Optional<unsigned> Program::getOrCreateGlobal(const ValueDecl *VD) {
  122 llvm::Optional<unsigned> Program::getOrCreateDummy(const ParmVarDecl *PD) {
  141 llvm::Optional<unsigned> Program::createGlobal(const ValueDecl *VD) {
  158 llvm::Optional<unsigned> Program::createGlobal(const Expr *E) {
  162 llvm::Optional<unsigned> Program::createGlobal(const DeclTy &D, QualType Ty,
  277     if (llvm::Optional<PrimType> T = Ctx.classify(FT)) {
  311       if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
  337       if (llvm::Optional<PrimType> T = Ctx.classify(ElemTy)) {
tools/clang/lib/AST/Interp/Program.h
   60   llvm::Optional<unsigned> getGlobal(const ValueDecl *VD);
   63   llvm::Optional<unsigned> getOrCreateGlobal(const ValueDecl *VD);
   66   llvm::Optional<unsigned> getOrCreateDummy(const ParmVarDecl *PD);
   69   llvm::Optional<unsigned> createGlobal(const ValueDecl *VD);
   72   llvm::Optional<unsigned> createGlobal(const Expr *E);
  124   llvm::Optional<unsigned> getCurrentDecl() const {
  133   llvm::Optional<unsigned> createGlobal(const DeclTy &D, QualType Ty,
tools/clang/lib/AST/ItaniumCXXABI.cpp
   88 Optional<bool> areDenseMapKeysEqualSpecialValues(T LHS, T RHS) {
  116     if (Optional<bool> Result = areDenseMapKeysEqualSpecialValues(
tools/clang/lib/AST/JSONNodeDumper.cpp
  666   if (llvm::Optional<unsigned> N = PET->getNumExpansions())
tools/clang/lib/AST/Linkage.h
   93   llvm::Optional<LinkageInfo> lookup(const NamedDecl *ND,
tools/clang/lib/AST/NSAPI.cpp
  145 Optional<NSAPI::NSArrayMethodKind> NSAPI::getNSArrayMethodKind(Selector Sel) {
  246 Optional<NSAPI::NSDictionaryMethodKind>
  303 Optional<NSAPI::NSSetMethodKind>
  366 Optional<NSAPI::NSNumberLiteralMethodKind>
  377 Optional<NSAPI::NSNumberLiteralMethodKind>
tools/clang/lib/AST/OSLog.cpp
   23     Optional<OSLogBufferItem::Kind> Kind;
   24     Optional<unsigned> Size;
   25     Optional<const Expr *> Count;
   26     Optional<const Expr *> Precision;
   27     Optional<const Expr *> FieldWidth;
tools/clang/lib/AST/StmtPrinter.cpp
 2029   if (Optional<Expr *> Size = E->getArraySize()) {
tools/clang/lib/AST/TemplateBase.cpp
  252 Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const {
tools/clang/lib/AST/Type.cpp
 1442 Optional<ArrayRef<QualType>> Type::getObjCSubstitutions(
 3820 Optional<NullabilityKind>
 3950 llvm::Optional<NullabilityKind>
 3961 Optional<NullabilityKind> AttributedType::stripOuterNullability(QualType &T) {
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
  239 llvm::Optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h
  125   static Optional<attr::Kind> getAttrKind(llvm::StringRef AttrKind) {
  148   static Optional<CastKind> getCastKind(llvm::StringRef AttrKind) {
  171   static Optional<OpenMPClauseKind> getClauseKind(llvm::StringRef ClauseKind) {
tools/clang/lib/ASTMatchers/Dynamic/Parser.cpp
  356       llvm::Optional<DynTypedMatcher> Result =
  359         llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
  435   llvm::Optional<MatcherCtor> Ctor = S->lookupMatcherCtor(NameToken.Text);
  601 llvm::Optional<MatcherCtor>
  661 llvm::Optional<DynTypedMatcher>
  672   llvm::Optional<DynTypedMatcher> Result =
tools/clang/lib/ASTMatchers/Dynamic/Registry.cpp
  533 llvm::Optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
  680   llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
  682     llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
tools/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
   62 llvm::Optional<DynTypedMatcher>
   72     llvm::Optional<DynTypedMatcher> Inner =
   87   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
   96   llvm::Optional<DynTypedMatcher>
  121   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
  137   llvm::Optional<DynTypedMatcher>
  186   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
  200   llvm::Optional<DynTypedMatcher>
  238 llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
tools/clang/lib/Analysis/BodyFarm.cpp
  668   Optional<Stmt *> &Val = Bodies[D];
  812   Optional<Stmt *> &Val = Bodies[D];
tools/clang/lib/Analysis/CFG.cpp
 5081         if (Optional<CFGStmt> SE = BI->getAs<CFGStmt>()) {
 5451       if (Optional<CFGConstructor> CE = E.getAs<CFGConstructor>()) {
 5823         if (Optional<CFGStmt> StmtElm = Elm.getAs<CFGStmt>())
tools/clang/lib/Analysis/CFGStmtMap.cpp
   52     Optional<CFGStmt> CS = CE.getAs<CFGStmt>();
tools/clang/lib/Analysis/Consumed.cpp
   65     if (Optional<CFGStmt> CS = B.getAs<CFGStmt>())
   84       if (Optional<CFGStmt> CS = BI->getAs<CFGStmt>())
tools/clang/lib/Analysis/LiveVariables.cpp
  512     if (Optional<CFGAutomaticObjDtor> Dtor =
  573         if (Optional<CFGStmt> cs = bi->getAs<CFGStmt>()) {
tools/clang/lib/Analysis/PathDiagnostic.cpp
  228 static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y);
  230 static Optional<bool>
  244 static Optional<bool> compareMacro(const PathDiagnosticMacroPiece &X,
  249 static Optional<bool> compareCall(const PathDiagnosticCallPiece &X,
  266 static Optional<bool> comparePiece(const PathDiagnosticPiece &X,
  312 static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y) {
  320     Optional<bool> b = comparePiece(**X_I, **Y_I);
  382   Optional<bool> b = comparePath(X.path, Y.path);
  652   if (Optional<BlockEdge> BE = P.getAs<BlockEdge>()) {
  672   } else if (Optional<StmtPoint> SP = P.getAs<StmtPoint>()) {
  676   } else if (Optional<PostInitializer> PIP = P.getAs<PostInitializer>()) {
  679   } else if (Optional<PreImplicitCall> PIC = P.getAs<PreImplicitCall>()) {
  681   } else if (Optional<PostImplicitCall> PIE = P.getAs<PostImplicitCall>()) {
  683   } else if (Optional<CallEnter> CE = P.getAs<CallEnter>()) {
  687   } else if (Optional<CallExitEnd> CEE = P.getAs<CallExitEnd>()) {
  697   } else if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>()) {
  698     if (Optional<CFGElement> BlockFront = BE->getFirstElement()) {
  710   } else if (Optional<FunctionExitPoint> FE = P.getAs<FunctionExitPoint>()) {
tools/clang/lib/Analysis/ReachableCode.cpp
   75   if (Optional<CFGStmt> CS = B->back().getAs<CFGStmt>()) {
   92       if (Optional<CFGStmt> CS = I->getAs<CFGStmt>()) {
  336     Optional<bool> TreatAllSuccessorsAsReachable;
  458     if (Optional<CFGStmt> CS = I->getAs<CFGStmt>()) {
tools/clang/lib/Analysis/RetainSummaryManager.cpp
   68 Optional<ObjKind> RetainSummaryManager::hasAnyEnabledAttrOf(const Decl *D,
  109 Optional<ObjKind> RetainSummaryManager::hasAnyEnabledAttrOf(const Decl *D,
  712 Optional<RetainSummaryManager::BehaviorSummary>
  858 Optional<RetEffect>
  984   if (Optional<RetEffect> RetE = getRetEffectFromAnnotations(RetTy, FD))
 1011   if (Optional<RetEffect> RetE = getRetEffectFromAnnotations(RetTy, MD))
tools/clang/lib/Analysis/ThreadSafety.cpp
  824         if (Optional<CFGStmt> CS = BI->getAs<CFGStmt>()) {
  836         if (Optional<CFGStmt> CS = BI.getAs<CFGStmt>()) {
 2241   if (Optional<CFGStmt> S = Last.getAs<CFGStmt>()) {
tools/clang/lib/Analysis/UninitializedValues.cpp
   72   Optional<unsigned> getValueIndex(const VarDecl *d) const;
   88 Optional<unsigned> DeclToIndex::getValueIndex(const VarDecl *d) const {
  149     const Optional<unsigned> &idx = declToIndex.getValueIndex(vd);
  210   const Optional<unsigned> &idx = declToIndex.getValueIndex(vd);
  858     if (Optional<CFGStmt> cs = I.getAs<CFGStmt>())
tools/clang/lib/Basic/FileManager.cpp
  402 llvm::Optional<FileEntryRef> FileManager::getBypassFile(FileEntryRef VF) {
tools/clang/lib/Basic/SourceManager.cpp
  685   llvm::Optional<FileEntryRef> BypassFile =
 2122   llvm::Optional<unsigned> NextStart;
tools/clang/lib/Basic/Targets/AMDGPU.h
  309   llvm::Optional<LangAS> getConstantAddressSpace() const override {
  324   Optional<unsigned>
tools/clang/lib/Basic/Targets/NVPTX.h
  143   Optional<unsigned>
tools/clang/lib/CodeGen/BackendUtil.cpp
  394 static Optional<llvm::CodeModel::Model>
  510 static Optional<GCOVOptions> getGCOVOptions(const CodeGenOptions &CodeGenOpts) {
  530 static Optional<InstrProfOptions>
  696   if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts)) {
  702   if (Optional<InstrProfOptions> Options =
  766   Optional<llvm::CodeModel::Model> CM = getCodeModel(CodeGenOpts);
 1015   Optional<PGOOptions> PGOOpt;
 1118       if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts))
 1120       if (Optional<InstrProfOptions> Options =
 1207       if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts))
 1211       if (Optional<InstrProfOptions> Options =
tools/clang/lib/CodeGen/CGCall.cpp
 1886       Optional<unsigned> NumElemsParam;
tools/clang/lib/CodeGen/CGDebugInfo.cpp
  368 Optional<llvm::DIFile::ChecksumKind>
  392 Optional<StringRef> CGDebugInfo::getSource(const SourceManager &SM,
  432   Optional<llvm::DIFile::ChecksumKind> CSKind =
  434   Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
  442                         Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
  443                         Optional<StringRef> Source) {
  520   Optional<llvm::DIFile::ChecksumKind> CSKind;
  521   Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo;
 1010   Optional<unsigned> DWARFAddressSpace =
 1905   Optional<unsigned> DWARFAddressSpace =
 2001     Optional<unsigned> DWARFAddressSpace =
 3775   Optional<unsigned> DWARFAddressSpace =
 3906                                                 llvm::Optional<unsigned> ArgNo,
tools/clang/lib/CodeGen/CGDebugInfo.h
  522                                      llvm::Optional<unsigned> ArgNo,
  556   Optional<llvm::DIFile::ChecksumKind>
  560   Optional<StringRef> getSource(const SourceManager &SM, FileID FID);
  569              Optional<llvm::DIFile::ChecksumInfo<StringRef>> CSInfo,
  570              Optional<StringRef> Source);
tools/clang/lib/CodeGen/CGExpr.cpp
 2302   llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 2964   Optional<ApplyDebugLocation> DL;
 4194 static Optional<LValue> EmitLValueOrThrowExpression(CodeGenFunction &CGF,
 4240   Optional<LValue> lhs =
 4254   Optional<LValue> rhs =
tools/clang/lib/CodeGen/CGExprConstant.cpp
   96   Optional<size_t> splitAt(CharUnits Pos);
  160   llvm::Optional<size_t> FirstElemToReplace = splitAt(Offset);
  165   llvm::Optional<size_t> LastElemToReplace = splitAt(Offset + CSize);
  224       llvm::Optional<size_t> FirstElemToUpdate = splitAt(OffsetInChars);
  227       llvm::Optional<size_t> LastElemToUpdate =
  286 Optional<size_t> ConstantAggregateBuilder::splitAt(CharUnits Pos) {
  499   llvm::Optional<size_t> FirstElemToReplace = splitAt(Offset);
  504   llvm::Optional<size_t> LastElemToReplace = splitAt(Offset + Size);
tools/clang/lib/CodeGen/CGExprScalar.cpp
  153 static llvm::Optional<QualType> getUnwidenedIntegerType(const ASTContext &Ctx,
  540     Optional<unsigned> Min = Version.getMinor(), SMin = Version.getSubminor();
tools/clang/lib/CodeGen/CGLoopInfo.cpp
   39   Optional<bool> Enabled;
   85   Optional<bool> Enabled;
  148   Optional<bool> Enabled;
  217   Optional<bool> Enabled;
  319   Optional<bool> Enabled;
  370   Optional<bool> Enabled;
tools/clang/lib/CodeGen/CGObjC.cpp
  370 static Optional<llvm::Value *>
  436 static Optional<llvm::Value *>
  505   if (Optional<llvm::Value *> Val = tryEmitSpecializedAllocInit(*this, E))
  614     if (Optional<llvm::Value *> SpecializedResult =
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp
 2672   llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 2880   Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 7519         if (llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 8448         llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 9584       Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
 9598     Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
 9632   llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 9683   llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 9759     llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h
  457     llvm::Optional<DeclToAddrMapTy> SecondaryLocalVarData = llvm::None;
  462     llvm::Optional<const RecordDecl *> SecondaryGlobalRecord = llvm::None;
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp
   57       const llvm::Optional<OpenMPDirectiveKind> CapturedRegion = llvm::None,
tools/clang/lib/CodeGen/CodeGenFunction.h
 1350     Optional<uint64_t> Count = PGO.getStmtCount(S);
tools/clang/lib/CodeGen/CodeGenModule.cpp
 2499         if (llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 3879   Optional<ConstantEmitter> emitter;
 5046   Optional<ConstantEmitter> emitter;
tools/clang/lib/CodeGen/CodeGenPGO.cpp
 1052   Optional<uint64_t> CondCount = PGO.getStmtCount(Cond);
tools/clang/lib/CodeGen/CodeGenPGO.h
   62   Optional<uint64_t> getStmtCount(const Stmt *S) {
tools/clang/lib/CodeGen/CoverageMappingGen.cpp
   42   Optional<SourceLocation> LocStart;
   45   Optional<SourceLocation> LocEnd;
   55   SourceMappingRegion(Counter Count, Optional<SourceLocation> LocStart,
   56                       Optional<SourceLocation> LocEnd, bool DeferRegion = false,
  263   Optional<unsigned> getCoverageFileID(SourceLocation Loc) {
  443   Optional<SourceMappingRegion> DeferredRegion;
  454   Optional<std::pair<SourceLocation, size_t>> LastTerminatedRegion;
  481   size_t pushRegion(Counter Count, Optional<SourceLocation> StartLoc = None,
  482                     Optional<SourceLocation> EndLoc = None) {
  732     Optional<Counter> ParentCounter;
  799   Optional<SourceRange> findGapAreaBetween(SourceLocation AfterLoc,
  811   Optional<SourceRange> findGapAreaBetween(const Stmt *AfterStmt,
tools/clang/lib/CrossTU/CrossTranslationUnit.cpp
  195 llvm::Optional<std::string>
  221     llvm::Optional<std::string> ResultLookupName = getLookupName(ResultDecl);
  237   const llvm::Optional<std::string> LookupName = getLookupName(D);
  569 llvm::Optional<std::pair<SourceLocation, ASTUnit *>>
tools/clang/lib/DirectoryWatcher/DirectoryScanner.cpp
   17 Optional<sys::fs::file_status> getFileStatus(StringRef Path) {
tools/clang/lib/DirectoryWatcher/DirectoryScanner.h
   27 llvm::Optional<llvm::sys::fs::file_status> getFileStatus(llvm::StringRef Path);
tools/clang/lib/DirectoryWatcher/linux/DirectoryWatcher-linux.cpp
   74   static llvm::Optional<SemaphorePipe> create() {
tools/clang/lib/Driver/Compilation.cpp
  280 void Compilation::Redirect(ArrayRef<Optional<StringRef>> Redirects) {
tools/clang/lib/Driver/DarwinSDKInfo.cpp
   18 Expected<Optional<DarwinSDKInfo>>
tools/clang/lib/Driver/Driver.cpp
  941   if (Optional<std::string> CompilerPathValue =
tools/clang/lib/Driver/Job.cpp
  316 int Command::Execute(ArrayRef<llvm::Optional<StringRef>> Redirects,
  326   Optional<ArrayRef<StringRef>> Env;
  395 int FallbackCommand::Execute(ArrayRef<llvm::Optional<StringRef>> Redirects,
  425 int ForceSuccessCommand::Execute(ArrayRef<llvm::Optional<StringRef>> Redirects,
tools/clang/lib/Driver/ToolChain.cpp
  428 Optional<std::string> ToolChain::getRuntimePath() const {
  446 Optional<std::string> ToolChain::getCXXStdlibPath() const {
tools/clang/lib/Driver/ToolChains/AVR.cpp
   32 llvm::Optional<StringRef> GetMcuFamilyName(StringRef MCU) {
   62       Optional<StringRef> FamilyName = GetMcuFamilyName(CPU);
   63       Optional<std::string> AVRLibcRoot = findAVRLibcInstallation();
  107   llvm::Optional<StringRef> FamilyName = GetMcuFamilyName(CPU);
  151 llvm::Optional<std::string> AVRToolChain::findAVRLibcInstallation() const {
tools/clang/lib/Driver/ToolChains/AVR.h
   36   llvm::Optional<std::string> findAVRLibcInstallation() const;
tools/clang/lib/Driver/ToolChains/Arch/RISCV.cpp
  360   llvm::Optional<StringRef> MArch;
tools/clang/lib/Driver/ToolChains/Cuda.cpp
  685     llvm::Optional<std::string> LibPath =
tools/clang/lib/Driver/ToolChains/Darwin.cpp
 1423 Optional<DarwinPlatform>
 1465 Optional<DarwinPlatform>
 1520 Optional<DarwinPlatform>
 1522                              const Optional<DarwinSDKInfo> &SDKInfo) {
 1600 Optional<DarwinPlatform>
 1623 Optional<DarwinPlatform> getDeploymentTargetFromTargetArg(
 1635 Optional<DarwinSDKInfo> parseSDKSettings(llvm::vfs::FileSystem &VFS,
 1680   Optional<DarwinPlatform> OSTarget =
 1683     Optional<DarwinPlatform> OSVersionArgTarget =
 1724         Optional<DarwinPlatform> SDKTarget =
tools/clang/lib/Driver/ToolChains/Darwin.h
  296   mutable Optional<DarwinSDKInfo> SDKInfo;
tools/clang/lib/Driver/ToolChains/Gnu.h
   29   llvm::Optional<Multilib> BiarchSibling;
  199     llvm::Optional<Multilib> BiarchSibling;
tools/clang/lib/Driver/ToolChains/Hexagon.cpp
  396 Optional<unsigned> HexagonToolChain::getSmallDataThreshold(
tools/clang/lib/Driver/ToolChains/Hexagon.h
  103   static Optional<unsigned> getSmallDataThreshold(
tools/clang/lib/Driver/ToolChains/MSVC.cpp
   74   if (llvm::Optional<std::string> VCToolsInstallDir =
   82   if (llvm::Optional<std::string> VCInstallDir =
   96   if (llvm::Optional<std::string> PathEnv =
 1246   if (llvm::Optional<std::string> cl_include_dir =
tools/clang/lib/Edit/RewriteObjCFoundationAPI.cpp
  694   Optional<bool> UpperU, UpperL;
  778   Optional<NSAPI::NSNumberLiteralMethodKind>
  986   Optional<NSAPI::NSNumberLiteralMethodKind>
tools/clang/lib/Format/ContinuationIndenter.cpp
  149 static llvm::Optional<StringRef> getRawStringDelimiter(StringRef TokenText) {
  186     llvm::Optional<FormatStyle> LanguageStyle =
  207 llvm::Optional<FormatStyle>
  215 llvm::Optional<FormatStyle>
 1740 llvm::Optional<FormatStyle>
tools/clang/lib/Format/ContinuationIndenter.h
   44   llvm::Optional<FormatStyle> getDelimiterStyle(StringRef Delimiter) const;
   46   llvm::Optional<FormatStyle>
  123   llvm::Optional<FormatStyle> getRawStringStyle(const FormatToken &Current,
tools/clang/lib/Format/Format.cpp
 1212 llvm::Optional<FormatStyle>
 1237 llvm::Optional<FormatStyle>
 2419   llvm::Optional<std::string> CurrentCode = None;
tools/clang/lib/Frontend/ASTUnit.cpp
  707       llvm::Optional<StoredDiagnostic> StoredDiag = None;
 1364     llvm::Optional<CaptureDroppedDiagnostics> Capture;
 1740     llvm::Optional<StringRef> ModuleFormat, std::unique_ptr<ASTUnit> *ErrAST,
tools/clang/lib/Frontend/DependencyFile.cpp
   49     Optional<FileEntryRef> File =
   86                   Optional<FileEntryRef> File,
tools/clang/lib/Frontend/FrontendActions.cpp
  290     Optional<FileEntryRef> FE = HS.LookupFile(
tools/clang/lib/Frontend/PrecompiledPreamble.cpp
  249   llvm::Optional<TempPCHFile> TempFile;
tools/clang/lib/Frontend/SerializedDiagnosticReader.cpp
   38   Optional<llvm::BitstreamBlockInfo> BlockInfo;
   76       Expected<Optional<llvm::BitstreamBlockInfo>> MaybeBlockInfo =
tools/clang/lib/Frontend/TextDiagnostic.cpp
  935 static llvm::Optional<std::pair<unsigned, unsigned>>
tools/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp
  531         Optional<FileEntryRef> File =
tools/clang/lib/Lex/HeaderMap.cpp
  148 Optional<StringRef> HeaderMapImpl::getString(unsigned StrTabIdx) const {
  180     if (Optional<StringRef> S = getString(Id))
  199 Optional<FileEntryRef> HeaderMap::LookupFile(StringRef Filename,
  224     Optional<StringRef> Key = getString(B.Key);
  232     Optional<StringRef> Prefix = getString(B.Prefix);
  233     Optional<StringRef> Suffix = getString(B.Suffix);
tools/clang/lib/Lex/HeaderSearch.cpp
  319 Optional<FileEntryRef> HeaderSearch::getFileAndSuggestModule(
  350 Optional<FileEntryRef> DirectoryLookup::LookupFile(
  412     Optional<FileEntryRef> Result = HM->LookupFile(Filename, HS.getFileMgr());
  487 Optional<FileEntryRef> DirectoryLookup::DoFrameworkLookup(
  728 Optional<FileEntryRef> HeaderSearch::LookupFile(
  797       if (Optional<FileEntryRef> FE = getFileAndSuggestModule(
  856   Optional<FileEntryRef> MSFE(MSFE_FE ? FileEntryRef(MSFE_Name, *MSFE_FE)
  900     Optional<FileEntryRef> File = SearchDirs[i].LookupFile(
  986       Optional<FileEntryRef> File = LookupFile(
 1023 Optional<FileEntryRef> HeaderSearch::LookupSubframeworkHeader(
tools/clang/lib/Lex/Lexer.cpp
 1237 Optional<Token> Lexer::findNextToken(SourceLocation Loc,
 1273   Optional<Token> Tok = findNextToken(Loc, SM, LangOpts);
tools/clang/lib/Lex/MacroInfo.cpp
  181   Optional<bool> isPublic;
tools/clang/lib/Lex/PPDirectives.cpp
  373 Optional<unsigned> Preprocessor::getSkippedRangeForExcludedConditionalBlock(
  718 Optional<FileEntryRef> Preprocessor::LookupFile(
  779     while (Optional<FileEntryRef> FE = HeaderInfo.LookupFile(
  797   Optional<FileEntryRef> FE = HeaderInfo.LookupFile(
  815       if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader(
  830         if (Optional<FileEntryRef> FE = HeaderInfo.LookupSubframeworkHeader(
 1714 Optional<FileEntryRef> Preprocessor::LookupHeaderIncludeOrImport(
 1722   Optional<FileEntryRef> File = LookupFile(
 1740         Optional<FileEntryRef> File = LookupFile(
 1759     Optional<FileEntryRef> File = LookupFile(
 1801     Optional<FileEntryRef> File = LookupFile(
 1925   Optional<FileEntryRef> File = LookupHeaderIncludeOrImport(
tools/clang/lib/Lex/PPMacroExpansion.cpp
 1213   Optional<FileEntryRef> File =
 1294   llvm::Optional<int> Result;
tools/clang/lib/Lex/Pragma.cpp
  516   Optional<FileEntryRef> File =
tools/clang/lib/Lex/PreprocessingRecord.cpp
  114     Optional<bool> IsInFile =
tools/clang/lib/Lex/Preprocessor.cpp
  571     Optional<FileEntryRef> File = LookupFile(
tools/clang/lib/Lex/TokenLexer.cpp
  250   Optional<bool> CalledWithVariadicArguments;
tools/clang/lib/Parse/ParseDecl.cpp
  467   llvm::Optional<ParseScope> PrototypeScope;
 5303     Optional<llvm::function_ref<void()>> CodeCompletionHandler) {
tools/clang/lib/Parse/ParseExpr.cpp
 3159 Optional<AvailabilitySpec> Parser::ParseAvailabilitySpec() {
 3211     Optional<AvailabilitySpec> Spec = ParseAvailabilitySpec();
tools/clang/lib/Parse/ParseOpenMP.cpp
 1012   Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
 1090 static Optional<SimpleClauseData>
 1142         Optional<SimpleClauseData> DevTypeData =
 2209   llvm::Optional<SimpleClauseData> Val = parseOpenMPSimpleClause(*this, Kind);
tools/clang/lib/Parse/ParsePragma.cpp
 1227     std::pair<Optional<attr::SubjectMatchRule>,
 1228               Optional<attr::SubjectMatchRule> (*)(StringRef, bool)>
tools/clang/lib/Parse/ParseStmt.cpp
 1244   llvm::Optional<bool> ConstexprCondition;
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp
  327       Optional<CFGStmt> S = E.getAs<CFGStmt>();
 1111             if (Optional<CFGStmt> CS = ElemIt->getAs<CFGStmt>()) {
 1198         if (Optional<CFGStmt> CS = ElemIt->getAs<CFGStmt>())
 2088   llvm::Optional<LogicalErrorHandler> LEH;
tools/clang/lib/Sema/Sema.cpp
  464   Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
  468   Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
 1298   if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
tools/clang/lib/Sema/SemaAttr.cpp
  600 Optional<attr::SubjectMatchRule>
  675       Optional<attr::SubjectMatchRule> ParentRule =
  699       Optional<attr::SubjectMatchRule> ParentRule =
tools/clang/lib/Sema/SemaCUDA.cpp
  282   llvm::Optional<CUDAFunctionTarget> InferredTarget;
tools/clang/lib/Sema/SemaChecking.cpp
 7360   Optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
 7393   Optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
 7420   Optional<ConversionSpecifier> FixedCS = CS.getStandardSpecifier();
10592   static llvm::Optional<StringRef>
13667 static Optional<int> GetNSMutableArrayArgumentIndex(Sema &S,
13678   Optional<NSAPI::NSArrayMethodKind> MKOpt =
13702 Optional<int> GetNSMutableDictionaryArgumentIndex(Sema &S,
13713   Optional<NSAPI::NSDictionaryMethodKind> MKOpt =
13734 static Optional<int> GetNSSetArgumentIndex(Sema &S, ObjCMessageExpr *Message) {
13748   Optional<NSAPI::NSSetMethodKind> MKOpt = S.NSAPIObj->getNSSetMethodKind(Sel);
13773   Optional<int> ArgOpt;
tools/clang/lib/Sema/SemaCodeComplete.cpp
 2737                        Optional<ArrayRef<QualType>> ObjCSubsts = None);
 2742                         Optional<ArrayRef<QualType>> ObjCSubsts = None) {
 2836                        Optional<ArrayRef<QualType>> ObjCSubsts) {
 3475       Optional<ArrayRef<QualType>> ObjCSubsts;
 4659     ExprValueKind BaseKind, RecordDecl *RD, Optional<FixItHint> AccessOpFixIt) {
 7429                                      Optional<bool> WantInstanceMethods,
 8153 void Sema::CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod,
tools/clang/lib/Sema/SemaDecl.cpp
12400   Optional<bool> CacheHasConstInit;
17666     Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
17679       Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
tools/clang/lib/Sema/SemaDeclAttr.cpp
 7732 static Optional<unsigned>
 7765 static Optional<AttributeInsertion>
 7886       Optional<AttributeInsertion> Insertion = createAttributeInsertion(
 7988         Optional<unsigned> NumParams = tryParseObjCMethodName(
tools/clang/lib/Sema/SemaExpr.cpp
 5304   Optional<CharUnits> ArgSize =
 5306   Optional<CharUnits> ParmSize = getASTContext().getTypeSizeInCharsIfKnown(CAT);
 7745     Optional<NullabilityKind> Kind = Ty->getNullability(Ctx);
tools/clang/lib/Sema/SemaExprCXX.cpp
 1653   Optional<Expr *> ArraySize;
 1911   llvm::Optional<uint64_t> KnownArraySize;
 7492     if (const Optional<unsigned> Index =
 7526     if (const Optional<unsigned> Index =
tools/clang/lib/Sema/SemaExprObjC.cpp
  245   Optional<NSAPI::NSNumberLiteralMethodKind> Kind =
  591       Optional<NullabilityKind> Nullability =
 1653   Optional<ArrayRef<QualType>> typeArgs
tools/clang/lib/Sema/SemaLambda.cpp
   62 static inline Optional<unsigned>
   67   const Optional<unsigned> NoLambdaIsCaptureReady;
  173 Optional<unsigned> clang::getStackIndexOfNearestEnclosingCaptureCapableLambda(
  177   const Optional<unsigned> NoLambdaIsCaptureCapable;
  179   const Optional<unsigned> OptionalStackIndex =
  434     Optional<std::tuple<unsigned, bool, Decl *>> Mangling) {
  787     Optional<unsigned> NumExpansions, IdentifierInfo *Id, bool IsDirectInit,
tools/clang/lib/Sema/SemaLookup.cpp
  522     llvm::Optional<unsigned> ExistingI;
tools/clang/lib/Sema/SemaModule.cpp
  598 static llvm::Optional<UnnamedDeclKind> getUnnamedDeclKind(Decl *D) {
tools/clang/lib/Sema/SemaOpenMP.cpp
  140     llvm::Optional<std::pair<const Expr *, OMPOrderedClause *>> OrderedRegion;
 2086     Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
 2100       Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
 2812       llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
 4957 Optional<std::pair<FunctionDecl *, Expr *>>
 5320   llvm::Optional<bool> TestIsLessOp;
 5329   Optional<unsigned> InitDependOnLC;
 5332   Optional<unsigned> CondDependOnLC;
 5334   Optional<unsigned> doesDependOnLoopCounter(const Stmt *S, bool IsInitializer);
 5417   bool setUB(Expr *NewUB, llvm::Optional<bool> LessOp, bool StrictOp,
 5456                                         llvm::Optional<bool> LessOp,
 5627 Optional<unsigned>
16224   Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
16232   Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
16251   Optional<OMPDeclareTargetDeclAttr::MapTypeTy> MapTy =
16257     llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> MapTy =
16308     llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
16316     Optional<OMPDeclareTargetDeclAttr::DevTypeTy> DevTy =
tools/clang/lib/Sema/SemaOverload.cpp
  840 llvm::Optional<unsigned> DeductionFailureInfo::getCallArgIndex() {
 9211     Optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
 9212     Optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
tools/clang/lib/Sema/SemaTemplate.cpp
  762   llvm::Optional<unsigned> Note;
 4237   Optional<bool> IsSatisfied;
 5150 static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) {
 5238     if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
 6360     Optional<unsigned> Depth = Param->getDepth() + 1;
tools/clang/lib/Sema/SemaTemplateDeduction.cpp
  644 static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) {
  711     if (Optional<unsigned> ExpandedPackExpansions =
  942       if (Optional<unsigned> Expansions = getExpandedPackSize(Param)) {
  964   Optional<unsigned> FixedNumExpansions;
 1087       Optional<unsigned> NumExpansions = Expansion->getNumExpansions();
 3041       Optional<unsigned> Expansions = getExpandedPackSize(Param);
 3931       Optional<unsigned> NumExpansions = ParamExpansion->getNumExpansions();
 4374                      Optional<unsigned> DependentDeductionDepth) {
 4420                      Optional<unsigned> DependentDeductionDepth) {
tools/clang/lib/Sema/SemaTemplateInstantiate.cpp
  721 Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const {
  830                                  Optional<unsigned> &NumExpansions) {
  989                                             Optional<unsigned> NumExpansions,
 1515                                                Optional<unsigned> NumExpansions,
 1809                                     Optional<unsigned> NumExpansions,
 1964       Optional<unsigned> NumExpansions;
tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
  118   Optional<unsigned> NumExpansions;
  396   Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
 2069     Optional<const ASTTemplateArgumentListInfo *>
 2476     Optional<unsigned> OrigNumExpansions
 2478     Optional<unsigned> NumExpansions = OrigNumExpansions;
 2631     Optional<unsigned> NumExpansions;
 2863     Optional<unsigned> NumExpansions;
 3846         Optional<unsigned> NumArgumentsInExpansion;
 3948     Optional<unsigned> NumArgumentsInExpansion
 4942       Optional<unsigned> NumExpansions;
tools/clang/lib/Sema/SemaTemplateVariadic.cpp
  584                          Optional<unsigned> NumExpansions) {
  602                                   Optional<unsigned> NumExpansions) {
  625                                     Optional<unsigned> NumExpansions) {
  649     bool &RetainExpansion, Optional<unsigned> &NumExpansions) {
  654   Optional<unsigned> NumPartialExpansions;
  782 Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T,
  788   Optional<unsigned> Result;
 1027       SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions) const {
 1084 Optional<unsigned> Sema::getFullyPackExpandedSize(TemplateArgument Arg) {
 1206                                   Optional<unsigned> NumExpansions) {
tools/clang/lib/Sema/SemaType.cpp
 4097   Optional<NullabilityKind> inferNullability;
tools/clang/lib/Sema/TreeTransform.h
  263                                Optional<unsigned> &NumExpansions) {
  659                                           Optional<unsigned> NumExpansions,
 1153                                     Optional<unsigned> NumExpansions) {
 3265                                            Optional<unsigned> NumExpansions) {
 3554       Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions();
 3555       Optional<unsigned> NumExpansions = OrigNumExpansions;
 4146       Optional<unsigned> OrigNumExpansions;
 4159       Optional<unsigned> NumExpansions = OrigNumExpansions;
 5097     ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions,
 5165       Optional<unsigned> NumExpansions;
 5181         Optional<unsigned> OrigNumExpansions =
 5270     Optional<unsigned> NumExpansions;
 5522       Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
 6524       Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
 6832   llvm::Optional<bool> ConstexprConditionValue;
10623   Optional<Expr *> ArraySize;
10624   if (Optional<Expr *> OldArraySize = E->getArraySize()) {
11005     Optional<unsigned> OrigNumExpansions =
11007     Optional<unsigned> NumExpansions = OrigNumExpansions;
11433       Optional<unsigned> OrigNumExpansions =
11435       Optional<unsigned> NumExpansions = OrigNumExpansions;
11500   Optional<std::tuple<unsigned, bool, Decl *>> Mangling;
11615       Optional<unsigned> NumExpansions;
12002     Optional<unsigned> NumExpansions;
12045   Optional<unsigned> Result = 0;
12057     Optional<unsigned> OrigNumExpansions;
12070     Optional<unsigned> NumExpansions =
12164   Optional<unsigned> OrigNumExpansions = E->getNumExpansions(),
12344       Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions;
12345       Optional<unsigned> NumExpansions = OrigNumExpansions;
tools/clang/lib/Serialization/ASTReader.cpp
 3337         llvm::Optional<Preprocessor::PreambleSkipInfo> SkipInfo;
 6099 Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
 6124     Optional<HeaderFileInfo> HFI;
 6144     Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
 6152   if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
 6672     Optional<unsigned> NumExpansions;
 9036 llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
 9316     Optional<unsigned> NumTemplateExpansions;
tools/clang/lib/Serialization/ASTReaderDecl.cpp
 2914     Optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
 2915     Optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
tools/clang/lib/Serialization/ASTWriter.cpp
  509   if (Optional<unsigned> NumExpansions = T->getNumExpansions())
 4635   if (Optional<unsigned> Minor = Version.getMinor())
 4639   if (Optional<unsigned> Subminor = Version.getSubminor())
 6052     if (Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions())
tools/clang/lib/Serialization/ASTWriterDecl.cpp
 2401     Optional<GVALinkage> Linkage;
tools/clang/lib/StaticAnalyzer/Checkers/AnalyzerStatsChecker.cpp
   62     if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>()) {
  127     if (Optional<CFGStmt> CS = CE.getAs<CFGStmt>()) {
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp
   86   Optional<nonloc::SymbolVal> SymVal = offset.getAs<nonloc::SymbolVal>();
  145   if (Optional<NonLoc> NV = extentBegin.getAs<NonLoc>()) {
  158     Optional<NonLoc> lowerBoundToCheck = lowerBound.getAs<NonLoc>();
  198     Optional<NonLoc> upperboundToCheck = upperbound.getAs<NonLoc>();
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp
  375 static Optional<uint64_t> GetCFNumberSize(ASTContext &Ctx, uint64_t i) {
  448   Optional<nonloc::ConcreteInt> V = TheTypeVal.getAs<nonloc::ConcreteInt>();
  453   Optional<uint64_t> OptCFNumberSize = GetCFNumberSize(Ctx, NumberKind);
  468   Optional<loc::MemRegionVal> LV = TheValueExpr.getAs<loc::MemRegionVal>();
  559   Optional<DefinedSVal> DefArgVal = ArgVal.getAs<DefinedSVal>();
  747   Optional<ExplodedNode*> errorNode;
  862   Optional<DefinedSVal> KnownCollection = CollectionVal.getAs<DefinedSVal>();
  894   Optional<Loc> ElementLoc;
  933   Optional<DefinedSVal> CountGreaterThanZero =
  962   if (Optional<BlockEdge> BE = P.getAs<BlockEdge>()) {
 1180   if (Optional<DefinedOrUnknownSVal> DV = Val.getAs<DefinedOrUnknownSVal>())
tools/clang/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp
   73   Optional<DefinedSVal> DV = val.getAs<DefinedSVal>();
   90   Optional<DefinedSVal> greaterThanEqualToZero =
  126   Optional<DefinedSVal> lessThanEqToOne =
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp
  270   Optional<DefinedSVal> val = V.getAs<DefinedSVal>();
  403   Optional<NonLoc> Length = LengthVal.getAs<NonLoc>();
  416   if (Optional<Loc> BufLoc = BufStart.getAs<Loc>()) {
  436     if (Optional<Loc> BufLoc = BufStart.getAs<Loc>()) {
  472   Optional<Loc> firstLoc = firstVal.getAs<Loc>();
  476   Optional<Loc> secondLoc = secondVal.getAs<Loc>();
  499   Optional<DefinedOrUnknownSVal> reverseTest =
  520   Optional<NonLoc> Length = LengthVal.getAs<NonLoc>();
  530   Optional<Loc> FirstStartLoc = FirstStart.getAs<Loc>();
  537   Optional<Loc> FirstEndLoc = FirstEnd.getAs<Loc>();
  544   Optional<DefinedOrUnknownSVal> OverlapTest =
  689   if (Optional<NonLoc> maxMinusRightNL = maxMinusRight.getAs<NonLoc>()) {
  774     if (Optional<NonLoc> strLn = strLength.getAs<NonLoc>()) {
  800     if (Optional<loc::GotoLabel> Label = Buf.getAs<loc::GotoLabel>()) {
  904   Optional<NonLoc> Length = LengthVal.getAs<NonLoc>();
  917   Optional<Loc> BufLoc = BufStart.getAs<Loc>();
  957   Optional<Loc> L = V.getAs<Loc>();
  964   if (Optional<loc::MemRegionVal> MR = L->getAs<loc::MemRegionVal>()) {
 1062   Optional<NonLoc> SizeNL = SizeVal.getAs<NonLoc>();
 1416     Optional<NonLoc> strLengthNL = strLength.getAs<NonLoc>();
 1417     Optional<NonLoc> maxlenValNL = maxlenVal.getAs<NonLoc>();
 1593     Optional<NonLoc> strLengthNL = strLength.getAs<NonLoc>();
 1594     Optional<NonLoc> lenValNL = lenVal.getAs<NonLoc>();
 1633         if (Optional<NonLoc> dstStrLengthNL = dstStrLength.getAs<NonLoc>()) {
 1686       if (Optional<NonLoc> amountCopiedNL = amountCopied.getAs<NonLoc>()) {
 1736     Optional<NonLoc> srcStrLengthNL = amountCopied.getAs<NonLoc>();
 1737     Optional<NonLoc> dstStrLengthNL = dstStrLength.getAs<NonLoc>();
 1758       if (Optional<NonLoc> finalStrLengthNL = finalStrLength.getAs<NonLoc>()) {
 1805   if (Optional<loc::MemRegionVal> dstRegVal =
 1812       if (Optional<NonLoc> maxLastNL = maxLastElementIndex.getAs<NonLoc>()) {
 1823     if (Optional<NonLoc> knownStrLength = finalStrLength.getAs<NonLoc>()) {
 2060   if (Optional<Loc> SearchStrLoc = SearchStrVal.getAs<Loc>()) {
tools/clang/lib/StaticAnalyzer/Checkers/CastValueChecker.cpp
  394   Optional<DefinedOrUnknownSVal> DV;
tools/clang/lib/StaticAnalyzer/Checkers/CheckObjCDealloc.cpp
  285     Optional<Loc> LValLoc = LVal.getAs<Loc>();
  956   Optional<Loc> LValLoc = LVal.getAs<Loc>();
tools/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp
   70   Optional<DefinedSVal> DV = Denom.getAs<DefinedSVal>();
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp
  759   Optional<ArrayRef<QualType>> TypeArgs =
  861   Optional<ArrayRef<QualType>> TypeArgs =
tools/clang/lib/StaticAnalyzer/Checkers/EnumCastOutOfRangeChecker.cpp
  111   const llvm::Optional<DefinedOrUnknownSVal> ValueToCast =
tools/clang/lib/StaticAnalyzer/Checkers/ExprInspectionChecker.cpp
  341     : public SymExprVisitor<SymbolExpressor, Optional<std::string>> {
  347   Optional<std::string> lookup(const SymExpr *S) {
  355   Optional<std::string> VisitSymExpr(const SymExpr *S) {
  359   Optional<std::string> VisitSymIntExpr(const SymIntExpr *S) {
  360     if (Optional<std::string> Str = lookup(S))
  362     if (Optional<std::string> Str = Visit(S->getLHS()))
  370   Optional<std::string> VisitSymSymExpr(const SymSymExpr *S) {
  371     if (Optional<std::string> Str = lookup(S))
  373     if (Optional<std::string> Str1 = Visit(S->getLHS()))
  374       if (Optional<std::string> Str2 = Visit(S->getRHS()))
  380   Optional<std::string> VisitSymbolCast(const SymbolCast *S) {
  381     if (Optional<std::string> Str = lookup(S))
  383     if (Optional<std::string> Str = Visit(S->getOperand()))
tools/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp
  261   Optional<Loc> FieldLoc =
tools/clang/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp
  115   static Optional<SVal> getPointedToSVal(CheckerContext &C, const Expr *Arg);
  219       Optional<SVal> V = getPointedToSVal(C, E);
  517     Optional<SVal> V = getPointedToSVal(C, Arg);
  558 Optional<SVal> GenericTaintChecker::getPointedToSVal(CheckerContext &C,
  565   Optional<Loc> AddrLoc = AddrVal.getAs<Loc>();
  727   Optional<SVal> PointedToSVal = getPointedToSVal(C, E);
  847   llvm::Optional<TaintConfig> Config =
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp
 1007   Optional<StmtPoint> Point = Succ->getLocation().getAs<StmtPoint>();
tools/clang/lib/StaticAnalyzer/Checkers/MIGChecker.cpp
  158   if (Optional<AnyCall> AC = AnyCall::forDecl(D)) {
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp
  213   if (Optional<loc::MemRegionVal> X = ArgV.getAs<loc::MemRegionVal>()) {
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
  211                                             Optional<SVal> RetVal = None);
  399   mutable Optional<uint64_t> KernelZeroFlagVal;
  417                                                Optional<SVal> RetVal = None);
  473   llvm::Optional<ProgramStateRef>
  623   Optional<CheckKind> getCheckIfTracked(AllocationFamily Family,
  625   Optional<CheckKind> getCheckIfTracked(CheckerContext &C,
  628   Optional<CheckKind> getCheckIfTracked(CheckerContext &C, SymbolRef Sym,
  966 llvm::Optional<ProgramStateRef> MallocChecker::performKernelMalloc(
 1084         llvm::Optional<ProgramStateRef> MaybeState =
 1095       llvm::Optional<ProgramStateRef> MaybeState =
 1232     ProgramStateRef State, Optional<SVal> RetVal) {
 1255   Optional<DefinedSVal> DefArgVal = C.getSVal(Arg).getAs<DefinedSVal>();
 1449 static Optional<bool> getFreeWhenDoneArg(const ObjCMethodCall &Call) {
 1468   if (Optional<bool> FreeWhenDone = getFreeWhenDoneArg(Call))
 1540   if (Optional<DefinedOrUnknownSVal> DefinedSize =
 1557                                             Optional<SVal> RetVal) {
 1904 Optional<MallocChecker::CheckKind>
 1939 Optional<MallocChecker::CheckKind>
 1947 Optional<MallocChecker::CheckKind>
 1959   if (Optional<nonloc::ConcreteInt> IntVal = V.getAs<nonloc::ConcreteInt>())
 1961   else if (Optional<loc::ConcreteInt> ConstAddr = V.getAs<loc::ConcreteInt>())
 1963   else if (Optional<loc::GotoLabel> Label = V.getAs<loc::GotoLabel>())
 2053   Optional<MallocChecker::CheckKind> CheckKind =
 2095   Optional<MallocChecker::CheckKind> CheckKind;
 2183   Optional<MallocChecker::CheckKind> CheckKind =
 2240   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
 2278   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
 2306   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
 2333   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, Sym);
 2362   Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(C, FreeExpr);
 2568   Optional<MallocChecker::CheckKind>
 2955     if (Optional<bool> FreeWhenDone = getFreeWhenDoneArg(*Msg))
 3366       Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(Family);
tools/clang/lib/StaticAnalyzer/Checkers/MallocOverflowSecurityChecker.cpp
  310       if (Optional<CFGStmt> CS = bi->getAs<CFGStmt>()) {
tools/clang/lib/StaticAnalyzer/Checkers/MmapWriteExecChecker.cpp
   51     Optional<nonloc::ConcreteInt> ProtLoc = ProtVal.getAs<nonloc::ConcreteInt>();
tools/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp
  189   if (Optional<loc::MemRegionVal> X = val.getAs<loc::MemRegionVal>()) {
tools/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp
   78     Optional<DefinedOrUnknownSVal> Constr = V.getAs<DefinedOrUnknownSVal>();
   92   Optional<loc::MemRegionVal> RegionVal = V.getAs<loc::MemRegionVal>();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
  287   Optional<Loc> IVarLoc = C.getSVal(IRE).getAs<Loc>();
  415 static Optional<RefVal> refValFromRetEffect(RetEffect RE,
  695     if (Optional<RefVal> updatedRefVal = refValFromRetEffect(RE, ResultTy))
  910   Optional<BehaviorSummary> BSmr =
 1338   Optional<AnyCall> C = AnyCall::forDecl(D);
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
  169 static Optional<unsigned> findArgIdxOfSymbol(ProgramStateRef CurrSt,
  172                                              Optional<CallEventRef<>> CE) {
  185 static Optional<std::string> findMetaClassAlloc(const Expr *Callee) {
  253   Optional<CallEventRef<>> CE = Mgr.getCall(S, CurrSt, LCtx);
  606 static Optional<std::string> describeRegion(const MemRegion *MR) {
  697     if (Optional<StmtPoint> SP = AllocPP.getAs<StmtPoint>())
  748   Optional<std::string> RegionDescription = describeRegion(FirstBinding);
  895   Optional<std::string> RegionDescription = describeRegion(AllocBinding);
tools/clang/lib/StaticAnalyzer/Checkers/ReturnValueChecker.cpp
   72 static Optional<bool> isInvariantBreak(bool ExpectedValue, SVal ReturnV,
   92   Optional<bool> IsInvariantBreak = isInvariantBreak(ExpectedValue, ReturnV, C);
  139   Optional<bool> IsInvariantBreak = isInvariantBreak(ExpectedValue, ReturnV, C);
tools/clang/lib/StaticAnalyzer/Checkers/StdLibraryFunctionsChecker.cpp
  230   Optional<FunctionSummaryTy> findFunctionSummary(const FunctionDecl *FD,
  349   Optional<FunctionSummaryTy> FoundSummary = findFunctionSummary(FD, CE, C);
  380   Optional<FunctionSummaryTy> FoundSummary = findFunctionSummary(FD, CE, C);
  431 Optional<StdLibraryFunctionsChecker::FunctionSummaryTy>
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp
  265   Optional<nonloc::ConcreteInt> CI = Whence.getAs<nonloc::ConcreteInt>();
  335   Optional<DefinedSVal> DV = SV.getAs<DefinedSVal>();
tools/clang/lib/StaticAnalyzer/Checkers/Taint.cpp
   66     if (Optional<SVal> binding =
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp
  103   if (Optional<PostStmt> P = Succ->getLocationAs<PostStmt>())
  135   Optional<DefinedSVal> DSV = S.getAs<DefinedSVal>();
tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp
   91       if (Optional<PostStmt> PS = P.getAs<PostStmt>())
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp
   72     if (Optional<UndefinedVal> V =
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedPointee.cpp
  127 static llvm::Optional<DereferenceInfo> dereference(ProgramStateRef State,
  164   llvm::Optional<DereferenceInfo> DerefInfo = dereference(State, FR);
  222 static llvm::Optional<DereferenceInfo> dereference(ProgramStateRef State,
tools/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp
   42   mutable Optional<uint64_t> Val_O_CREAT;
tools/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp
   77     if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>()) {
  132         if (Optional<CFGStmt> S = (*ci).getAs<CFGStmt>())
  202     if (Optional<CFGStmt> S = I->getAs<CFGStmt>()) {
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp
  142   if (Optional<DefinedSVal> LessThanZeroDVal =
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp
  155   Optional<DefinedOrUnknownSVal> DVal =
tools/clang/lib/StaticAnalyzer/Checkers/Yaml.h
   27 llvm::Optional<T> getConfiguration(CheckerManager &Mgr, Checker *Chk,
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp
  219   static Optional<PathDiagnosticBuilder>
  306     if (Optional<loc::MemRegionVal> Reg = SV.getAs<loc::MemRegionVal>()) {
 1030     Optional<StmtPoint> SP = N->getLocation().getAs<StmtPoint>();
 1191   if (Optional<CallExitEnd> CE = P.getAs<CallExitEnd>()) {
 1561 static Optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
 1591 static Optional<size_t> getLengthOnSingleLine(const SourceManager &SM,
 1651       Optional<size_t> s1Length = getLengthOnSingleLine(SM, s1Start);
 1653         Optional<size_t> s2Length = getLengthOnSingleLine(SM, s2Start);
 1712     Optional<size_t> ByteWidth = getLengthOnSingleLine(SM, EdgeRange);
 2239 Optional<bugreporter::TrackingKind>
 2264 Optional<bugreporter::TrackingKind>
 2276 Optional<bugreporter::TrackingKind>
 2316   if (Optional<BlockEntrance> BE = ProgP.getAs<BlockEntrance>()) {
 2348     if (Optional<PreImplicitCall> PIE = P.getAs<PreImplicitCall>())
 2749 Optional<PathDiagnosticBuilder> PathDiagnosticBuilder::findValidReport(
 2808   Optional<PathDiagnosticBuilder> PDB =
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp
  183 static Optional<SVal> getSValForVar(const Expr *CondVarExpr,
  207 static Optional<const llvm::APSInt *>
  210   if (Optional<SVal> V = getSValForVar(CondVarExpr, N))
  225   if (Optional<SVal> V = getSValForVar(CondVarExpr, N))
  226     if (Optional<bugreporter::TrackingKind> K = B->getInterestingnessKind(*V))
  234   if (Optional<SVal> V = getSValForVar(E, N))
  387   const Optional<RegionVector>
  492 const Optional<NoStoreFuncVisitor::RegionVector>
  510         if (Optional<RegionVector> Out =
  536       if (Optional<RegionVector> Out =
  604         if (Optional<RegionVector> P =
  852   Optional<SourceLocation> matchAssignment(const ExplodedNode *N) {
  942       if (Optional<CallExitEnd> CEE = Node->getLocationAs<CallExitEnd>())
  957         if (Optional<StmtPoint> SP = Node->getLocationAs<StmtPoint>())
  972     Optional<CallExitEnd> CEE = Node->getLocationAs<CallExitEnd>();
  986       if (Optional<Loc> LValue = RetVal.getAs<Loc>())
  995       if (Optional<Loc> RetLoc = RetVal.getAs<Loc>())
 1010     Optional<StmtPoint> SP = N->getLocationAs<StmtPoint>();
 1032     Optional<Loc> LValue;
 1136     Optional<CallEnter> CE = N->getLocationAs<CallEnter>();
 1154       Optional<Loc> ArgV = Call->getArgSVal(I).getAs<Loc>();
 1217   Optional<PostStmt> P = N->getLocationAs<PostStmt>();
 1382   if (Optional<PostInitializer> PIP = Pred->getLocationAs<PostInitializer>()) {
 1400       Optional<PostStore> PS = Succ->getLocationAs<PostStore>();
 1409     if (Optional<PostStmt> P = Succ->getLocationAs<PostStmt>())
 1418     if (Optional<CallEnter> CE = Succ->getLocationAs<CallEnter>()) {
 1467   if (Optional<PostStmt> PS = StoreSite->getLocationAs<PostStmt>()) {
 1881       if (Optional<BlockEdge> BE = ProgPoint.getAs<BlockEdge>()) {
 2097   Optional<PreStmt> P = N->getLocationAs<PreStmt>();
 2161   if (Optional<BlockEdge> BE = ProgPoint.getAs<BlockEdge>()) {
 2178   if (Optional<PostStmt> PS = ProgPoint.getAs<PostStmt>()) {
 2323                                       Optional<bool> &prunable,
 2409   Optional<bool> shouldPrune;
 2643   Optional<const llvm::APSInt *> IntValue;
 2769   Optional<CallEnter> CEnter = ProgLoc.getAs<CallEnter>();
 2848   Optional<bool> isSat = RefutationSolver->check();
 2899   if (Optional<std::string> Msg = T->generateMessage(BRC, R)) {
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp
 1272             llvm::DenseMap<PrivateMethodKey, Optional<const ObjCMethodDecl *>>;
 1275         Optional<const ObjCMethodDecl *> &Val = PMC[std::make_pair(IDecl, Sel)];
 1418   if (Optional<CFGAutomaticObjDtor> AutoDtor = E.getAs<CFGAutomaticObjDtor>())
 1420   else if (Optional<CFGDeleteDtor> DeleteDtor = E.getAs<CFGDeleteDtor>())
tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp
  247       if (Optional<CFGStmt> LastStmt = LastElement.getAs<CFGStmt>()) {
  249       } else if (Optional<CFGAutomaticObjDtor> AutoDtor =
  288   if (Optional<CFGElement> E = L.getFirstElement()) {
tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp
  144   if (Optional<StmtPoint> SP = SuccLoc.getAs<StmtPoint>())
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
  262       Optional<DefinedOrUnknownSVal> Constraint =
  282     if (Optional<Loc> LV = V.getAs<Loc>()) {
  298         if (Optional<Loc> LV = V.getAs<Loc>()) {
  374     if (Optional<SVal> V = getObjectUnderConstruction(State, MT, LC)) {
  473 Optional<SVal>
  478   return Optional<SVal>::create(State->get<ObjectsUnderConstruction>(Key));
  867           if (Optional<Loc> LValueLoc = LValue.getAs<Loc>())
 1076   if (Optional<SVal> V =
 1433       Optional<SVal> ConstantVal = svalBuilder.getConstantVal(ArgE);
 1870     if (Optional<StmtPoint> SP = L.getAs<StmtPoint>())
 2077     Optional<CFGStmt> CS = Elem.getAs<CFGStmt>();
 2224   if (Optional<loc::GotoLabel> LV = V.getAs<loc::GotoLabel>()) {
 2376     if (Optional<NonLoc> NL = CondV.getAs<NonLoc>())
 2435     Optional<std::pair<SVal, QualType>> VInfo;
 2798     if (Optional<loc::MemRegionVal> LocRegVal =
 2939     Optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>();
 2980     if (Optional<Loc> LV = X.getAs<Loc>())
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp
  818     if (Optional<CFGStmt> CS = CE.getAs<CFGStmt>()) {
 1036           if (Optional<Loc> LV = V.getAs<Loc>()) {
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp
   77   if (Optional<Loc> L = V.getAs<Loc>())
  403   if (Optional<SVal> ElidedTarget =
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp
   84       if (Optional<StmtPoint> SP = PP.getAs<StmtPoint>()) {
   87       } else if (Optional<CallExitEnd> CEE = PP.getAs<CallExitEnd>()) {
   95         Optional<CallEnter> CE;
  102       } else if (Optional<BlockEdge> BE = PP.getAs<BlockEdge>()) {
  105     } else if (Optional<CallEnter> CE = PP.getAs<CallEnter>()) {
  535     if (Optional<SVal> V =
  937   Optional<bool> MayInline = Engine.FunctionSummaries->mayInline(D);
tools/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp
  238     if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>())
tools/clang/lib/StaticAnalyzer/Core/MemRegion.cpp
 1410       if (Optional<nonloc::ConcreteInt> CI =
tools/clang/lib/StaticAnalyzer/Core/ProgramState.cpp
  567   if (Optional<loc::MemRegionVal> X = val.getAs<loc::MemRegionVal>())
  570   if (Optional<nonloc::LazyCompoundVal> X =
  574   if (Optional<nonloc::LocAsInteger> X = val.getAs<nonloc::LocAsInteger>())
  583   if (Optional<nonloc::CompoundVal> X = val.getAs<nonloc::CompoundVal>())
tools/clang/lib/StaticAnalyzer/Core/RangeConstraintManager.cpp
  337   Optional<nonloc::SymbolVal> SymVal = X.getAs<nonloc::SymbolVal>();
tools/clang/lib/StaticAnalyzer/Core/RegionStore.cpp
  215   Optional<SVal> getDirectBinding(const MemRegion *R) const;
  219   Optional<SVal> getDefaultBinding(const MemRegion *R) const;
  265 Optional<SVal> RegionBindingsRef::getDirectBinding(const MemRegion *R) const {
  266   return Optional<SVal>::create(lookup(R, BindingKey::Direct));
  269 Optional<SVal> RegionBindingsRef::getDefaultBinding(const MemRegion *R) const {
  270   return Optional<SVal>::create(lookup(R, BindingKey::Default));
  495   Optional<RegionBindingsRef> tryBindSmallStruct(RegionBindingsConstRef B,
  553   Optional<SVal> getDefaultBinding(Store S, const MemRegion *R) override {
  594   Optional<SVal> getBindingForDerivedDefaultValue(RegionBindingsConstRef B,
  880   if (Optional<nonloc::ConcreteInt> ExtentCI =
 1052   if (Optional<nonloc::LazyCompoundVal> LCS =
 1126         if (Optional<Loc> L = V.getAs<Loc>()) {
 1186       Optional<uint64_t> NumElements;
 1221         Optional<uint64_t> ROffset =
 1310     if (Optional<nonloc::LazyCompoundVal> LCS =
 1591 static Optional<nonloc::LazyCompoundVal>
 1594   Optional<SVal> V = B.getDefaultBinding(R);
 1598   Optional<nonloc::LazyCompoundVal> LCV = V->getAs<nonloc::LazyCompoundVal>();
 1631     if (Optional<nonloc::LazyCompoundVal> V =
 1675   if (const Optional<SVal> &V = B.getDirectBinding(R))
 1690     if (Optional<nonloc::ConcreteInt> CI = Idx.getAs<nonloc::ConcreteInt>()) {
 1730               if (Optional<SVal> V = svalBuilder.getConstantVal(ElemInit))
 1761           if (const Optional<SVal> &V = B.getDirectBinding(superR)) {
 1782   if (const Optional<SVal> &V = B.getDirectBinding(R))
 1790       if (Optional<SVal> V = svalBuilder.getConstantVal(Init))
 1808               if (Optional<SVal> V = svalBuilder.getConstantVal(FieldInit))
 1819 Optional<SVal>
 1825   if (const Optional<SVal> &D = B.getDefaultBinding(superR)) {
 1916     if (Optional<SVal> D = getBindingForDerivedDefaultValue(B, Base, R, Ty)) {
 1965   if (const Optional<SVal> &V = B.getDirectBinding(R))
 1971   if (const Optional<SVal> &V = B.getDefaultBinding(superR)) {
 1986   if (Optional<SVal> V = B.getDirectBinding(R))
 1989   if (Optional<SVal> V = B.getDefaultBinding(R))
 2003       if (Optional<SVal> V = svalBuilder.getConstantVal(Init))
 2024         if (Optional<SVal> V = svalBuilder.getConstantVal(Init))
 2034     if (Optional<SVal> V = getBindingForDerivedDefaultValue(B, MS, R, T)) {
 2079     if (Optional<nonloc::LazyCompoundVal> InnerLCV =
 2094   if (Optional<nonloc::LazyCompoundVal> V =
 2155   if (Optional<loc::MemRegionVal> LV = L.getAs<loc::MemRegionVal>())
 2238   Optional<uint64_t> Size;
 2246   if (Optional<loc::MemRegionVal> MRV = Init.getAs<loc::MemRegionVal>()) {
 2330 Optional<RegionBindingsRef>
 2386   if (Optional<nonloc::LazyCompoundVal> LCV =
 2388     if (Optional<RegionBindingsRef> NewB = tryBindSmallStruct(B, R, RD, *LCV))
 2591   if (Optional<nonloc::LazyCompoundVal> LCS =
tools/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp
  104   if (Optional<nonloc::ConcreteInt> CI = val.getAs<nonloc::ConcreteInt>()) {
  285 Optional<SVal> SValBuilder::getConstantVal(const Expr *E) {
  347       Optional<SVal> Val = getConstantVal(SE);
  394     if (Optional<nonloc::ConcreteInt> rInt = RHS.getAs<nonloc::ConcreteInt>())
  398     if (Optional<nonloc::ConcreteInt> lInt = LHS.getAs<nonloc::ConcreteInt>())
  417   if (Optional<Loc> LV = lhs.getAs<Loc>()) {
  418     if (Optional<Loc> RV = rhs.getAs<Loc>())
  424   if (Optional<Loc> RV = rhs.getAs<Loc>()) {
  547     if (Optional<Loc> L = val.getAs<Loc>())
  566     if (Optional<nonloc::LocAsInteger> LV = val.getAs<nonloc::LocAsInteger>()) {
tools/clang/lib/StaticAnalyzer/Core/SVals.cpp
   45   if (Optional<nonloc::SymbolVal> SV = getAs<nonloc::SymbolVal>()) {
   51   if (Optional<loc::MemRegionVal> RV = getAs<loc::MemRegionVal>()) {
   64   if (Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) {
   87   if (Optional<nonloc::LocAsInteger> X = getAs<nonloc::LocAsInteger>())
   90   if (Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) {
  102   Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>();
  129   if (Optional<nonloc::SymbolVal> X = getAs<nonloc::SymbolVal>())
  138   if (Optional<nonloc::SymbolVal> X = getAs<nonloc::SymbolVal>())
  152   if (Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>())
  155   if (Optional<nonloc::LocAsInteger> X = getAs<nonloc::LocAsInteger>())
  227   if (Optional<loc::ConcreteInt> LV = getAs<loc::ConcreteInt>())
  229   if (Optional<nonloc::ConcreteInt> NV = getAs<nonloc::ConcreteInt>())
tools/clang/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp
  129         Optional<StringRef> URI = FileLoc->getString("uri");
tools/clang/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp
   29   if (Optional<Loc> LV = Cond.getAs<Loc>()) {
tools/clang/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp
   79   if (Optional<nonloc::LocAsInteger> LI = val.getAs<nonloc::LocAsInteger>()) {
  446 static Optional<NonLoc> tryRearrange(ProgramStateRef State,
  764       if (Optional<NonLoc> V = tryRearrange(state, op, lhs, rhs, resultTy))
  896     if (Optional<loc::ConcreteInt> rInt = rhs.getAs<loc::ConcreteInt>()) {
  899       if (Optional<NonLoc> Result = ResultVal.getAs<NonLoc>())
  931     if (Optional<loc::ConcreteInt> rInt = rhs.getAs<loc::ConcreteInt>()) {
 1028         Optional<NonLoc> LeftIndex = LeftIndexVal.getAs<NonLoc>();
 1038         Optional<NonLoc> RightIndex = RightIndexVal.getAs<NonLoc>();
 1137   if (Optional<nonloc::ConcreteInt> rhsInt = rhs.getAs<nonloc::ConcreteInt>()) {
 1138     if (Optional<loc::ConcreteInt> lhsInt = lhs.getAs<loc::ConcreteInt>()) {
 1202     if (Optional<NonLoc> indexV = index.getAs<NonLoc>()) {
 1216   if (Optional<loc::ConcreteInt> X = V.getAs<loc::ConcreteInt>())
 1219   if (Optional<nonloc::ConcreteInt> X = V.getAs<nonloc::ConcreteInt>())
tools/clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp
  227 static llvm::Optional<CheckerRegistry::CheckerInfoSet>
  269     llvm::Optional<CheckerInfoSet> Deps =
tools/clang/lib/Tooling/ASTDiff/ASTDiff.cpp
  692 llvm::Optional<std::string> Node::getQualifiedIdentifier() const {
  700 llvm::Optional<StringRef> Node::getIdentifier() const {
tools/clang/lib/Tooling/Inclusions/HeaderIncludes.cpp
   58     llvm::Optional<StringRef> RawIDName = llvm::None) {
  305 llvm::Optional<tooling::Replacement>
tools/clang/lib/Tooling/InterpolatingCompilationDatabase.cpp
  127   Optional<types::ID> Type;
  282   Optional<types::ID> tryParseTypeArg(const llvm::opt::Arg &Arg) {
  298   Optional<LangStandard::Kind> tryParseStdArg(const llvm::opt::Arg &Arg) {
tools/clang/lib/Tooling/JSONCompilationDatabase.cpp
  352     llvm::Optional<std::vector<llvm::yaml::ScalarNode *>> Command;
tools/clang/lib/Tooling/Refactoring/ASTSelection.cpp
   54   Optional<SelectedASTNode> getSelectedASTNode() {
  182 Optional<SelectedASTNode>
  379 Optional<CodeRangeASTSelection>
tools/clang/lib/Tooling/Refactoring/ASTSelectionRequirements.cpp
   22   Optional<SelectedASTNode> Selection =
   39   Optional<CodeRangeASTSelection> CodeRange = CodeRangeASTSelection::create(
tools/clang/lib/Tooling/Refactoring/Extract/Extract.cpp
   71                           Optional<std::string> DeclName) {
tools/clang/lib/Tooling/Refactoring/Extract/SourceExtraction.cpp
  103   Optional<Token> NextToken = Lexer::findNextToken(End, SM, LangOpts);
tools/clang/lib/Tooling/Syntax/Tokens.cpp
  168 llvm::Optional<llvm::ArrayRef<syntax::Token>>
  209 llvm::Optional<TokenBuffer::Expansion>
  520   llvm::Optional<SourceLocation>
tools/clang/lib/Tooling/Transformer/RewriteRule.cpp
   40     llvm::Optional<CharSourceRange> EditRange =
  150   llvm::Optional<CharSourceRange> RootRange = tooling::getRangeForEdit(
tools/clang/lib/Tooling/Transformer/SourceCode.cpp
   26   Optional<Token> Tok = Lexer::findNextToken(
   33 llvm::Optional<CharSourceRange>
tools/clang/lib/Tooling/Transformer/SourceCodeBuilders.cpp
   63 llvm::Optional<std::string> tooling::buildParens(const Expr &E,
   73 llvm::Optional<std::string>
   94 llvm::Optional<std::string> tooling::buildAddressOf(const Expr &E,
  115 llvm::Optional<std::string> tooling::buildDot(const Expr &E,
  139 llvm::Optional<std::string> tooling::buildArrow(const Expr &E,
tools/clang/lib/Tooling/Transformer/Stencil.cpp
  171   llvm::Optional<std::string> Source;
  207     if (llvm::Optional<std::string> S =
tools/clang/tools/clang-extdef-mapping/ClangExtDefMapGen.cpp
   79   llvm::Optional<std::string> LookupName =
tools/clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp
  135   virtual Expected<Optional<StringRef>>
  299   Expected<Optional<StringRef>> ReadBundleStart(MemoryBuffer &Input) final {
  381   static Expected<Optional<StringRef>> IsOffloadSection(SectionRef CurSection) {
  415   Expected<Optional<StringRef>> ReadBundleStart(MemoryBuffer &Input) final {
  422       Expected<Optional<StringRef>> TripleOrErr =
  536   Expected<Optional<StringRef>> ReadBundleStart(MemoryBuffer &Input) final {
  748     Expected<Optional<StringRef>> CurTripleOrErr = FH->ReadBundleStart(Input);
tools/clang/tools/clang-refactor/ClangRefactor.cpp
  150     Optional<TestSelectionRangesInFile> ParsedTestSelection =
  157   Optional<ParsedSourceRange> Range = ParsedSourceRange::fromString(Value);
  197              Optional<std::string> &Value) override {
  227   void visit(const RefactoringOption &Opt, Optional<std::string> &) override {
  319     Optional<PartialDiagnosticAt> Diag = DiagnosticError::take(Err);
tools/clang/tools/clang-refactor/TestSupport.cpp
  179     Optional<tooling::AtomicChanges> CanonicalResult;
  180     Optional<std::string> CanonicalErrorMessage;
  293 Optional<TestSelectionRangesInFile>
tools/clang/tools/clang-refactor/TestSupport.h
   98 Optional<TestSelectionRangesInFile> findTestSelectionRanges(StringRef Filename);
tools/clang/tools/diagtool/FindDiagnosticID.cpp
   29 static Optional<DiagnosticRecord>
   58   Optional<DiagnosticRecord> Diag =
tools/clang/tools/driver/cc1gen_reproducer_main.cpp
  110 static llvm::Optional<driver::Driver::CompilationDiagnosticReport>
  182   llvm::Optional<driver::Driver::CompilationDiagnosticReport> Report =
tools/clang/tools/driver/driver.cpp
  400     llvm::Optional<std::string> OptCL = llvm::sys::Process::GetEnv("CL");
  409     llvm::Optional<std::string> Opt_CL_ = llvm::sys::Process::GetEnv("_CL_");
tools/clang/tools/extra/clang-doc/BitcodeReader.cpp
   81 llvm::Error decodeRecord(Record R, llvm::Optional<Location> &Field,
  710   Expected<Optional<llvm::BitstreamBlockInfo>> MaybeBlockInfo =
tools/clang/tools/extra/clang-doc/BitcodeReader.h
   68   Optional<llvm::BitstreamBlockInfo> BlockInfo;
tools/clang/tools/extra/clang-doc/HTMLGenerator.cpp
  310              llvm::Optional<StringRef> JumpToSection = None) {
  438                     llvm::Optional<StringRef> RepositoryUrl = None) {
tools/clang/tools/extra/clang-doc/Representation.h
  301   llvm::Optional<Location> DefLoc;    // Location where this decl is defined.
  400   llvm::Optional<SmallString<16>> JumpToSection;
  429   llvm::Optional<std::string> RepositoryUrl;
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/FindAllMacros.cpp
   22 llvm::Optional<SymbolInfo>
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/FindAllMacros.h
   47   llvm::Optional<SymbolInfo> CreateMacroSymbol(const Token &MacroNameTok,
tools/clang/tools/extra/clang-include-fixer/find-all-symbols/FindAllSymbols.cpp
   72 llvm::Optional<SymbolInfo>
tools/clang/tools/extra/clang-move/Move.cpp
  555   Optional<ast_matchers::internal::Matcher<NamedDecl>> HasAnySymbolNames;
tools/clang/tools/extra/clang-query/Query.cpp
   91       llvm::Optional<DynTypedMatcher> M = Matcher.tryBind("root");
tools/clang/tools/extra/clang-query/QueryParser.cpp
  229     Optional<DynTypedMatcher> Matcher = Parser::parseMatcherExpression(
tools/clang/tools/extra/clang-query/tool/ClangQuery.cpp
  138     while (llvm::Optional<std::string> Line = LE.readLine()) {
tools/clang/tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp
  207 llvm::Optional<ClangTidyProfiling::StorageParams>
tools/clang/tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.h
  152   llvm::Optional<ClangTidyProfiling::StorageParams>
tools/clang/tools/extra/clang-tidy/ClangTidyOptions.cpp
  120 static void mergeVectors(Optional<T> &Dest, const Optional<T> &Src) {
  120 static void mergeVectors(Optional<T> &Dest, const Optional<T> &Src) {
  129 static void mergeCommaSeparatedLists(Optional<std::string> &Dest,
  130                                      const Optional<std::string> &Src) {
  136 static void overrideValue(Optional<T> &Dest, const Optional<T> &Src) {
  136 static void overrideValue(Optional<T> &Dest, const Optional<T> &Src) {
  245     llvm::Optional<OptionsSource> Result;
  272 llvm::Optional<OptionsSource>
tools/clang/tools/extra/clang-tidy/ClangTidyOptions.h
   64   llvm::Optional<std::string> Checks;
   67   llvm::Optional<std::string> WarningsAsErrors;
   71   llvm::Optional<std::string> HeaderFilterRegex;
   74   llvm::Optional<bool> SystemHeaders;
   88   llvm::Optional<std::string> FormatStyle;
   94   llvm::Optional<std::string> User;
  105   llvm::Optional<ArgList> ExtraArgs;
  108   llvm::Optional<ArgList> ExtraArgsBefore;
  253   llvm::Optional<OptionsSource> tryReadConfigFile(llvm::StringRef Directory);
tools/clang/tools/extra/clang-tidy/ClangTidyProfiling.cpp
   79 ClangTidyProfiling::ClangTidyProfiling(llvm::Optional<StorageParams> Storage)
tools/clang/tools/extra/clang-tidy/ClangTidyProfiling.h
   37   llvm::Optional<llvm::TimerGroup> TG;
   39   llvm::Optional<StorageParams> Storage;
   51   ClangTidyProfiling(llvm::Optional<StorageParams> Storage);
tools/clang/tools/extra/clang-tidy/ExpandModularHeadersPPCallbacks.cpp
  213                                                  bool, Optional<FileEntryRef>,
tools/clang/tools/extra/clang-tidy/ExpandModularHeadersPPCallbacks.h
   86   void HasInclude(SourceLocation Loc, StringRef, bool, Optional<FileEntryRef> ,
tools/clang/tools/extra/clang-tidy/abseil/DurationAdditionCheck.cpp
   41   llvm::Optional<DurationScale> Scale = getScaleForTimeInverse(
tools/clang/tools/extra/clang-tidy/abseil/DurationComparisonCheck.cpp
   33   llvm::Optional<DurationScale> Scale = getScaleForDurationInverse(
tools/clang/tools/extra/clang-tidy/abseil/DurationConversionCastCheck.cpp
   47   llvm::Optional<DurationScale> Scale =
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryFloatCheck.cpp
   56   llvm::Optional<std::string> SimpleArg = stripFloatCast(Result, *Arg);
tools/clang/tools/extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp
   24 static llvm::Optional<DurationScale>
   55 static llvm::Optional<std::tuple<DurationScale, double>>
  102 static llvm::Optional<DurationScale> GetNewScale(DurationScale OldScale,
  105     llvm::Optional<std::tuple<DurationScale, double>> result =
  162   llvm::Optional<DurationScale> MaybeScale =
  169   llvm::Optional<DurationScale> NewScale;
  202     llvm::Optional<DurationScale> NewScale =
tools/clang/tools/extra/clang-tidy/abseil/DurationRewriter.cpp
   27 static llvm::Optional<llvm::APSInt>
   70 static llvm::Optional<std::string>
   89 static llvm::Optional<std::string>
  185 llvm::Optional<std::string>
  205 llvm::Optional<std::string>
  210     if (llvm::Optional<llvm::APSInt> IntValue = truncateIfIntegral(*LitFloat))
  219   if (llvm::Optional<std::string> MaybeArg = stripFloatCast(Result, Node))
  223   if (llvm::Optional<std::string> MaybeArg =
  231 llvm::Optional<DurationScale> getScaleForDurationInverse(llvm::StringRef Name) {
  253 llvm::Optional<DurationScale> getScaleForTimeInverse(llvm::StringRef Name) {
  275   if (llvm::Optional<std::string> MaybeRewrite =
  293   if (llvm::Optional<std::string> MaybeRewrite =
tools/clang/tools/extra/clang-tidy/abseil/DurationRewriter.h
   46 llvm::Optional<std::string>
   54 llvm::Optional<std::string>
   67 llvm::Optional<DurationScale> getScaleForDurationInverse(llvm::StringRef Name);
   71 llvm::Optional<DurationScale> getScaleForTimeInverse(llvm::StringRef Name);
tools/clang/tools/extra/clang-tidy/abseil/DurationSubtractionCheck.cpp
   40   llvm::Optional<DurationScale> Scale =
tools/clang/tools/extra/clang-tidy/abseil/FasterStrsplitDelimiterCheck.cpp
   24 llvm::Optional<std::string> makeCharacterLiteral(const StringLiteral *Literal,
  108   llvm::Optional<std::string> Replacement =
tools/clang/tools/extra/clang-tidy/abseil/TimeComparisonCheck.cpp
   34   llvm::Optional<DurationScale> Scale = getScaleForTimeInverse(
tools/clang/tools/extra/clang-tidy/abseil/TimeSubtractionCheck.cpp
   98     llvm::Optional<DurationScale> Scale = getScaleForTimeInverse(TimeInverse);
  136   llvm::Optional<DurationScale> Scale = getScaleForTimeInverse(InverseName);
tools/clang/tools/extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp
  676     CallContext(StringRef Name, Optional<unsigned> DestinationPos,
  677                 Optional<unsigned> SourcePos, unsigned LengthPos,
  683     Optional<unsigned> DestinationPos;
  684     Optional<unsigned> SourcePos;
  797     Optional<bool> AreSafeFunctionsWanted;
tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp
  233     Optional<CFGStmt> S = Elem.getAs<CFGStmt>();
  332     Optional<CFGStmt> S = Elem.getAs<CFGStmt>();
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp
   97       Optional<FixItHint> Insertion = Inserter->CreateIncludeInsertion(
tools/clang/tools/extra/clang-tidy/google/TodoCommentCheck.cpp
   20   TodoCommentHandler(TodoCommentCheck &Check, llvm::Optional<std::string> User)
tools/clang/tools/extra/clang-tidy/google/UpgradeGoogletestCaseCheck.cpp
   23 static llvm::Optional<llvm::StringRef>
   98     llvm::Optional<llvm::StringRef> Replacement = getNewMacroName(Name);
tools/clang/tools/extra/clang-tidy/modernize/ReplaceRandomShuffleCheck.cpp
   97   if (Optional<FixItHint> IncludeFixit =
tools/clang/tools/extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp
  165 static llvm::Optional<ClassifiedToken>
  204 llvm::Optional<SmallVector<ClassifiedToken, 8>>
  238     if (llvm::Optional<ClassifiedToken> CT = classifyToken(F, *PP, T))
  279   llvm::Optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
  331   llvm::Optional<SmallVector<ClassifiedToken, 8>> MaybeTokens =
tools/clang/tools/extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.h
   44   llvm::Optional<SmallVector<ClassifiedToken, 8>>
tools/clang/tools/extra/clang-tidy/performance/FasterStringFindCheck.cpp
   24 llvm::Optional<std::string> MakeCharacterLiteral(const StringLiteral *Literal) {
tools/clang/tools/extra/clang-tidy/performance/ForRangeCopyCheck.cpp
   71   llvm::Optional<bool> Expensive =
   88   llvm::Optional<bool> Expensive =
tools/clang/tools/extra/clang-tidy/readability/AvoidConstParamsInDecls.cpp
   50 static llvm::Optional<Token> ConstTok(CharSourceRange Range,
   61   llvm::Optional<Token> ConstTok;
tools/clang/tools/extra/clang-tidy/readability/ConstReturnTypeCheck.cpp
   27 static llvm::Optional<Token>
   73   llvm::Optional<Token> Tok = findConstToRemove(Def, MatchResult);
   86     if (llvm::Optional<Token> T = findConstToRemove(Decl, MatchResult))
tools/clang/tools/extra/clang-tidy/readability/IdentifierNamingCheck.cpp
  396     const std::vector<llvm::Optional<IdentifierNamingCheck::NamingStyle>>
tools/clang/tools/extra/clang-tidy/readability/IdentifierNamingCheck.h
   59     NamingStyle(llvm::Optional<CaseType> Case, const std::string &Prefix,
   63     llvm::Optional<CaseType> Case;
  101   std::vector<llvm::Optional<NamingStyle>> NamingStyles;
tools/clang/tools/extra/clang-tidy/readability/IsolateDeclarationCheck.cpp
  108 static Optional<std::vector<SourceRange>>
  203 static Optional<std::vector<StringRef>>
  254   Optional<std::vector<SourceRange>> PotentialRanges =
  259   Optional<std::vector<StringRef>> PotentialSnippets = collectSourceRanges(
tools/clang/tools/extra/clang-tidy/readability/UppercaseLiteralSuffixCheck.cpp
   62   llvm::Optional<FixItHint> FixIt;
   65 llvm::Optional<SourceLocation> GetMacroAwareLocation(SourceLocation Loc,
   77 llvm::Optional<SourceRange> GetMacroAwareSourceRange(SourceRange Loc,
   79   llvm::Optional<SourceLocation> Begin =
   81   llvm::Optional<SourceLocation> End = GetMacroAwareLocation(Loc.getEnd(), SM);
   87 llvm::Optional<std::string>
  106 llvm::Optional<NewSuffix>
  122   llvm::Optional<SourceRange> Range =
  168   llvm::Optional<std::string> NewSuffix =
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.cpp
  190       if (Optional<CFGStmt> S = Elem.getAs<CFGStmt>())
tools/clang/tools/extra/clang-tidy/utils/IncludeInserter.cpp
   48 llvm::Optional<FixItHint>
tools/clang/tools/extra/clang-tidy/utils/IncludeInserter.h
   67   llvm::Optional<FixItHint>
tools/clang/tools/extra/clang-tidy/utils/IncludeSorter.cpp
  113 Optional<FixItHint> IncludeSorter::CreateIncludeInsertion(StringRef FileName,
tools/clang/tools/extra/clang-tidy/utils/IncludeSorter.h
   63   Optional<FixItHint> CreateIncludeInsertion(StringRef FileName, bool IsAngled);
tools/clang/tools/extra/clang-tidy/utils/LexerUtils.cpp
   81     llvm::Optional<Token> Tok = Lexer::findNextToken(Loc, SM, LangOpts);
   95 llvm::Optional<Token> getConstQualifyingToken(CharSourceRange Range,
  102   llvm::Optional<Token> FirstConstTok;
tools/clang/tools/extra/clang-tidy/utils/LexerUtils.h
   65     Optional<Token> CurrentToken = Lexer::findNextToken(Start, SM, LangOpts);
   94 llvm::Optional<Token> getConstQualifyingToken(CharSourceRange Range,
tools/clang/tools/extra/clang-tidy/utils/Matchers.h
   34   llvm::Optional<bool> IsExpensive =
tools/clang/tools/extra/clang-tidy/utils/NamespaceAliaser.cpp
   29 Optional<FixItHint>
tools/clang/tools/extra/clang-tidy/utils/NamespaceAliaser.h
   31   llvm::Optional<FixItHint>
tools/clang/tools/extra/clang-tidy/utils/TransformerClangTidyCheck.cpp
   29     std::function<Optional<RewriteRule>(const LangOptions &,
  103     if (Optional<FixItHint> Fix = Inserter->CreateIncludeInsertion(
tools/clang/tools/extra/clang-tidy/utils/TransformerClangTidyCheck.h
   47   TransformerClangTidyCheck(std::function<Optional<tooling::RewriteRule>(
   63   Optional<tooling::RewriteRule> Rule;
tools/clang/tools/extra/clang-tidy/utils/TypeTraits.cpp
   41 llvm::Optional<bool> isExpensiveToCopy(QualType Type,
tools/clang/tools/extra/clang-tidy/utils/TypeTraits.h
   21 llvm::Optional<bool> isExpensiveToCopy(QualType Type,
tools/clang/tools/extra/clang-tidy/utils/UsingInserter.cpp
   32 Optional<FixItHint> UsingInserter::createUsingDeclaration(
tools/clang/tools/extra/clang-tidy/utils/UsingInserter.h
   31   llvm::Optional<FixItHint>
tools/clang/tools/extra/clangd/AST.cpp
   32 llvm::Optional<llvm::ArrayRef<TemplateArgumentLoc>>
  166   if (llvm::Optional<llvm::ArrayRef<TemplateArgumentLoc>> Args =
  199 llvm::Optional<SymbolID> getSymbolID(const Decl *D) {
  206 llvm::Optional<SymbolID> getSymbolID(const IdentifierInfo &II,
tools/clang/tools/extra/clangd/AST.h
   63 llvm::Optional<SymbolID> getSymbolID(const Decl *D);
   72 llvm::Optional<SymbolID> getSymbolID(const IdentifierInfo &II,
tools/clang/tools/extra/clangd/ClangdLSPServer.cpp
  260     llvm::Optional<std::pair<int, Callback<llvm::json::Value>>> OldestCB;
  495     llvm::Optional<WithContextValue> WithOffsetEncoding;
  749                                       Callback<llvm::Optional<Range>> Reply) {
  757   llvm::Optional<std::string> Code = DraftMgr.getDraft(File);
  887 static llvm::Optional<Command> asCommand(const CodeAction &Action) {
 1050     Callback<llvm::Optional<URIForFile>> Reply) {
 1071                               Callback<llvm::Optional<Hover>> Reply) {
 1097     Callback<Optional<TypeHierarchyItem>> Reply) {
 1104     Callback<Optional<TypeHierarchyItem>> Reply) {
 1191     llvm::Optional<Path> CompileCommandsDir, bool UseDirBasedCDB,
 1192     llvm::Optional<OffsetEncoding> ForcedOffsetEncoding,
tools/clang/tools/extra/clangd/ClangdLSPServer.h
   44                   llvm::Optional<Path> CompileCommandsDir, bool UseDirBasedCDB,
   45                   llvm::Optional<OffsetEncoding> ForcedOffsetEncoding,
   93                             Callback<llvm::Optional<URIForFile>>);
  101                        Callback<llvm::Optional<Range>>);
  104                Callback<llvm::Optional<Hover>>);
  106                        Callback<llvm::Optional<TypeHierarchyItem>>);
  108                               Callback<llvm::Optional<TypeHierarchyItem>>);
  211   llvm::Optional<Path> CompileCommandsDir; // FIXME: merge with capability?
  214   llvm::Optional<OverlayCDB> CDB;
  216   llvm::Optional<OffsetEncoding> NegotiatedOffsetEncoding;
  218   llvm::Optional<ClangdServer> Server;
tools/clang/tools/extra/clangd/ClangdServer.cpp
  201     llvm::Optional<SpeculativeFuzzyFind> SpecFuzzyFind;
  305                                  Callback<llvm::Optional<Range>> CB) {
  453     PathRef Path, Callback<llvm::Optional<clangd::Path>> CB) {
  503                              Callback<llvm::Optional<HoverInfo>> CB) {
  518                                  Callback<Optional<TypeHierarchyItem>> CB) {
  532     Callback<llvm::Optional<TypeHierarchyItem>> CB) {
  605 ClangdServer::blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds) {
tools/clang/tools/extra/clangd/ClangdServer.h
  114     llvm::Optional<std::string> WorkspaceRoot;
  120     llvm::Optional<std::string> ResourceDir = llvm::None;
  198                           Callback<llvm::Optional<clangd::Path>> CB);
  206                  Callback<llvm::Optional<HoverInfo>> CB);
  211                      Callback<llvm::Optional<TypeHierarchyItem>> CB);
  216                             Callback<llvm::Optional<TypeHierarchyItem>> CB);
  246                      Callback<llvm::Optional<Range>> CB);
  297   blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds = 10);
  332   llvm::StringMap<llvm::Optional<FuzzyFindRequest>>
  336   llvm::Optional<std::string> WorkspaceRoot;
tools/clang/tools/extra/clangd/CodeComplete.cpp
  213   llvm::Optional<llvm::StringRef>
  487 llvm::Optional<SymbolID> getSymbolID(const CodeCompletionResult &R,
  528   llvm::Optional<std::string> UnresolvedQualifier;
  794   llvm::Optional<SymbolID> IDForDoc;
 1217   llvm::Optional<FuzzyMatcher> Filter; // Initialized once Sema runs.
 1221   llvm::Optional<ScopeDistance> ScopeProximity;
 1222   llvm::Optional<OpaqueType> PreferredType; // Initialized once Sema runs.
 1228   llvm::Optional<IncludeInserter> Inserter;  // Available during runWithSema.
 1229   llvm::Optional<URIDistance> FileProximity; // Initialized once Sema runs.
 1234   llvm::Optional<FuzzyFindRequest> SpecReq;
 1583   llvm::Optional<float> fuzzyScore(const CompletionCandidate &C) {
 1669     llvm::Optional<CodeCompletionBuilder> Builder;
tools/clang/tools/extra/clangd/CodeComplete.h
   67   llvm::Optional<bool> BundleOverloads;
  170     llvm::Optional<TextEdit> Insertion;
  231   llvm::Optional<FuzzyFindRequest> CachedReq;
  234   llvm::Optional<FuzzyFindRequest> NewReq;
tools/clang/tools/extra/clangd/Diagnostics.h
   59   llvm::Optional<std::string> AbsFile;
  146   llvm::Optional<LangOptions> LangOpts;
  147   llvm::Optional<Diag> LastDiag;
tools/clang/tools/extra/clangd/DraftStore.cpp
   16 llvm::Optional<std::string> DraftStore::getDraft(PathRef File) const {
tools/clang/tools/extra/clangd/DraftStore.h
   30   llvm::Optional<std::string> getDraft(PathRef File) const;
tools/clang/tools/extra/clangd/ExpectedTypes.cpp
   44 static llvm::Optional<QualType>
   69 llvm::Optional<OpaqueType> OpaqueType::encode(ASTContext &Ctx, QualType T) {
   83 llvm::Optional<OpaqueType> OpaqueType::fromType(ASTContext &Ctx,
   88 llvm::Optional<OpaqueType>
tools/clang/tools/extra/clangd/ExpectedTypes.h
   37   static llvm::Optional<OpaqueType>
   41   static llvm::Optional<OpaqueType> fromType(ASTContext &Ctx, QualType Type);
   57   static llvm::Optional<OpaqueType> encode(ASTContext &Ctx, QualType Type);
tools/clang/tools/extra/clangd/FS.cpp
   39 llvm::Optional<llvm::vfs::Status>
tools/clang/tools/extra/clangd/FS.h
   46   llvm::Optional<llvm::vfs::Status> lookup(llvm::StringRef Path) const;
tools/clang/tools/extra/clangd/FindSymbols.cpp
  131 llvm::Optional<DocumentSymbol> declToSym(ASTContext &Ctx, const NamedDecl &ND) {
  204     llvm::Optional<DocumentSymbol> Sym = declToSym(AST.getASTContext(), *ND);
tools/clang/tools/extra/clangd/FindTarget.cpp
  503     llvm::Optional<ReferenceLoc> Ref;
tools/clang/tools/extra/clangd/FormattedString.cpp
  150   Optional<bool> LastWasBlock;
tools/clang/tools/extra/clangd/FuzzyMatch.cpp
   92 llvm::Optional<float> FuzzyMatcher::match(llvm::StringRef Word) {
tools/clang/tools/extra/clangd/FuzzyMatch.h
   80   llvm::Optional<float> match(llvm::StringRef Word);
tools/clang/tools/extra/clangd/GlobalCompilationDatabase.cpp
   95         llvm::Optional<Path> CompileCommandsDir)
  101 llvm::Optional<tooling::CompileCommand>
  157 llvm::Optional<DirectoryBasedGlobalCompilationDatabase::CDBLookupResult>
  253 llvm::Optional<ProjectInfo>
  266                        llvm::Optional<std::string> ResourceDir)
  276 llvm::Optional<tooling::CompileCommand>
  278   llvm::Optional<tooling::CompileCommand> Cmd;
  304     PathRef File, llvm::Optional<tooling::CompileCommand> Cmd) {
  319 llvm::Optional<ProjectInfo> OverlayCDB::getProjectInfo(PathRef File) const {
tools/clang/tools/extra/clangd/GlobalCompilationDatabase.h
   39   virtual llvm::Optional<tooling::CompileCommand>
   43   virtual llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const {
   69       llvm::Optional<Path> CompileCommandsDir);
   75   llvm::Optional<tooling::CompileCommand>
   80   llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override;
  100   llvm::Optional<CDBLookupResult> lookupCDB(CDBLookupRequest Request) const;
  111   llvm::Optional<Path> CompileCommandsDir;
  129              llvm::Optional<std::string> ResourceDir = llvm::None);
  131   llvm::Optional<tooling::CompileCommand>
  134   llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override;
  139                     llvm::Optional<tooling::CompileCommand> CompilationCommand);
tools/clang/tools/extra/clangd/HeaderSourceSwitch.cpp
   18 llvm::Optional<Path> getCorrespondingHeaderOrSource(
   71 llvm::Optional<Path> getCorrespondingHeaderOrSource(const Path &OriginalFile,
tools/clang/tools/extra/clangd/HeaderSourceSwitch.h
   20 llvm::Optional<Path> getCorrespondingHeaderOrSource(
   26 llvm::Optional<Path> getCorrespondingHeaderOrSource(const Path &OriginalFile,
tools/clang/tools/extra/clangd/Headers.cpp
  189 llvm::Optional<std::string>
  219 llvm::Optional<TextEdit>
  221   llvm::Optional<TextEdit> Edit = None;
tools/clang/tools/extra/clangd/Headers.h
  181   llvm::Optional<std::string>
  187   llvm::Optional<TextEdit> insert(llvm::StringRef VerbatimHeader) const;
tools/clang/tools/extra/clangd/IncludeFixer.cpp
  130   llvm::Optional<const SymbolSlab *> Symbols = lookupCached(*ID);
  195 llvm::Optional<std::string> qualifiedByUnresolved(const SourceManager &SM,
  221   llvm::Optional<std::string> ResolvedScope;
  226   llvm::Optional<std::string> UnresolvedScope;
  231 llvm::Optional<CheapUnresolvedName> extractUnresolvedNameCheaply(
  324   UnresolvedNameRecorder(llvm::Optional<UnresolvedName> &LastUnresolvedName)
  376   llvm::Optional<UnresolvedName> &LastUnresolvedName;
  397   if (llvm::Optional<const SymbolSlab *> Syms = fuzzyFindCached(Req))
  403 llvm::Optional<const SymbolSlab *>
  426 llvm::Optional<const SymbolSlab *>
tools/clang/tools/extra/clangd/IncludeFixer.h
   81   llvm::Optional<UnresolvedName> LastUnresolvedName;
   90   llvm::Optional<const SymbolSlab *>
   92   llvm::Optional<const SymbolSlab *> lookupCached(const SymbolID &ID) const;
tools/clang/tools/extra/clangd/JSONTransport.cpp
  117   llvm::Optional<std::string> readRawMessage() {
  121   llvm::Optional<std::string> readDelimitedMessage();
  122   llvm::Optional<std::string> readStandardMessage();
  141   llvm::Optional<llvm::json::Value> ID;
  195 llvm::Optional<std::string> JSONTransport::readStandardMessage() {
  267 llvm::Optional<std::string> JSONTransport::readDelimitedMessage() {
tools/clang/tools/extra/clangd/ParsedAST.cpp
  217 llvm::Optional<ParsedAST>
  256   llvm::Optional<tidy::ClangTidyContext> CTContext;
  312   llvm::Optional<IncludeFixer> FixIncludes;
  504 llvm::Optional<ParsedAST>
tools/clang/tools/extra/clangd/ParsedAST.h
   50   static llvm::Optional<ParsedAST>
  138 llvm::Optional<ParsedAST>
tools/clang/tools/extra/clangd/Protocol.h
  372   llvm::Optional<SymbolKindBitset> WorkspaceSymbolKinds;
  410   llvm::Optional<CompletionItemKindBitset> CompletionItemKinds;
  421   llvm::Optional<std::vector<OffsetEncoding>> offsetEncoding;
  459   llvm::Optional<std::string> compilationDatabasePath;
  475   llvm::Optional<int> processId;
  481   llvm::Optional<std::string> rootPath;
  486   llvm::Optional<URIForFile> rootUri;
  495   llvm::Optional<TraceLevel> trace;
  538   llvm::Optional<Range> range;
  541   llvm::Optional<int> rangeLength;
  561   llvm::Optional<bool> wantDiagnostics;
  667   llvm::Optional<std::vector<DiagnosticRelatedInformation>> relatedInformation;
  673   llvm::Optional<std::string> category;
  678   llvm::Optional<std::vector<CodeAction>> codeActions;
  715   llvm::Optional<std::map<std::string, std::vector<TextEdit>>> changes;
  756   llvm::Optional<WorkspaceEdit> workspaceEdit;
  757   llvm::Optional<TweakArgs> tweakArgs;
  777   llvm::Optional<std::string> kind;
  783   llvm::Optional<std::vector<Diagnostic>> diagnostics;
  786   llvm::Optional<WorkspaceEdit> edit;
  790   llvm::Optional<Command> command;
  859   llvm::Optional<SymbolID> ID;
  879   llvm::Optional<std::string> failureReason;
  929   llvm::Optional<Range> range;
  988   llvm::Optional<TextEdit> textEdit;
 1030   llvm::Optional<std::pair<unsigned, unsigned>> labelOffsets;
 1135   llvm::Optional<std::string> detail;
 1160   llvm::Optional<std::vector<TypeHierarchyItem>> parents;
 1165   llvm::Optional<std::vector<TypeHierarchyItem>> children;
 1169   llvm::Optional<std::string> data;
tools/clang/tools/extra/clangd/Quality.cpp
  329                         llvm::Optional<llvm::StringRef> SymbolScope) {
  338 static llvm::Optional<llvm::StringRef>
tools/clang/tools/extra/clangd/Quality.h
  110   llvm::Optional<llvm::StringRef> SymbolScope;
tools/clang/tools/extra/clangd/QueryDriverDatabase.cpp
  120   llvm::Optional<llvm::StringRef> Redirects[] = {
  214   llvm::Optional<tooling::CompileCommand>
  257   llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override {
tools/clang/tools/extra/clangd/SemanticHighlighting.cpp
   38 llvm::Optional<HighlightingKind> kindForType(const Type *TP);
   39 llvm::Optional<HighlightingKind> kindForDecl(const NamedDecl *D) {
   91 llvm::Optional<HighlightingKind> kindForType(const Type *TP) {
  105 llvm::Optional<HighlightingKind>
  107   llvm::Optional<HighlightingKind> Result;
tools/clang/tools/extra/clangd/SourceCode.cpp
  234 llvm::Optional<Range> getTokenRange(const SourceManager &SM,
  545 llvm::Optional<SourceRange> toHalfOpenFileRange(const SourceManager &SM,
  629 llvm::Optional<std::string> getCanonicalPath(const FileEntry *F,
  692 llvm::Optional<FileDigest> digestFile(const SourceManager &SM, FileID FID) {
  980 llvm::Optional<DefinedMacro> locateMacroAt(SourceLocation Loc,
tools/clang/tools/extra/clangd/SourceCode.h
   40 Optional<FileDigest> digestFile(const SourceManager &SM, FileID FID);
   72 llvm::Optional<Range> getTokenRange(const SourceManager &SM,
  129 llvm::Optional<SourceRange> toHalfOpenFileRange(const SourceManager &Mgr,
  189 llvm::Optional<std::string> getCanonicalPath(const FileEntry *F,
  291 llvm::Optional<DefinedMacro> locateMacroAt(SourceLocation Loc,
tools/clang/tools/extra/clangd/TUScheduler.cpp
   77 llvm::Optional<llvm::StringRef> TUScheduler::getFileBeingProcessedInContext() {
  123   llvm::Optional<std::unique_ptr<ParsedAST>> take(Key K) {
  216                  llvm::Optional<WantDiagnostics> UpdateType);
  238     llvm::Optional<WantDiagnostics> UpdateType;
  486     llvm::Optional<std::unique_ptr<ParsedAST>> AST = IdleASTs.take(this);
  488       llvm::Optional<ParsedAST> NewAST =
  532     llvm::Optional<std::unique_ptr<ParsedAST>> AST = IdleASTs.take(this);
  539       llvm::Optional<ParsedAST> NewAST =
  631                           llvm::Optional<WantDiagnostics> UpdateType) {
  676         llvm::Optional<WithContext> Ctx;
  677         llvm::Optional<trace::Span> Tracer;
tools/clang/tools/extra/clangd/TUScheduler.h
  245   static llvm::Optional<llvm::StringRef> getFileBeingProcessedInContext();
  256   llvm::Optional<AsyncTaskRunner> PreambleTasks;
  257   llvm::Optional<AsyncTaskRunner> WorkerThreads;
tools/clang/tools/extra/clangd/Threading.cpp
   99 Deadline timeoutSeconds(llvm::Optional<double> Seconds) {
tools/clang/tools/extra/clangd/Threading.h
   86 Deadline timeoutSeconds(llvm::Optional<double> Seconds);
tools/clang/tools/extra/clangd/XRefs.cpp
   86 llvm::Optional<Location> toLSPLocation(const SymbolLocation &Loc,
  215 llvm::Optional<Location> makeLocation(ASTContext &AST, SourceLocation TokLoc,
  857 llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
  882 llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
  886   llvm::Optional<HoverInfo> HI;
 1036 static llvm::Optional<TypeHierarchyItem>
 1083 static Optional<TypeHierarchyItem>
 1115     if (Optional<TypeHierarchyItem> ChildSym =
 1144     if (Optional<TypeHierarchyItem> ParentSym =
 1214 llvm::Optional<TypeHierarchyItem>
 1222   Optional<TypeHierarchyItem> Result =
 1241       if (Optional<SymbolID> ID = getSymbolID(CXXRD))
tools/clang/tools/extra/clangd/XRefs.h
   44   llvm::Optional<Location> Definition;
   69     llvm::Optional<std::string> Type;
   71     llvm::Optional<std::string> Name;
   73     llvm::Optional<std::string> Default;
   86   llvm::Optional<std::string> NamespaceScope;
   92   llvm::Optional<Range> SymRange;
  102   llvm::Optional<std::string> Type;
  104   llvm::Optional<std::string> ReturnType;
  106   llvm::Optional<std::vector<Param>> Parameters;
  108   llvm::Optional<std::vector<Param>> TemplateParameters;
  110   llvm::Optional<std::string> Value;
  123 llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
  143 llvm::Optional<TypeHierarchyItem> getTypeHierarchy(
  154 llvm::Optional<QualType> getDeducedType(ParsedAST &AST,
tools/clang/tools/extra/clangd/index/Background.h
   63       std::function<llvm::Optional<ProjectInfo>(PathRef)> GetProjectInfo);
  100   blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds);
  147   blockUntilIdleForTest(llvm::Optional<double> TimeoutSeconds = 10) {
tools/clang/tools/extra/clangd/index/BackgroundIndexStorage.cpp
  106       std::function<llvm::Optional<ProjectInfo>(PathRef)> GetProjectInfo)
  140   std::function<llvm::Optional<ProjectInfo>(PathRef)> GetProjectInfo;
  147     std::function<llvm::Optional<ProjectInfo>(PathRef)> GetProjectInfo) {
tools/clang/tools/extra/clangd/index/BackgroundQueue.cpp
   22     llvm::Optional<Task> Task;
  108     llvm::Optional<double> TimeoutSeconds) {
tools/clang/tools/extra/clangd/index/Index.h
   42   llvm::Optional<uint32_t> Limit;
   73   llvm::Optional<uint32_t> Limit;
   80   llvm::Optional<uint32_t> Limit;
tools/clang/tools/extra/clangd/index/IndexAction.cpp
   32 llvm::Optional<std::string> toURI(const FileEntry *File) {
tools/clang/tools/extra/clangd/index/Serialization.h
   43   llvm::Optional<SymbolSlab> Symbols;
   44   llvm::Optional<RefSlab> Refs;
   45   llvm::Optional<RelationSlab> Relations;
   47   llvm::Optional<IncludeGraph> Sources;
   49   llvm::Optional<tooling::CompileCommand> Cmd;
tools/clang/tools/extra/clangd/index/SymbolCollector.cpp
  151 llvm::Optional<SymbolLocation>
  613   llvm::Optional<OpaqueType> TypeStorage;
  647 llvm::Optional<std::string>
tools/clang/tools/extra/clangd/index/SymbolCollector.h
  129   llvm::Optional<std::string> getIncludeHeader(llvm::StringRef QName, FileID);
tools/clang/tools/extra/clangd/index/YAMLSerialization.cpp
   41   llvm::Optional<clang::clangd::Symbol> Symbol;
   42   llvm::Optional<RefBundle> Refs;
   43   llvm::Optional<clang::clangd::Relation> Relation;
tools/clang/tools/extra/clangd/index/dex/Dex.cpp
  222     const llvm::Optional<float> Score = Filter.match(Sym->Name);
tools/clang/tools/extra/clangd/index/dex/PostingList.cpp
  187 llvm::Optional<DocID> readVByte(llvm::ArrayRef<uint8_t> &Bytes) {
tools/clang/tools/extra/clangd/index/dex/dexp/Dexp.cpp
  294   while (llvm::Optional<std::string> Request = LE.readLine()) {
tools/clang/tools/extra/clangd/refactor/Rename.cpp
   24 llvm::Optional<std::string> filePath(const SymbolLocation &Loc,
   42 llvm::Optional<std::string> getOtherRefFile(const Decl &D, StringRef MainFile,
   51   llvm::Optional<std::string> OtherFile;
   72 llvm::Optional<ReasonToReject> renamableWithinFile(const Decl &RenameDecl,
tools/clang/tools/extra/clangd/refactor/Tweak.h
   79     llvm::Optional<std::string> ShowMessage;
tools/clang/tools/extra/clangd/refactor/tweaks/DefineInline.cpp
   71 llvm::Optional<SourceLocation> getSemicolonForDecl(const FunctionDecl *FD) {
tools/clang/tools/extra/clangd/refactor/tweaks/DumpAST.cpp
   56   llvm::Optional<ast_type_traits::DynTypedNode> Node;
tools/clang/tools/extra/clangd/refactor/tweaks/ExpandAutoType.cpp
   47   llvm::Optional<clang::AutoTypeLoc> CachedLocation;
   76   llvm::Optional<clang::QualType> DeducedType =
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractFunction.cpp
  200 llvm::Optional<SourceRange> findZoneRange(const Node *Parent,
  221 llvm::Optional<SourceRange>
  246 llvm::Optional<ExtractionZone> findExtractionZone(const Node *CommonAnc,
tools/clang/tools/extra/clangd/refactor/tweaks/RemoveUsingNamespace.cpp
   73   llvm::Optional<Token> NextTok =
tools/clang/tools/extra/clangd/tool/ClangdMain.cpp
  486   llvm::Optional<llvm::raw_fd_ostream> InputMirrorStream;
  503   llvm::Optional<llvm::raw_fd_ostream> TraceStream;
  518   llvm::Optional<trace::Session> TracingSession;
  548   llvm::Optional<Path> CompileCommandsDirPath;
  666   llvm::Optional<OffsetEncoding> OffsetEncodingFromFlag;
tools/clang/tools/extra/clangd/unittests/CancellationTests.cpp
   24   llvm::Optional<WithContext> ContextWithCancellation;
tools/clang/tools/extra/clangd/unittests/ClangdTests.cpp
 1039     llvm::Optional<tooling::CompileCommand>
tools/clang/tools/extra/clangd/unittests/DraftStoreTests.cpp
  340   Optional<std::string> Contents = DS.getDraft(File);
tools/clang/tools/extra/clangd/unittests/ExpectedTypeTest.cpp
   42   llvm::Optional<OpaqueType> fromCompletionResult(const NamedDecl *D) {
   78   llvm::Optional<ParsedAST> AST;
tools/clang/tools/extra/clangd/unittests/FuzzyMatchTests.cpp
   43   llvm::Optional<llvm::StringRef> Annotated;
   48   llvm::Optional<float> Score;
   49   MatchesMatcher(ExpectedMatch Candidate, llvm::Optional<float> Score)
   75                                             llvm::Optional<float> Score = {}) {
  203     llvm::Optional<float> LastScore;
tools/clang/tools/extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp
   67     llvm::Optional<tooling::CompileCommand>
   79     llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override {
tools/clang/tools/extra/clangd/unittests/HeaderSourceSwitchTests.cpp
   31   Optional<Path> PathResult =
  142     llvm::Optional<std::string> ExpectedSource;
  211     llvm::Optional<std::string> ExpectedResult;
tools/clang/tools/extra/clangd/unittests/HeadersTests.cpp
  105   llvm::Optional<TextEdit> insert(llvm::StringRef VerbatimHeader) {
tools/clang/tools/extra/clangd/unittests/SourceCodeTests.cpp
  591   llvm::Optional<SourceRange> Range = toHalfOpenFileRange(
tools/clang/tools/extra/clangd/unittests/SymbolCollectorTests.cpp
  137   llvm::Optional<ParsedAST> AST; // Initialized after build.
tools/clang/tools/extra/clangd/unittests/SyncAPI.cpp
   28   CaptureProxy(llvm::Optional<T> &Target) : Target(&Target) {
   57   llvm::Optional<T> *Target;
   65 template <typename T> CaptureProxy<T> capture(llvm::Optional<T> &Target) {
   73   llvm::Optional<llvm::Expected<CodeCompleteResult>> Result;
   80   llvm::Optional<llvm::Expected<SignatureHelp>> Result;
   87   llvm::Optional<llvm::Expected<std::vector<LocatedSymbol>>> Result;
   94   llvm::Optional<llvm::Expected<std::vector<DocumentHighlight>>> Result;
  102   llvm::Optional<llvm::Expected<std::vector<TextEdit>>> Result;
  108   llvm::Optional<std::string> Result;
  115   llvm::Optional<llvm::Expected<std::vector<SymbolInformation>>> Result;
  122   llvm::Optional<llvm::Expected<std::vector<DocumentSymbol>>> Result;
  150   llvm::Optional<llvm::Expected<std::vector<Range>>> Result;
  155 llvm::Expected<llvm::Optional<clangd::Path>>
  157   llvm::Optional<llvm::Expected<llvm::Optional<clangd::Path>>> Result;
  157   llvm::Optional<llvm::Expected<llvm::Optional<clangd::Path>>> Result;
tools/clang/tools/extra/clangd/unittests/SyncAPI.h
   59 llvm::Expected<llvm::Optional<clangd::Path>>
tools/clang/tools/extra/clangd/unittests/TestFS.cpp
   43 llvm::Optional<ProjectInfo>
   48 llvm::Optional<tooling::CompileCommand>
tools/clang/tools/extra/clangd/unittests/TestFS.h
   52   llvm::Optional<tooling::CompileCommand>
   55   llvm::Optional<ProjectInfo> getProjectInfo(PathRef File) const override;
tools/clang/tools/extra/clangd/unittests/TestTU.h
   59   llvm::Optional<std::string> ClangTidyChecks;
   60   llvm::Optional<std::string> ClangTidyWarningsAsErrors;
tools/clang/tools/extra/clangd/unittests/TypeHierarchyTests.cpp
  374     llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
  413   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
  445   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
  627   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
tools/clang/tools/extra/clangd/unittests/XRefsTests.cpp
  115   llvm::Optional<Range> Def = DefOrNone;
  456     llvm::Optional<Range> WantDecl;
  457     llvm::Optional<Range> WantDef;
  480       llvm::Optional<Range> GotDef;
 2157     mutable Optional<llvm::DenseSet<SymbolID>> RefIDs;
tools/clang/tools/extra/unittests/clang-tidy/LLVMModuleTest.cpp
   15                                        Optional<StringRef> ExpectedWarning) {
   37                              Optional<StringRef> ExpectedWarning) {
tools/clang/tools/extra/unittests/clang-tidy/TransformerClangTidyCheckTest.cpp
  121 Optional<RewriteRule> needsObjC(const LangOptions &LangOpts,
  146 Optional<RewriteRule> noSkip(const LangOptions &LangOpts,
tools/clang/tools/libclang/CIndex.cpp
  532             const Optional<bool> V = handleDeclForVisitation(*TL);
  597 Optional<bool> CursorVisitor::shouldVisitCursor(CXCursor Cursor) {
  632     const Optional<bool> V = handleDeclForVisitation(D);
  640 Optional<bool> CursorVisitor::handleDeclForVisitation(const Decl *D) {
  666   const Optional<bool> V = shouldVisitCursor(Cursor);
 1057     const Optional<bool> &V = shouldVisitCursor(Cursor);
 7820   Optional<unsigned> Minor = In.getMinor();
 7826   Optional<unsigned> Subminor = In.getSubminor();
tools/clang/tools/libclang/CXType.cpp
  176 static Optional<ArrayRef<TemplateArgument>>
  192 static Optional<QualType> TemplateArgumentToQualType(const TemplateArgument &A) {
  198 static Optional<QualType>
 1153   Optional<QualType> QT = FindTemplateArgumentTypeAt(TA.getValue(), index);
tools/clang/tools/libclang/CursorVisitor.h
  202   Optional<bool> shouldVisitCursor(CXCursor C);
  270   Optional<bool> handleDeclForVisitation(const Decl *D);
tools/clang/unittests/AST/ASTImporterTest.cpp
 3285     Optional<unsigned> ToIndex = ASTImporter::getFieldIndex(ToField);
 4904   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromSpec);
 4929   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFoo);
 4963   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromProto);
 4989   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
 5056   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFRD);
 5115   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
 5161     Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
 5169   Optional<ImportError> OptErr =
 5204     Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
 5244     Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromD);
tools/clang/unittests/AST/ASTPrint.h
   23     Optional<llvm::function_ref<void(PrintingPolicy &Policy)>>;
tools/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp
   43   llvm::Optional<MatcherCtor>
  137 llvm::Optional<DynTypedMatcher> getSingleMatcher(const VariantValue &Value) {
  138   llvm::Optional<DynTypedMatcher> Result =
  210   llvm::Optional<DynTypedMatcher> VarDecl(Parser::parseMatcherExpression(
  221   llvm::Optional<DynTypedMatcher> HasParameter(Parser::parseMatcherExpression(
  231   llvm::Optional<DynTypedMatcher> HasParameterWithNamedValues(
  255   llvm::Optional<DynTypedMatcher> OM(Parser::parseMatcherExpression(
  383     llvm::Optional<DynTypedMatcher> TopLevelLetBinding(
  398     llvm::Optional<DynTypedMatcher> NestedLetBinding(
tools/clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
   37   llvm::Optional<MatcherCtor> lookupMatcherCtor(StringRef MatcherName) {
   45     llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName);
   58     llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName);
   72     llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName);
   91     llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName1);
  102     llvm::Optional<MatcherCtor> Ctor = lookupMatcherCtor(MatcherName1);
tools/clang/unittests/Basic/DiagnosticTest.cpp
   84   Optional<PartialDiagnosticAt> ErrDiag = DiagnosticError::take(Err);
tools/clang/unittests/Basic/FileManagerTest.cpp
  436   llvm::Optional<FileEntryRef> BypassRef = Manager.getBypassFile(Ref);
tools/clang/unittests/CrossTU/CrossTranslationUnitTest.cpp
   89         llvm::Optional<std::pair<SourceLocation, ASTUnit *>> SLocResult =
tools/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp
  169   llvm::Optional<bool> result() const {
tools/clang/unittests/Frontend/ParsedSourceLocationTest.cpp
   20     Optional<ParsedSourceRange> PSR = ParsedSourceRange::fromString(Value);
tools/clang/unittests/Tooling/ASTSelectionTest.cpp
   30   Optional<FileRange> SelectionRange;
   32                           Optional<SelectedASTNode>)>
   37                          Optional<FileRange> SelectionRange,
   39                                                  Optional<SelectedASTNode>)>
   67     StringRef Source, FileLocation Location, Optional<FileRange> SelectionRange,
   69                             Optional<SelectedASTNode>)>
   78     StringRef Source, FileLocation Location, Optional<FileRange> SelectionRange,
   79     llvm::function_ref<void(Optional<SelectedASTNode>)> Consumer,
  539 const SelectedASTNode &checkFnBody(const Optional<SelectedASTNode> &Node,
  694         Optional<CodeRangeASTSelection> SelectedCode =
  702         Optional<CodeRangeASTSelection> SelectedCode =
  711         Optional<CodeRangeASTSelection> SelectedCode =
  720         Optional<CodeRangeASTSelection> SelectedCode =
  740         Optional<CodeRangeASTSelection> SelectedCode =
  761         Optional<CodeRangeASTSelection> SelectedCode =
  775         Optional<CodeRangeASTSelection> SelectedCode =
  795         Optional<CodeRangeASTSelection> SelectedCode =
  823         Optional<CodeRangeASTSelection> SelectedCode =
  853         Optional<CodeRangeASTSelection> SelectedCode =
  881         Optional<CodeRangeASTSelection> SelectedCode =
  920         Optional<CodeRangeASTSelection> SelectedCode =
  930         Optional<CodeRangeASTSelection> SelectedCode =
  953         Optional<CodeRangeASTSelection> SelectedCode =
  985         Optional<CodeRangeASTSelection> SelectedCode =
  997         Optional<CodeRangeASTSelection> SelectedCode =
 1028         Optional<CodeRangeASTSelection> SelectedCode =
 1039         Optional<CodeRangeASTSelection> SelectedCode =
 1050         Optional<CodeRangeASTSelection> SelectedCode =
 1072         Optional<CodeRangeASTSelection> SelectedCode =
tools/clang/unittests/Tooling/RefactoringActionRulesTest.cpp
   50     Optional<Expected<AtomicChanges>> Result;
  178 Optional<SymbolOccurrences> findOccurrences(RefactoringActionRule &Rule,
  190     Optional<SymbolOccurrences> Result;
  227   Optional<SymbolOccurrences> Result = findOccurrences(*Rule, RefContext);
tools/clang/unittests/Tooling/RefactoringTest.cpp
  107                                   llvm::Optional<Replacement> ExpectedExisting,
  108                                   llvm::Optional<Replacement> ExpectedNew) {
tools/clang/unittests/Tooling/SourceCodeBuildersTest.cpp
   52 static llvm::Optional<TestMatch> matchStmt(StringRef StatementCode,
  130     llvm::Optional<std::string> (*Builder)(const Expr &, const ASTContext &),
tools/clang/unittests/Tooling/StencilTest.cpp
   56 static llvm::Optional<TestMatch> matchStmt(StringRef StatementCode,
tools/clang/unittests/Tooling/Syntax/TokensTest.cpp
  114       llvm::Optional<TokenCollector> Collector;
tools/clang/unittests/Tooling/TransformerTest.cpp
   65                      const llvm::Optional<std::string> &MaybeActual) {
   84   llvm::Optional<std::string> rewrite(StringRef Input) {
tools/clang/utils/TableGen/ClangDiagnosticsEmitter.cpp
  273                          std::pair<unsigned, Optional<unsigned> > > GMap;
  689   using ModifierMappingsType = Optional<std::vector<int>>;
  720     Optional<std::vector<int>> OldMappings;
tools/dsymutil/CompileUnit.cpp
   50     Optional<DWARFFormValue> Value;
tools/dsymutil/CompileUnit.h
  132   Optional<PatchLocation> getUnitRangesAttribute() const {
  258   Optional<BasicDIEUnit> NewUnit;
  291   Optional<PatchLocation> UnitRangeAttribute;
tools/dsymutil/DebugMap.cpp
   46 bool DebugMapObject::addSymbol(StringRef Name, Optional<uint64_t> ObjectAddress,
  273     Optional<uint64_t> ObjAddress;
tools/dsymutil/DebugMap.h
  140     Optional<yaml::Hex64> ObjectAddress;
  144     SymbolMapping(Optional<uint64_t> ObjectAddr, uint64_t BinaryAddress,
  161   bool addSymbol(StringRef SymName, Optional<uint64_t> ObjectAddress,
tools/dsymutil/DwarfLinker.cpp
  264   if (Optional<DWARFFormValue> Val = DIE.find(dwarf::DW_AT_name))
  265     if (Optional<const char *> Name = Val->getAsCString()) {
  635   Optional<uint32_t> LocationIdx =
  676   Optional<uint32_t> LowPcIdx = Abbrev->findAttributeIndex(dwarf::DW_AT_low_pc);
  716   Optional<uint64_t> HighPc = DIE.getHighPC(*LowPc);
 2111   Optional<DWARFFormValue> Ref;
tools/dsymutil/DwarfStreamer.cpp
   30 static Optional<object::SectionRef>
tools/dsymutil/LinkUtils.h
   66   Optional<std::string> ResourceDir;
tools/dsymutil/MachODebugMapParser.cpp
   59   StringMap<Optional<uint64_t>> CurrentObjectAddresses;
tools/dsymutil/dsymutil.cpp
  379   OutputLocation(std::string DWARFFile, Optional<std::string> ResourceDir = {})
  382   Optional<std::string> getResourceDir() const { return ResourceDir; }
  384   Optional<std::string> ResourceDir;
tools/gold/gold-plugin.cpp
  118 static Optional<Reloc::Model> RelocationModel = None;
tools/lld/COFF/DebugTypes.cpp
  158 static Optional<std::string> findPdbPath(StringRef pdbPath,
  178   Optional<std::string> p = findPdbPath(ts.Name, dependentFile);
  222   Optional<std::string> p = findPdbPath(ts.Name, dependentFile);
tools/lld/COFF/Driver.cpp
  367       if (Optional<StringRef> path = findLib(arg->getValue()))
  425 static Optional<sys::fs::UniqueID> getUniqueID(StringRef path) {
  434 Optional<StringRef> LinkerDriver::findFile(StringRef filename) {
  437   if (Optional<sys::fs::UniqueID> id = getUniqueID(path)) {
  477 Optional<StringRef> LinkerDriver::findLib(StringRef filename) {
  487   if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
  495   Optional<std::string> envOpt = Process::GetEnv("LIB");
 1053     if (Optional<StringRef> path = doFindFile(arg->getValue()))
 1078 Optional<std::string> getReproduceFile(const opt::InputArgList &args) {
 1154   if (Optional<std::string> path = getReproduceFile(args)) {
 1559     if (Optional<StringRef> path = doFindFile(arg->getValue()))
 1560       if (Optional<sys::fs::UniqueID> id = getUniqueID(*path))
 1570     if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
 1592       if (Optional<StringRef> path = findFile(arg->getValue()))
 1596       if (Optional<StringRef> path = findFile(arg->getValue()))
 1608     if (Optional<StringRef> path = findLib(arg->getValue()))
tools/lld/COFF/Driver.h
   89   Optional<StringRef> findFile(StringRef filename);
   90   Optional<StringRef> findLib(StringRef filename);
tools/lld/COFF/DriverUtils.cpp
  893   if (Optional<std::string> s = Process::GetEnv("LINK")) {
  897   if (Optional<std::string> s = Process::GetEnv("_LINK_")) {
tools/lld/COFF/InputFiles.cpp
  423     } else if (Optional<Symbol *> optSym =
  574 Optional<Symbol *> ObjFile::createDefined(
  795 Optional<std::pair<StringRef, uint32_t>>
  804   Optional<std::pair<std::string, unsigned>> ret = dwarf->getVariableLoc(var);
  812 Optional<DILineInfo> ObjFile::getDILineInfo(uint32_t offset,
tools/lld/COFF/InputFiles.h
  193   llvm::Optional<uint32_t> pchSignature;
  205   llvm::Optional<llvm::codeview::CVTypeArray> debugTypes;
  207   llvm::Optional<std::pair<StringRef, uint32_t>>
  210   llvm::Optional<llvm::DILineInfo> getDILineInfo(uint32_t offset,
  256   llvm::Optional<Symbol *>
tools/lld/COFF/PDB.cpp
  302 static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *file) {
  397     if (Optional<ArrayRef<uint8_t>> debugH = getDebugH(file))
  453     Optional<uint32_t> endPrecomp;
 1794 Optional<std::pair<StringRef, uint32_t>>
 1806   Optional<uint32_t> nameIndex;
 1807   Optional<uint32_t> lineNumber;
tools/lld/COFF/PDB.h
   33 llvm::Optional<std::pair<llvm::StringRef, uint32_t>>
tools/lld/COFF/SymbolTable.cpp
  111 static Optional<std::pair<StringRef, uint32_t>>
  113   Optional<DILineInfo> optionalLineInfo =
  123 static Optional<std::pair<StringRef, uint32_t>>
  126   Optional<std::pair<StringRef, uint32_t>> fileLine =
  152       Optional<std::pair<StringRef, uint32_t>> fileLine =
  532   Optional<std::pair<StringRef, uint32_t>> fileLine;
tools/lld/COFF/Writer.cpp
  228   llvm::Optional<coff_symbol16> createSymbol(Defined *d);
 1083 Optional<coff_symbol16> Writer::createSymbol(Defined *def) {
 1162         if (Optional<coff_symbol16> sym = createSymbol(d))
tools/lld/Common/DWARF.cpp
   72 Optional<std::pair<std::string, unsigned>>
   91 Optional<DILineInfo> DWARFCache::getDILineInfo(uint64_t offset,
tools/lld/Common/TargetOptionsCommandFlags.cpp
   29 llvm::Optional<llvm::Reloc::Model> lld::getRelocModelFromCMModel() {
   33 llvm::Optional<llvm::CodeModel::Model> lld::getCodeModelFromCMModel() {
tools/lld/ELF/Config.h
  230   llvm::Optional<uint64_t> imageBase;
tools/lld/ELF/DWARF.cpp
   82 Optional<RelocAddrEntry>
  119 Optional<RelocAddrEntry> LLDDwarfObj<ELFT>::find(const llvm::DWARFSection &s,
tools/lld/ELF/DWARF.h
   72   llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &sec,
   77   llvm::Optional<llvm::RelocAddrEntry> findAux(const InputSectionBase &sec,
tools/lld/ELF/Driver.cpp
  192   Optional<MemoryBufferRef> buffer = readFile(path);
  274   if (Optional<std::string> path = searchLibrary(name))
 1036     if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue())){
 1054     if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
 1065       if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
 1081     if (Optional<std::string> path = searchScript(arg->getValue())) {
 1082       if (Optional<MemoryBufferRef> buffer = readFile(*path))
 1171       if (Optional<std::string> path = searchScript(arg->getValue())) {
 1172         if (Optional<MemoryBufferRef> mb = readFile(*path))
 1202       if (Optional<MemoryBufferRef> mb = readFile(arg->getValue())) {
 1302 static Optional<uint64_t> getImageBase(opt::InputArgList &args) {
 1967       if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
tools/lld/ELF/Driver.h
   69 llvm::Optional<std::string> findFromSearchPaths(StringRef path);
   70 llvm::Optional<std::string> searchScript(StringRef path);
   71 llvm::Optional<std::string> searchLibraryBaseName(StringRef path);
   72 llvm::Optional<std::string> searchLibrary(StringRef path);
tools/lld/ELF/DriverUtils.cpp
  207 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
  219 Optional<std::string> findFromSearchPaths(StringRef path) {
  221     if (Optional<std::string> s = findFile(dir, path))
  228 Optional<std::string> searchLibraryBaseName(StringRef name) {
  231       if (Optional<std::string> s = findFile(dir, "lib" + name + ".so"))
  233     if (Optional<std::string> s = findFile(dir, "lib" + name + ".a"))
  240 Optional<std::string> searchLibrary(StringRef name) {
  249 Optional<std::string> searchScript(StringRef name) {
tools/lld/ELF/InputFiles.cpp
  103 Optional<MemoryBufferRef> readFile(StringRef path) {
  236   if (Optional<DILineInfo> info = file.getDILineInfo(&sec, offset))
  240   if (Optional<std::pair<std::string, unsigned>> fileLine =
  274 Optional<std::pair<std::string, unsigned>>
  284 Optional<DILineInfo> ObjFile<ELFT>::getDILineInfo(InputSectionBase *s,
  489   else if (Optional<std::string> s = findFromSearchPaths(specifier))
  491   else if (Optional<std::string> s = searchLibraryBaseName(specifier))
tools/lld/ELF/InputFiles.h
   52 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
  141   llvm::Optional<size_t> mipsGotIndex;
  223   llvm::Optional<llvm::DILineInfo> getDILineInfo(InputSectionBase *, uint64_t);
  224   llvm::Optional<std::pair<std::string, unsigned>> getVariableLoc(StringRef name);
tools/lld/ELF/InputSection.cpp
  304   if (Optional<DILineInfo> info = getFile<ELFT>()->getDILineInfo(this, offset))
tools/lld/ELF/LinkerScript.cpp
 1183 static Optional<size_t> getPhdrIndex(ArrayRef<PhdrsCommand> vec,
 1197     if (Optional<size_t> idx = getPhdrIndex(phdrsCommands, s))
tools/lld/ELF/LinkerScript.h
  210   llvm::Optional<unsigned> flags;
tools/lld/ELF/OutputSections.h
   87   llvm::Optional<std::array<uint8_t, 4>> filler;
tools/lld/ELF/Relocations.cpp
   67 static Optional<std::string> getLinkerScriptLocation(const Symbol &sym) {
   85   else if (Optional<std::string> loc = getLinkerScriptLocation(sym))
tools/lld/ELF/ScriptParser.cpp
  301     if (Optional<std::string> path = findFromSearchPaths(s))
  349   if (Optional<std::string> path = searchScript(tok)) {
  350     if (Optional<MemoryBufferRef> mb = readFile(*path))
 1057 static Optional<uint64_t> parseInt(StringRef tok) {
 1278   if (Optional<uint64_t> val = parseInt(tok))
 1315   if (Optional<uint64_t> val = parseInt(tok))
tools/lld/ELF/SymbolTable.h
   85   llvm::Optional<llvm::StringMap<std::vector<Symbol *>>> demangledSyms;
tools/lld/MinGW/Driver.cpp
  113 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
  126       if (Optional<std::string> s = findFile(dir, name.substr(1)))
  134       if (Optional<std::string> s = findFile(dir, "lib" + name + ".dll.a"))
  136       if (Optional<std::string> s = findFile(dir, name + ".dll.a"))
  139     if (Optional<std::string> s = findFile(dir, "lib" + name + ".a"))
  142       if (Optional<std::string> s = findFile(dir, name + ".lib"))
  144       if (Optional<std::string> s = findFile(dir, "lib" + name + ".dll")) {
  149       if (Optional<std::string> s = findFile(dir, name + ".dll")) {
tools/lld/include/lld/Common/DWARF.h
   29   llvm::Optional<llvm::DILineInfo> getDILineInfo(uint64_t offset,
   31   llvm::Optional<std::pair<std::string, unsigned>>
tools/lld/include/lld/Common/TargetOptionsCommandFlags.h
   19 llvm::Optional<llvm::Reloc::Model> getRelocModelFromCMModel();
   20 llvm::Optional<llvm::CodeModel::Model> getCodeModelFromCMModel();
tools/lld/include/lld/Core/File.h
  238   llvm::Optional<std::error_code> _lastError;
tools/lld/include/lld/ReaderWriter/MachOLinkingContext.h
  227   llvm::Optional<StringRef> searchDirForLibrary(StringRef path,
  232   llvm::Optional<StringRef> searchLibrary(StringRef libName) const;
  240   llvm::Optional<StringRef> findPathForFramework(StringRef fwName) const;
tools/lld/lib/Driver/DarwinLdDriver.cpp
 1056     llvm::Optional<StringRef> resolvedPath;
tools/lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp
  530 llvm::Optional<StringRef>
  558 llvm::Optional<StringRef>
  562     llvm::Optional<StringRef> searchDir = searchDirForLibrary(dir, libName);
  570 llvm::Optional<StringRef>
tools/lld/wasm/Config.h
   66   llvm::Optional<std::vector<std::string>> features;
tools/lld/wasm/Driver.cpp
  150 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
  183   if (Optional<MemoryBufferRef> buf = readFile(filename))
  219   Optional<MemoryBufferRef> buffer = readFile(path);
  261     if (Optional<std::string> s = findFile(dir, "lib" + name + ".a")) {
tools/lld/wasm/InputChunks.h
  170   llvm::Optional<uint32_t> functionIndex;
  171   llvm::Optional<uint32_t> tableIndex;
tools/lld/wasm/InputEvent.h
   51   llvm::Optional<uint32_t> eventIndex;
tools/lld/wasm/InputFiles.cpp
   45 Optional<MemoryBufferRef> readFile(StringRef path) {
tools/lld/wasm/InputFiles.h
  170 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
tools/lld/wasm/InputGlobal.h
   44   llvm::Optional<uint32_t> globalIndex;
tools/lldb/include/lldb/Breakpoint/BreakpointID.h
   61   static llvm::Optional<BreakpointID>
tools/lldb/include/lldb/Core/Highlighter.h
  115                          llvm::Optional<size_t> cursor_pos,
  120                         llvm::Optional<size_t> cursor_pos,
  131                  llvm::Optional<size_t> cursor_pos,
tools/lldb/include/lldb/Core/Module.h
  964   llvm::Optional<UnwindTable> m_unwind_table; ///< Table of FuncUnwinders
tools/lldb/include/lldb/Core/SourceManager.h
   44     size_t DisplaySourceLines(uint32_t line, llvm::Optional<size_t> column,
tools/lldb/include/lldb/Core/ValueObject.h
  860   llvm::Optional<std::pair<TypeValidatorResult, std::string>>
tools/lldb/include/lldb/Core/ValueObjectChild.h
   72   llvm::Optional<LazyBool> m_can_update_with_invalid_exe_ctx;
tools/lldb/include/lldb/Expression/ExpressionVariable.h
  235   virtual llvm::Optional<CompilerType>
tools/lldb/include/lldb/Host/FileSystem.h
  190   static llvm::Optional<FileSystem> &InstanceImpl();
tools/lldb/include/lldb/Host/HostInfoBase.h
   59   static llvm::Optional<ArchitectureKind> ParseArchitectureKind(llvm::StringRef kind);
tools/lldb/include/lldb/Host/common/NativeProcessProtocol.h
  150   virtual llvm::Optional<std::pair<uint32_t, uint32_t>>
  183   virtual llvm::Optional<WaitStatus> GetExitStatus();
  413   llvm::Optional<WaitStatus> m_exit_status;
tools/lldb/include/lldb/Interpreter/CommandHistory.h
   31   llvm::Optional<llvm::StringRef> FindString(llvm::StringRef input_str) const;
tools/lldb/include/lldb/Interpreter/CommandInterpreter.h
  582   llvm::Optional<int> m_quit_exit_code;
tools/lldb/include/lldb/Symbol/ClangASTContext.h
  692   llvm::Optional<uint64_t> GetByteSize(lldb::opaque_compiler_type_t type,
  694     if (llvm::Optional<uint64_t> bit_size = GetBitSize(type, exe_scope))
  699   llvm::Optional<uint64_t>
  708   llvm::Optional<size_t>
  785   llvm::Optional<CompilerType::IntegralTemplateArgument>
tools/lldb/include/lldb/Symbol/CompilerType.h
  248   llvm::Optional<uint64_t> GetByteSize(ExecutionContextScope *exe_scope) const;
  250   llvm::Optional<uint64_t> GetBitSize(ExecutionContextScope *exe_scope) const;
  256   llvm::Optional<size_t> GetTypeBitAlign(ExecutionContextScope *exe_scope) const;
  326   llvm::Optional<IntegralTemplateArgument>
tools/lldb/include/lldb/Symbol/CxxModuleHandler.h
   46   llvm::Optional<clang::Decl *> tryInstantiateStdTemplate(clang::Decl *d);
   56   llvm::Optional<clang::Decl *> Import(clang::Decl *d);
tools/lldb/include/lldb/Symbol/DWARFCallFrameInfo.h
  124   llvm::Optional<FDEEntryMap::Entry>
tools/lldb/include/lldb/Symbol/SymbolFile.h
  152   virtual llvm::Optional<ArrayInfo>
  266   llvm::Optional<std::vector<lldb::CompUnitSP>> m_compile_units;
tools/lldb/include/lldb/Symbol/Type.h
  101        llvm::Optional<uint64_t> byte_size, SymbolContextScope *context,
  127   llvm::Optional<uint64_t> GetByteSize();
tools/lldb/include/lldb/Symbol/TypeSystem.h
   45   llvm::Optional<lldb::LanguageType> GetSingularLanguage();
  282   virtual llvm::Optional<uint64_t>
  360   virtual llvm::Optional<CompilerType::IntegralTemplateArgument>
  412   virtual llvm::Optional<size_t>
tools/lldb/include/lldb/Symbol/UnwindTable.h
   63   llvm::Optional<AddressRange> GetAddressRange(const Address &addr,
tools/lldb/include/lldb/Target/LanguageRuntime.h
  159   virtual llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) {
tools/lldb/include/lldb/Target/UnixSignals.h
   91   std::vector<int32_t> GetFilteredSignals(llvm::Optional<bool> should_suppress,
   92                                           llvm::Optional<bool> should_stop,
   93                                           llvm::Optional<bool> should_notify);
tools/lldb/include/lldb/Utility/FileSpec.h
  214   static llvm::Optional<Style> GuessPathStyle(llvm::StringRef absolute_path);
tools/lldb/include/lldb/Utility/Predicate.h
  122   llvm::Optional<T> WaitFor(C Cond, const Timeout<std::micro> &timeout) {
  182   llvm::Optional<T>
tools/lldb/include/lldb/Utility/Reproducer.h
  332                                 llvm::Optional<FileSpec> root);
  350   llvm::Error SetCapture(llvm::Optional<FileSpec> root);
  351   llvm::Error SetReplay(llvm::Optional<FileSpec> root);
  354   static llvm::Optional<Reproducer> &InstanceImpl();
  356   llvm::Optional<Generator> m_generator;
  357   llvm::Optional<Loader> m_loader;
  368   llvm::Optional<std::string> GetNextFile();
tools/lldb/include/lldb/Utility/SelectHelper.h
   68   llvm::Optional<std::chrono::steady_clock::time_point> m_end_time;
tools/lldb/include/lldb/Utility/Timeout.h
   28 class Timeout : public llvm::Optional<std::chrono::duration<int64_t, Ratio>> {
   36   using Base = llvm::Optional<Dur<Ratio>>;
tools/lldb/include/lldb/Utility/UserIDResolver.h
   27   llvm::Optional<llvm::StringRef> GetUserName(id_t uid) {
   30   llvm::Optional<llvm::StringRef> GetGroupName(id_t gid) {
   39   virtual llvm::Optional<std::string> DoGetUserName(id_t uid) = 0;
   40   virtual llvm::Optional<std::string> DoGetGroupName(id_t gid) = 0;
   43   using Map = llvm::DenseMap<id_t, llvm::Optional<std::string>>;
   45   llvm::Optional<llvm::StringRef>
tools/lldb/source/API/SBDebugger.cpp
  321     llvm::Optional<std::string> nextfile = loader->GetNextFile();
tools/lldb/source/API/SBType.cpp
  125     if (llvm::Optional<uint64_t> size =
tools/lldb/source/Breakpoint/BreakpointID.cpp
   70 llvm::Optional<BreakpointID>
tools/lldb/source/Commands/CommandObjectFrame.cpp
  112     llvm::Optional<lldb::addr_t> address;
  113     llvm::Optional<ConstString> reg;
  114     llvm::Optional<int64_t> offset;
  274     llvm::Optional<int32_t> relative_frame_offset;
tools/lldb/source/Commands/CommandObjectMemory.cpp
  485             if (llvm::Optional<CompilerType> type =
  533       llvm::Optional<uint64_t> size = compiler_type.GetByteSize(nullptr);
  656       llvm::Optional<uint64_t> size = compiler_type.GetByteSize(nullptr);
 1073         llvm::Optional<uint64_t> size =
tools/lldb/source/Commands/CommandObjectReproducer.cpp
  226     llvm::Optional<Loader> loader_storage;
  309         llvm::Optional<std::string> command_file =
tools/lldb/source/Core/DumpDataExtractor.cpp
   65 static llvm::Optional<llvm::APInt> GetAPInt(const DataExtractor &data,
  113   llvm::Optional<llvm::APInt> apint = GetAPInt(data, &offset, byte_size);
  578           llvm::Optional<llvm::APInt> apint =
tools/lldb/source/Core/Highlighter.cpp
   30                                    llvm::Optional<size_t> cursor_pos,
   75                                    llvm::Optional<size_t> cursor_pos,
tools/lldb/source/Core/IOHandler.cpp
  314 static Optional<std::string> SplitLine(std::string &line_buffer) {
  325 static Optional<std::string> SplitLineEOF(std::string &line_buffer) {
  362   Optional<std::string> got_line = SplitLine(m_line_buffer);
tools/lldb/source/Core/SourceManager.cpp
  199       llvm::Optional<size_t> columnToHighlight;
  524                                                llvm::Optional<size_t> column,
tools/lldb/source/Core/Value.cpp
  226     if (llvm::Optional<uint64_t> size = GetCompilerType().GetByteSize(scope)) {
  343     if (llvm::Optional<uint64_t> size = ast_type.GetByteSize(
tools/lldb/source/Core/ValueObject.cpp
  344     if (llvm::Optional<CompilerType> complete_type =
  775   llvm::Optional<uint64_t> item_type_size =
 1843   llvm::Optional<uint64_t> size =
 1885   llvm::Optional<uint64_t> size =
tools/lldb/source/DataFormatters/TypeFormat.cpp
   98         llvm::Optional<uint64_t> size = compiler_type.GetByteSize(exe_scope);
tools/lldb/source/DataFormatters/VectorType.cpp
  174   llvm::Optional<uint64_t> container_size =
  176   llvm::Optional<uint64_t> element_size = element_type.GetByteSize(exe_scope);
  202     llvm::Optional<uint64_t> size = m_child_type.GetByteSize(nullptr);
tools/lldb/source/Expression/Materializer.cpp
  533         llvm::Optional<size_t> opt_bit_align =
  789       llvm::Optional<uint64_t> byte_size = m_type.GetByteSize(exe_scope);
  795       llvm::Optional<size_t> opt_bit_align = m_type.GetTypeBitAlign(exe_scope);
tools/lldb/source/Host/common/FileSystem.cpp
   83 Optional<FileSystem> &FileSystem::InstanceImpl() {
   84   static Optional<FileSystem> g_fs;
tools/lldb/source/Host/common/HostInfoBase.cpp
  102 llvm::Optional<HostInfoBase::ArchitectureKind> HostInfoBase::ParseArchitectureKind(llvm::StringRef kind) {
tools/lldb/source/Host/common/NativeProcessProtocol.cpp
   57 llvm::Optional<WaitStatus> NativeProcessProtocol::GetExitStatus() {
  118 llvm::Optional<std::pair<uint32_t, uint32_t>>
tools/lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp
   66 llvm::Optional<llvm::StringRef> GetURLAddress(llvm::StringRef url,
  159     llvm::Optional<llvm::StringRef> addr;
tools/lldb/source/Host/posix/HostInfoPosix.cpp
   50   llvm::Optional<std::string> DoGetUserName(id_t uid) override;
   51   llvm::Optional<std::string> DoGetGroupName(id_t gid) override;
   60 static llvm::Optional<PasswdEntry> GetPassword(id_t uid) {
   82 llvm::Optional<std::string> PosixUserIDResolver::DoGetUserName(id_t uid) {
   83   if (llvm::Optional<PasswdEntry> password = GetPassword(uid))
   88 llvm::Optional<std::string> PosixUserIDResolver::DoGetGroupName(id_t gid) {
  127   if (llvm::Optional<PasswdEntry> password = GetPassword(::geteuid()))
tools/lldb/source/Interpreter/CommandHistory.cpp
   30 llvm::Optional<llvm::StringRef>
tools/lldb/source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp
 1471       llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
 1577     llvm::Optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
 1597             llvm::Optional<uint64_t> byte_size =
tools/lldb/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp
 1763     llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
 2113   llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
 2130       llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
 2266   llvm::Optional<uint64_t> byte_size =
tools/lldb/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp
  825     llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
  934     llvm::Optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.h
  102   using RegisterFileFlag = llvm::Optional<bool>;
tools/lldb/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp
 1474         if (llvm::Optional<uint64_t> size = compiler_type.GetBitSize(&thread))
 1581   llvm::Optional<uint64_t> bit_width = compiler_type.GetBitSize(&thread);
 1582   llvm::Optional<uint64_t> byte_size = compiler_type.GetByteSize(&thread);
 1718         llvm::Optional<uint64_t> base_byte_size =
 1747               llvm::Optional<uint64_t> base_byte_size =
tools/lldb/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp
 1768       llvm::Optional<uint64_t> bit_size = value_type.GetBitSize(&thread);
 2089   llvm::Optional<uint64_t> byte_size = value_type.GetByteSize(nullptr);
 2107       llvm::Optional<uint64_t> base_byte_size = base_type.GetByteSize(nullptr);
 2236   llvm::Optional<uint64_t> byte_size =
tools/lldb/source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp
  309     llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
  514     llvm::Optional<uint64_t> byte_size =
  639     llvm::Optional<uint64_t> byte_size =
tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp
  806   llvm::Optional<uint64_t> bit_width = return_compiler_type.GetBitSize(&thread);
tools/lldb/source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp
  753   llvm::Optional<uint64_t> byte_size =
  962             llvm::Optional<uint64_t> field_byte_width =
 1034         llvm::Optional<uint64_t> field_byte_width =
tools/lldb/source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp
  395     llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
  463       llvm::Optional<uint64_t> bit_width =
  527       llvm::Optional<uint64_t> byte_size =
  574         llvm::Optional<uint64_t> byte_size =
  608     llvm::Optional<uint64_t> byte_size =
  659   llvm::Optional<uint64_t> bit_width = return_compiler_type.GetBitSize(&thread);
  703         llvm::Optional<uint64_t> field_bit_width =
tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp
  271     llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
  341       llvm::Optional<uint64_t> bit_width =
  644     llvm::Optional<uint64_t> byte_size = type.GetByteSize(nullptr);
  778       llvm::Optional<uint64_t> elem_size = elem_type.GetByteSize(nullptr);
tools/lldb/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp
  371     llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
  441       llvm::Optional<uint64_t> bit_width =
  508       llvm::Optional<uint64_t> byte_size =
  555         llvm::Optional<uint64_t> byte_size =
tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp
  421     llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
  491       llvm::Optional<uint64_t> bit_width =
  560       llvm::Optional<uint64_t> byte_size =
  607         llvm::Optional<uint64_t> byte_size =
  646     llvm::Optional<uint64_t> byte_size =
  741     llvm::Optional<uint64_t> field_bit_width =
  784   llvm::Optional<uint64_t> bit_width = return_compiler_type.GetBitSize(&thread);
tools/lldb/source/Plugins/ABI/Windows-x86_64/ABIWindows_x86_64.cpp
 1254     llvm::Optional<uint64_t> bit_size = compiler_type.GetBitSize(&thread);
 1324       llvm::Optional<uint64_t> bit_width =
 1394       llvm::Optional<uint64_t> byte_size =
 1441         llvm::Optional<uint64_t> byte_size =
 1479     llvm::Optional<uint64_t> byte_size =
 1540     llvm::Optional<uint64_t> field_bit_width =
 1591   llvm::Optional<uint64_t> bit_width = return_compiler_type.GetBitSize(&thread);
tools/lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp
  623   if (llvm::Optional<uint64_t> vdso_base =
  627   if (llvm::Optional<uint64_t> interpreter_base =
  639   llvm::Optional<uint64_t> entry_point =
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTUtils.h
   74   llvm::Optional<ASTSourceDescriptor>
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp
   67 llvm::Optional<CompilerType>
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h
   62   llvm::Optional<CompilerType>
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangUserExpression.h
  217   llvm::Optional<size_t> m_user_expression_start_pos;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
  315   llvm::Optional<uint64_t> bit_size =
 1250     llvm::Optional<uint64_t> value_size = compiler_type.GetByteSize(nullptr);
 1253     llvm::Optional<size_t> opt_alignment = compiler_type.GetTypeBitAlign(nullptr);
tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp
   23 Optional<ParsedFunction> CPlusPlusNameParser::ParseAsFunctionDefinition() {
   25   Optional<ParsedFunction> result(None);
   50 Optional<ParsedName> CPlusPlusNameParser::ParseAsFullName() {
   52   Optional<ParsedNameRanges> name_ranges = ParseFullNameImpl();
  104 Optional<ParsedFunction>
  136 Optional<ParsedFunction>
  463 Optional<CPlusPlusNameParser::ParsedNameRanges>
  477   Optional<size_t> last_coloncolon_position = None;
tools/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.h
   48   llvm::Optional<ParsedFunction> ParseAsFunctionDefinition();
   58   llvm::Optional<ParsedName> ParseAsFullName();
  127   llvm::Optional<ParsedFunction> ParseFunctionImpl(bool expect_return_type);
  130   llvm::Optional<ParsedFunction> ParseFuncPtr(bool expect_return_type);
  168   llvm::Optional<ParsedNameRanges> ParseFullNameImpl();
tools/lldb/source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp
  128   llvm::Optional<uint64_t> size = wchar_compiler_type.GetBitSize(nullptr);
  251   llvm::Optional<uint64_t> size = wchar_compiler_type.GetBitSize(nullptr);
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp
  258         llvm::Optional<uint64_t> size = tree_node_type.GetByteSize(nullptr);
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp
   89     llvm::Optional<uint64_t> bit_size =
  101   llvm::Optional<uint64_t> bit_size =
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp
   96   if (llvm::Optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp
   84 llvm::Optional<uint64_t> LibcxxVariantIndexValue(ValueObjectSP &impl_sp) {
tools/lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp
  147   if (llvm::Optional<uint64_t> size = m_element_type.GetByteSize(nullptr)) {
  215   llvm::Optional<uint64_t> size = m_bool_type.GetByteSize(nullptr);
tools/lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp
  300       llvm::Optional<uint64_t> size = wchar_compiler_type.GetBitSize(nullptr);
tools/lldb/source/Plugins/Language/ClangCommon/ClangHighlighter.cpp
  133                                  llvm::Optional<size_t> cursor_pos,
tools/lldb/source/Plugins/Language/ClangCommon/ClangHighlighter.h
   27                  llvm::Optional<size_t> cursor_pos,
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntime.h
  126   llvm::Optional<uint32_t> m_Foundation_major;
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h
  337   llvm::Optional<std::pair<lldb::addr_t, lldb::addr_t>> m_CFBoolean_values;
tools/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp
  401 llvm::Optional<CompilerType>
tools/lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h
  254   llvm::Optional<CompilerType> GetRuntimeType(CompilerType base_type) override;
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptExpressionOpts.cpp
   97   llvm::Optional<llvm::Reloc::Model> reloc_model = llvm::None;
tools/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.cpp
  125 llvm::Optional<Record::Kind> Record::classify(llvm::StringRef Line) {
  165 llvm::Optional<ModuleRecord> ModuleRecord::parse(llvm::StringRef Line) {
  194 llvm::Optional<InfoRecord> InfoRecord::parse(llvm::StringRef Line) {
  219 llvm::Optional<FileRecord> FileRecord::parse(llvm::StringRef Line) {
  280 llvm::Optional<FuncRecord> FuncRecord::parse(llvm::StringRef Line) {
  302 llvm::Optional<LineRecord> LineRecord::parse(llvm::StringRef Line) {
  337 llvm::Optional<PublicRecord> PublicRecord::parse(llvm::StringRef Line) {
  359 llvm::Optional<StackCFIRecord> StackCFIRecord::parse(llvm::StringRef Line) {
  381   llvm::Optional<lldb::addr_t> Size;
  408 llvm::Optional<StackWinRecord> StackWinRecord::parse(llvm::StringRef Line) {
tools/lldb/source/Plugins/ObjectFile/Breakpad/BreakpadRecords.h
   28   static llvm::Optional<Kind> classify(llvm::StringRef Line);
   50   static llvm::Optional<ModuleRecord> parse(llvm::StringRef Line);
   66   static llvm::Optional<InfoRecord> parse(llvm::StringRef Line);
   79   static llvm::Optional<FileRecord> parse(llvm::StringRef Line);
   94   static llvm::Optional<FuncRecord> parse(llvm::StringRef Line);
  112   static llvm::Optional<LineRecord> parse(llvm::StringRef Line);
  129   static llvm::Optional<PublicRecord> parse(llvm::StringRef Line);
  146   static llvm::Optional<StackCFIRecord> parse(llvm::StringRef Line);
  147   StackCFIRecord(lldb::addr_t Address, llvm::Optional<lldb::addr_t> Size,
  153   llvm::Optional<lldb::addr_t> Size;
  162   static llvm::Optional<StackWinRecord> parse(llvm::StringRef Line);
tools/lldb/source/Plugins/ObjectFile/Breakpad/ObjectFileBreakpad.cpp
   23   static llvm::Optional<Header> parse(llvm::StringRef text);
   27 llvm::Optional<Header> Header::parse(llvm::StringRef text) {
   72   llvm::Optional<Header> header = Header::parse(text);
   99   llvm::Optional<Header> header = Header::parse(text);
  132   llvm::Optional<Record::Kind> current_section;
  153     llvm::Optional<Record::Kind> next_section = Record::classify(line);
tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
  783 llvm::Optional<FileSpec> ObjectFileELF::GetDebugLink() {
 1702   llvm::Optional<VMRange> GetAddressInfo(const ELFProgramHeader &H) {
 1717   llvm::Optional<SectionAddressInfo> GetAddressInfo(const ELFSectionHeader &H) {
tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h
  127   llvm::Optional<lldb_private::FileSpec> GetDebugLink();
tools/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
 2029 static llvm::Optional<struct nlist_64>
tools/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h
  223   llvm::Optional<llvm::VersionTuple> m_min_os_version;
  224   llvm::Optional<llvm::VersionTuple> m_sdk_versions;
tools/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h
  301   llvm::Optional<lldb_private::FileSpecList> m_deps_filespec;
  303   llvm::Optional<OWNBINType> m_owningbin;
tools/lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp
   29     const llvm::Optional<AdbClient::UnixSocketNamespace> &socket_namespace,
tools/lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.h
   44   llvm::Optional<AdbClient::UnixSocketNamespace> m_socket_namespace;
tools/lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp
  836   llvm::Optional<llvm::detail::scope_exit<std::function<void()>>>
  843   llvm::Optional<llvm::detail::scope_exit<std::function<void()>>>
tools/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp
  341 llvm::Optional<std::string>
  349 llvm::Optional<std::string>
tools/lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h
  192   llvm::Optional<std::string> DoGetUserName(UserIDResolver::id_t uid) override;
  193   llvm::Optional<std::string> DoGetGroupName(UserIDResolver::id_t uid) override;
tools/lldb/source/Plugins/Process/POSIX/NativeProcessELF.cpp
   15 llvm::Optional<uint64_t>
   47   llvm::Optional<uint64_t> maybe_phdr_addr =
   49   llvm::Optional<uint64_t> maybe_phdr_entry_size =
   51   llvm::Optional<uint64_t> maybe_phdr_num_entries =
tools/lldb/source/Plugins/Process/POSIX/NativeProcessELF.h
   33   llvm::Optional<uint64_t> GetAuxValue(enum AuxVector::EntryType type);
   48   llvm::Optional<lldb::addr_t> m_shared_library_info_addr;
tools/lldb/source/Plugins/Process/Utility/AuxVector.cpp
   32 llvm::Optional<uint64_t>
tools/lldb/source/Plugins/Process/Utility/AuxVector.h
   63   llvm::Optional<uint64_t> GetAuxValue(enum EntryType entry_type) const;
tools/lldb/source/Plugins/Process/elf-core/RegisterUtilities.cpp
   14 static llvm::Optional<uint32_t>
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
 3596 static llvm::Optional<ModuleSpec>
 3630 llvm::Optional<std::vector<ModuleSpec>>
 3677     if (llvm::Optional<ModuleSpec> module_spec = ParseModuleSpec(
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
  431   llvm::Optional<std::vector<ModuleSpec>>
tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp
  440     if (llvm::Optional<llvm::StringRef> name =
  460     if (llvm::Optional<llvm::StringRef> name =
tools/lldb/source/Plugins/Process/minidump/MinidumpParser.cpp
  235 llvm::Optional<LinuxProcStatus> MinidumpParser::GetLinuxProcStatus() {
  244 llvm::Optional<lldb::pid_t> MinidumpParser::GetPid() {
  250   llvm::Optional<LinuxProcStatus> proc_status = GetLinuxProcStatus();
  328 llvm::Optional<minidump::Range>
  396   llvm::Optional<minidump::Range> range = FindMemoryRange(addr);
tools/lldb/source/Plugins/Process/minidump/MinidumpParser.h
   73   llvm::Optional<LinuxProcStatus> GetLinuxProcStatus();
   75   llvm::Optional<lldb::pid_t> GetPid();
   87   llvm::Optional<Range> FindMemoryRange(lldb::addr_t addr);
tools/lldb/source/Plugins/Process/minidump/MinidumpTypes.cpp
   27 llvm::Optional<lldb::pid_t> MinidumpMiscInfo::GetPid() const {
   37 llvm::Optional<LinuxProcStatus>
tools/lldb/source/Plugins/Process/minidump/MinidumpTypes.h
  102   llvm::Optional<lldb::pid_t> GetPid() const;
  113   static llvm::Optional<LinuxProcStatus> Parse(llvm::ArrayRef<uint8_t> &data);
tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp
  227   llvm::Optional<lldb::pid_t> pid = m_minidump_parser->GetPid();
tools/lldb/source/Plugins/Process/minidump/ProcessMinidump.h
   95   llvm::Optional<MinidumpParser> m_minidump_parser;
  114   llvm::Optional<MemoryRegionInfos> m_memory_regions;
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp
  376 static llvm::Optional<std::pair<llvm::StringRef, llvm::StringRef>>
  504   llvm::Optional<StackCFIRecord> init_record = StackCFIRecord::parse(*It);
  523     llvm::Optional<StackCFIRecord> record = StackCFIRecord::parse(*It);
  547   llvm::Optional<StackWinRecord> record = StackWinRecord::parse(*It);
  697   llvm::Optional<addr_t> next_addr;
tools/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h
   82   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
  191     llvm::Optional<FileSpecList> support_files;
  215   llvm::Optional<std::vector<FileSpec>> m_files;
  216   llvm::Optional<CompUnitMap> m_cu_data;
  223   llvm::Optional<UnwindData> m_unwind_data;
tools/lldb/source/Plugins/SymbolFile/DWARF/DIERef.h
   30   DIERef(llvm::Optional<uint32_t> dwo_num, Section section,
   37   llvm::Optional<uint32_t> dwo_num() const {
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h
   53   static llvm::Optional<lldb_private::SymbolFile::ArrayInfo>
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
 1253     if (llvm::Optional<uint64_t> clang_type_size =
 1831           llvm::Optional<uint64_t> size = clang_type.GetBitSize(nullptr);
 2498         llvm::Optional<uint64_t> byte_size;
 3192 llvm::Optional<SymbolFile::ArrayInfo>
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h
  196   llvm::Optional<uint64_t> byte_size;
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp
   21 llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef() const {
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h
   58   llvm::Optional<DIERef> GetDIERef() const;
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFContext.cpp
   32                                llvm::Optional<SectionType> dwo_section_type,
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFContext.h
   48                    llvm::Optional<lldb::SectionType> dwo_section_type,
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
   72       llvm::Optional<uint8_t> fixed_skip_size =
  582         llvm::Optional<uint8_t> fixed_skip_size = DWARFFormValue::GetFixedSize(form, cu);
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
  188 llvm::Optional<uint8_t>
  197 llvm::Optional<uint8_t> DWARFFormValue::GetFixedSize() const {
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.h
   57   static llvm::Optional<uint8_t> GetFixedSize(dw_form_t form,
   59   llvm::Optional<uint8_t> GetFixedSize() const;
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
  285   llvm::Optional<uint64_t> addr_base, gnu_addr_base, ranges_base,
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h
  282   llvm::Optional<lldb_private::FileSpec> m_comp_dir;
  283   llvm::Optional<lldb_private::FileSpec> m_file_spec;
tools/lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp
   46 llvm::Optional<DIERef>
   48   llvm::Optional<uint64_t> cu_offset = entry.getCUOffset();
   62   if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
   71   if (llvm::Optional<DIERef> ref = ToDIERef(entry))
  158     llvm::Optional<DIERef> ref = ToDIERef(entry);
  231     if (llvm::Optional<DIERef> ref = ToDIERef(entry))
tools/lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h
   69   llvm::Optional<DIERef> ToDIERef(const DebugNames::Entry &entry);
tools/lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp
   48   std::vector<llvm::Optional<DWARFUnit::ScopedExtractDIEs>> clear_cu_dies(
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
  761 llvm::Optional<uint32_t> SymbolFileDWARF::GetDWARFUnitIndex(uint32_t cu_idx) {
  785   if (llvm::Optional<uint32_t> dwarf_idx = GetDWARFUnitIndex(cu_idx)) {
 1235 llvm::Optional<SymbolFileDWARF::DecodedUID>
 1260   llvm::Optional<uint32_t> dwo_num = uid >> 32 & 0x7fffffff;
 1273   llvm::Optional<DecodedUID> decoded = DecodeUID(uid);
 1328 llvm::Optional<SymbolFile::ArrayInfo>
 3688     llvm::Optional<DWARFExpression> LocationInCallee = {};
 3689     llvm::Optional<DWARFExpression> LocationInCaller = {};
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
  129   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
  274   lldb::user_id_t GetUID(const llvm::Optional<DIERef> &ref) {
  289   virtual llvm::Optional<uint32_t> GetDwoNum() { return llvm::None; }
  445   llvm::Optional<uint32_t> GetDWARFUnitIndex(uint32_t cu_idx);
  451   llvm::Optional<DecodedUID> DecodeUID(lldb::user_id_t uid);
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
  727 llvm::Optional<SymbolFile::ArrayInfo>
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
   75   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h
   47   llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
tools/lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp
   69   llvm::Optional<CVType> cvt = types.tryGetType(bis.BuildId);
tools/lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.h
   63   llvm::Optional<llvm::codeview::Compile3Sym> m_compile_opts;
   66   llvm::Optional<llvm::codeview::ObjNameSym> m_obj_name;
tools/lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp
  132     llvm::codeview::RegisterId reg, llvm::Optional<int32_t> relative_offset,
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp
   33 static llvm::Optional<PdbCompilandSymId> FindSymbolScope(PdbIndex &index,
  124 static llvm::Optional<clang::CallingConv>
  150 static llvm::Optional<CVTagRecord>
  332         llvm::Optional<CVTagRecord> tag =
  408 static llvm::Optional<PublicSym32> FindPublicSym(const SegmentOffset &addr,
  461 llvm::Optional<CompilerDecl> PdbAstBuilder::GetOrCreateDeclForUid(PdbSymUid uid) {
  537   llvm::Optional<PublicSym32> pub =
  581     llvm::Optional<PdbCompilandSymId> scope =
 1152   llvm::Optional<clang::CallingConv> cc =
 1178     llvm::Optional<llvm::StringRef> parent) {
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h
   58   llvm::Optional<lldb_private::CompilerDecl>
  120   void ParseAllNamespacesPlusChildrenOf(llvm::Optional<llvm::StringRef> parent);
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.cpp
   83 llvm::Optional<uint16_t>
   88 llvm::Optional<uint16_t> PdbIndex::GetModuleIndexForVa(lldb::addr_t va) const {
  144   llvm::Optional<uint16_t> modi = GetModuleIndexForVa(va);
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.h
  155   llvm::Optional<uint16_t> GetModuleIndexForAddr(uint16_t segment,
  157   llvm::Optional<uint16_t> GetModuleIndexForVa(lldb::addr_t va) const;
tools/lldb/source/Plugins/SymbolFile/NativePDB/PdbUtil.h
  106   llvm::Optional<DWARFExpression> location;
  107   llvm::Optional<Variable::RangeList> ranges;
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp
  687   llvm::Optional<PdbTypeSymId> full_decl_uid;
  791   llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(addr);
  964     llvm::Optional<uint16_t> modi = m_index->GetModuleIndexForVa(file_addr);
 1554 llvm::Optional<SymbolFile::ArrayInfo>
tools/lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h
  104   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp
   54     llvm::Optional<uint64_t> vtable_idx) {
tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.h
   72       llvm::Optional<uint64_t> vtable_idx = llvm::Optional<uint64_t>());
tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp
  577     llvm::Optional<uint64_t> size;
  659     llvm::Optional<uint64_t> bytes;
  697     llvm::Optional<uint64_t> bytes;
tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp
  585 llvm::Optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
tools/lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h
   75   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
tools/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp
  235 llvm::Optional<SymbolFile::ArrayInfo>
tools/lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h
   64   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
tools/lldb/source/Symbol/ClangASTContext.cpp
 4432       if (Optional<uint64_t> size = element_type.GetByteSize(nullptr))
 4954 Optional<uint64_t>
 5020 llvm::Optional<size_t>
 5502 static Optional<SymbolFile::ArrayInfo>
 6666             Optional<uint64_t> size =
 6699           Optional<uint64_t> size =
 6875           if (Optional<uint64_t> size =
 6899           if (Optional<uint64_t> size =
 6919           if (Optional<uint64_t> size =
 6958         if (Optional<uint64_t> size =
 6995           if (Optional<uint64_t> size =
 7797 Optional<CompilerType::IntegralTemplateArgument>
tools/lldb/source/Symbol/ClangASTImporter.cpp
  927     llvm::Optional<Decl *> D = m_std_handler->Import(From);
tools/lldb/source/Symbol/CompilerType.cpp
  477 llvm::Optional<uint64_t>
  484 llvm::Optional<uint64_t>
  486   if (llvm::Optional<uint64_t> bit_size = GetBitSize(exe_scope))
  491 llvm::Optional<size_t> CompilerType::GetTypeBitAlign(ExecutionContextScope *exe_scope) const {
  678 llvm::Optional<CompilerType::IntegralTemplateArgument>
  792     llvm::Optional<uint64_t> byte_size = GetByteSize(nullptr);
  890     llvm::Optional<uint64_t> bit_width = GetBitSize(nullptr);
tools/lldb/source/Symbol/CxxModuleHandler.cpp
  177 llvm::Optional<Decl *> CxxModuleHandler::tryInstantiateStdTemplate(Decl *d) {
  284 llvm::Optional<Decl *> CxxModuleHandler::Import(Decl *d) {
tools/lldb/source/Symbol/DWARFCallFrameInfo.cpp
  167   if (llvm::Optional<FDEEntryMap::Entry> entry = GetFirstFDEEntryInRange(range))
  194 llvm::Optional<DWARFCallFrameInfo::FDEEntryMap::Entry>
tools/lldb/source/Symbol/PostfixExpression.cpp
   22 static llvm::Optional<BinaryOpNode::OpType>
   37 static llvm::Optional<UnaryOpNode::OpType>
tools/lldb/source/Symbol/Type.cpp
  143            ConstString name, llvm::Optional<uint64_t> byte_size,
  335 llvm::Optional<uint64_t> Type::GetByteSize() {
  350       if (llvm::Optional<uint64_t> size = encoding_type->GetByteSize()) {
  356     if (llvm::Optional<uint64_t> size =
tools/lldb/source/Symbol/TypeSystem.cpp
   35 llvm::Optional<LanguageType> LanguageSet::GetSingularLanguage() {
  136 llvm::Optional<CompilerType::IntegralTemplateArgument>
tools/lldb/source/Symbol/UnwindPlan.cpp
   69 static llvm::Optional<std::pair<lldb::ByteOrder, uint32_t>>
tools/lldb/source/Symbol/UnwindTable.cpp
   86 llvm::Optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr,
tools/lldb/source/Target/Process.cpp
 4564 static llvm::Optional<ExpressionResults>
tools/lldb/source/Target/UnixSignals.cpp
  295 UnixSignals::GetFilteredSignals(llvm::Optional<bool> should_suppress,
  296                                 llvm::Optional<bool> should_stop,
  297                                 llvm::Optional<bool> should_notify) {
tools/lldb/source/Utility/FileSpec.cpp
  331 llvm::Optional<FileSpec::Style> FileSpec::GuessPathStyle(llvm::StringRef absolute_path) {
tools/lldb/source/Utility/Reproducer.cpp
   24                                    llvm::Optional<FileSpec> root) {
   61 Optional<Reproducer> &Reproducer::InstanceImpl() {
   62   static Optional<Reproducer> g_reproducer;
   94 llvm::Error Reproducer::SetCapture(llvm::Optional<FileSpec> root) {
  111 llvm::Error Reproducer::SetReplay(llvm::Optional<FileSpec> root) {
  332 llvm::Optional<std::string> CommandLoader::GetNextFile() {
tools/lldb/source/Utility/SelectHelper.cpp
   85 static void updateMaxFd(llvm::Optional<lldb::socket_t> &vold,
  103   llvm::Optional<lldb::socket_t> max_read_fd;
  104   llvm::Optional<lldb::socket_t> max_write_fd;
  105   llvm::Optional<lldb::socket_t> max_error_fd;
  106   llvm::Optional<lldb::socket_t> max_fd;
tools/lldb/source/Utility/UserIDResolver.cpp
   16 llvm::Optional<llvm::StringRef> UserIDResolver::Get(
   32   llvm::Optional<std::string> DoGetUserName(id_t uid) override {
   36   llvm::Optional<std::string> DoGetGroupName(id_t gid) override {
tools/lldb/tools/driver/Driver.cpp
  778 llvm::Optional<int> InitializeReproducer(opt::InputArgList &input_args) {
tools/lldb/unittests/Language/Highlighting/HighlighterTest.cpp
  101                  llvm::Optional<size_t> cursor = llvm::Optional<size_t>()) {
  131            llvm::Optional<size_t> cursor = llvm::Optional<size_t>()) {
tools/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp
  181   std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
  207   std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
  254     std::future<llvm::Optional<std::vector<ModuleSpec>>> async_result =
tools/lldb/unittests/Process/minidump/MinidumpParserTest.cpp
   73   llvm::Optional<MinidumpParser> parser;
  186   llvm::Optional<LinuxProcStatus> proc_status = parser->GetLinuxProcStatus();
  221   llvm::Optional<lldb::pid_t> pid = parser->GetPid();
  263   llvm::Optional<minidump::Range> range = parser.FindMemoryRange(range_start);
  522   llvm::Optional<lldb::pid_t> pid = misc_info->GetPid();
  529   llvm::Optional<lldb::pid_t> pid = parser->GetPid();
  537   llvm::Optional<lldb::pid_t> pid = parser->GetPid();
tools/lldb/unittests/Symbol/TestLineEntry.cpp
   47   llvm::Optional<TestFile> m_file;
tools/lldb/unittests/TestingSupport/TestUtilities.h
   51   llvm::Optional<std::string> Name;
tools/lldb/unittests/Utility/ProcessInstanceInfoTest.cpp
   19   llvm::Optional<std::string> DoGetUserName(id_t uid) override {
   25   llvm::Optional<std::string> DoGetGroupName(id_t gid) override {
tools/lldb/unittests/Utility/ReproducerInstrumentationTest.cpp
   53 static llvm::Optional<Serializer> g_serializer;
   54 static llvm::Optional<TestingRegistry> g_registry;
tools/lldb/unittests/tools/lldb-server/tests/TestClient.h
   95   llvm::Optional<ProcessInfo> m_process_info;
tools/llvm-cov/CodeCoverage.cpp
  143   Optional<std::pair<std::string, std::string>> PathRemapping;
  479   Optional<StringRef> Redirects[] = {InputPath.str(), OutputPath.str(), {""}};
tools/llvm-cov/SourceCoverageViewHTML.cpp
  531   Optional<StringRef> Color;
tools/llvm-cov/SourceCoverageViewText.cpp
  104   Optional<raw_ostream::Colors> Highlight;
tools/llvm-dwarfdump/llvm-dwarfdump.cpp
  111 static std::array<llvm::Optional<uint64_t>, (unsigned)DIDT_ID_Count>
  329     if (llvm::Optional<uint64_t> Off = Entry.getDIESectionOffset()) {
  338   llvm::Optional<uint64_t> CUOff = Entry.getCUOffset();
  339   llvm::Optional<uint64_t> Off = Entry.getDIEUnitOffset();
  347   if (llvm::Optional<uint64_t> DWOId = CU->getDWOId()) {
tools/llvm-dwp/llvm-dwp.cpp
  165   Optional<uint64_t> Signature = None;
  710   Optional<buffer_ostream> BOS;
tools/llvm-elfabi/ELFObjHandler.cpp
   32   Optional<uint64_t> SONameOffset;
   37   Optional<uint64_t> ElfHash;
   38   Optional<uint64_t> GnuHash;
tools/llvm-exegesis/lib/BenchmarkResult.cpp
  100   Optional<unsigned> getRegNo(StringRef RegName) {
  267     Optional<unsigned> RegNo;
tools/llvm-exegesis/lib/Clustering.cpp
  319     Optional<unsigned> NumOpcodes) {
tools/llvm-exegesis/lib/Clustering.h
   35          Optional<unsigned> NumOpcodes = None);
tools/llvm-ifs/llvm-ifs.cpp
   84   Optional<std::string> Warning;
  168   Optional<std::string> SOName;
tools/llvm-lipo/llvm-lipo.cpp
   91   Optional<StringRef> ArchType;
tools/llvm-mca/Views/InstructionInfoView.cpp
   57     Optional<double> RThroughput =
tools/llvm-nm/llvm-nm.cpp
  688 static Optional<std::string> demangle(StringRef Name, bool StripUnderscore) {
  799       if (Optional<std::string> Opt = demangle(S.Name, MachO))
tools/llvm-objcopy/COFF/Object.h
   89   Optional<size_t> WeakTargetSymbolId;
tools/llvm-objcopy/CopyConfig.h
   78   Optional<SectionFlag> NewFlags;
  149   Optional<elf::ELFCopyConfig> ELF;
  158   Optional<MachineInfo> OutputArch;
  165   Optional<StringRef> BuildIdLinkInput;
  166   Optional<StringRef> BuildIdLinkOutput;
  167   Optional<StringRef> ExtractPartition;
  172   Optional<StringRef> NewSymbolVisibility;
tools/llvm-objcopy/ELF/ELFConfig.h
   34   Optional<uint8_t> NewSymbolVisibility;
tools/llvm-objcopy/ELF/Object.h
  922   Optional<StringRef> ExtractPartition;
  935              Optional<StringRef> ExtractPartition)
  976   Optional<StringRef> ExtractPartition;
  980   explicit ELFReader(Binary *B, Optional<StringRef> ExtractPartition)
tools/llvm-objcopy/MachO/Object.h
  246   Optional<size_t> SymTabCommandIndex;
  248   Optional<size_t> DyLdInfoCommandIndex;
  250   Optional<size_t> DySymTabCommandIndex;
  252   Optional<size_t> DataInCodeCommandIndex;
  254   Optional<size_t> FunctionStartsCommandIndex;
tools/llvm-objdump/llvm-objdump.cpp
  949   Optional<SectionRef> Plt = None;
 1945   Optional<object::SectionRef> ClangASTSection;
 1980   Optional<object::SectionRef> FaultMapSection;
tools/llvm-opt-report/OptReport.cpp
  210     const Optional<remarks::RemarkLocation> &Loc = Remark.Loc;
tools/llvm-pdbutil/DumpOutputStyle.cpp
  437 iterateOneModule(InputFile &File, const Optional<PrintScope> &HeaderScope,
  451                                 const Optional<PrintScope> &HeaderScope,
  479     InputFile &File, const Optional<PrintScope> &HeaderScope,
  660   Optional<PrintScope> Scope;
  705   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
  801     else if (Optional<CVType> T = TpiTypes.tryGetType(UDT.Type)) {
 1622   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI)) {
tools/llvm-pdbutil/ExplainOutputStyle.cpp
  124 Optional<uint32_t> ExplainOutputStyle::getPdbBlockStreamIndex() const {
tools/llvm-pdbutil/ExplainOutputStyle.h
   45   Optional<uint32_t> getPdbBlockStreamIndex() const;
tools/llvm-pdbutil/InputFile.h
  148   Optional<object::section_iterator> SectionIter;
tools/llvm-pdbutil/LinePrinter.h
  106 inline Optional<PrintScope> withLabelWidth(const Optional<PrintScope> &Scope,
  106 inline Optional<PrintScope> withLabelWidth(const Optional<PrintScope> &Scope,
  118   explicit AutoIndent(const Optional<PrintScope> &Scope) {
tools/llvm-pdbutil/PdbYaml.h
   74   Optional<PdbModiStream> Modi;
  101   Optional<MSFHeaders> Headers;
  102   Optional<std::vector<uint32_t>> StreamSizes;
  103   Optional<std::vector<StreamBlockList>> StreamMap;
  104   Optional<PdbInfoStream> PdbStream;
  105   Optional<PdbDbiStream> DbiStream;
  106   Optional<PdbTpiStream> TpiStream;
  107   Optional<PdbTpiStream> IpiStream;
  108   Optional<PdbPublicsStream> PublicsStream;
  110   Optional<std::vector<StringRef>> StringTable;
tools/llvm-pdbutil/StreamUtil.h
   55   Optional<uint32_t> ModuleIndex;
tools/llvm-pdbutil/TypeReferenceTracker.cpp
   25   for (Optional<TypeIndex> TI = Types.getFirst(); TI; TI = Types.getNext(*TI))
  130     Optional<CVType> Rec = (Ids && RefKind == TiRefKind::IndexRef)
tools/llvm-pdbutil/llvm-pdbutil.cpp
  373 llvm::Optional<NumberRange> DumpBlockRange;
  374 llvm::Optional<NumberRange> DumpByteRange;
 1396                        Optional<opts::bytes::NumberRange> &Parsed) {
tools/llvm-pdbutil/llvm-pdbutil.h
  111   llvm::Optional<uint64_t> Max;
  114 extern llvm::Optional<NumberRange> DumpBlockRange;
  115 extern llvm::Optional<NumberRange> DumpByteRange;
tools/llvm-rc/ResourceFileWriter.h
   82     Optional<uint32_t> Style;
   83     Optional<uint32_t> ExStyle;
   92     Optional<FontInfo> Font;
  106       std::array<Optional<StringRef>, 16> Data;
tools/llvm-rc/ResourceScriptParser.cpp
  558   Optional<IntWithNotMask> Style;
  581   Optional<uint32_t> ExStyle;
  586   Optional<uint32_t> HelpID;
tools/llvm-rc/ResourceScriptStmt.h
  611   Optional<IntWithNotMask> Style;
  612   Optional<uint32_t> ExtStyle, HelpID;
  636           Optional<IntWithNotMask> ItemStyle, Optional<uint32_t> ExtItemStyle,
  636           Optional<IntWithNotMask> ItemStyle, Optional<uint32_t> ExtItemStyle,
  637           Optional<uint32_t> CtlHelpID, IntOrString CtlClass)
tools/llvm-readobj/COFFDumper.cpp
 1273       Optional<uint32_t> PCHSignature;
tools/llvm-readobj/ELFDumper.cpp
 2361   Optional<uint64_t> DtPltGot;
 2362   Optional<uint64_t> DtLocalGotNum;
 2363   Optional<uint64_t> DtGotSym;
 2364   Optional<uint64_t> DtMipsPltGot;
 2365   Optional<uint64_t> DtJmpRel;
tools/opt/Debugify.cpp
  187   Optional<uint64_t> DbgVarSize = DVI->getFragmentSizeInBits();
tools/opt/NewPMDriver.cpp
  222   Optional<PGOOptions> P;
tools/polly/include/polly/ScopInfo.h
 1737   Optional<std::string> name;
tools/polly/lib/Analysis/ScopPass.cpp
  118     Optional<PreservedAnalyses> InnerPA;
tools/polly/lib/Exchange/JSONExporter.cpp
  288     Optional<StringRef> Schedule =
unittests/ADT/APIntTest.cpp
 2691           Optional<APInt> S = APIntOps::SolveQuadraticEquationWrap(
unittests/ADT/IteratorTest.cpp
  337     const vector<tuple<Optional<unsigned>, Optional<StringRef>>> expected{
  337     const vector<tuple<Optional<unsigned>, Optional<StringRef>>> expected{
  351     const vector<tuple<Optional<StringRef>, Optional<unsigned>>> expected{
  351     const vector<tuple<Optional<StringRef>, Optional<unsigned>>> expected{
unittests/ADT/OptionalTest.cpp
   20 static_assert(is_trivially_copyable<Optional<int>>::value,
   23 static_assert(is_trivially_copyable<Optional<std::array<int, 3>>>::value,
   56       !is_trivially_copyable<Optional<NonDefaultConstructible>>::value,
   64   Optional<NonDefaultConstructible> O;
   70   Optional<NonDefaultConstructible> O(NonDefaultConstructible(3));
   92     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
   97     Optional<NonDefaultConstructible> B(A);
  111     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
  112     Optional<NonDefaultConstructible> B;
  131     Optional<NonDefaultConstructible> A(NonDefaultConstructible(3));
  132     Optional<NonDefaultConstructible> B(NonDefaultConstructible(4));
  151     Optional<NonDefaultConstructible> A;
  152     Optional<NonDefaultConstructible> B(NonDefaultConstructible(3));
  171     Optional<NonDefaultConstructible> A;
  172     Optional<NonDefaultConstructible> B;
  189   Optional<int> A;
  218   !is_trivially_copyable<Optional<MultiArgConstructor>>::value,
  223   Optional<MultiArgConstructor> A;
  268 static_assert(!is_trivially_copyable<Optional<MoveOnly>>::value,
  273   Optional<MoveOnly> O;
  281   Optional<MoveOnly> O(MoveOnly(3));
  290   Optional<MoveOnly> A(MoveOnly(3));
  292   Optional<MoveOnly> B(std::move(A));
  303   Optional<MoveOnly> O;
  313   Optional<MoveOnly> A(MoveOnly(3));
  314   Optional<MoveOnly> B;
  326   Optional<MoveOnly> A;
  327   Optional<MoveOnly> B(MoveOnly(3));
  338   Optional<MoveOnly> A(MoveOnly(3));
  339   Optional<MoveOnly> B(MoveOnly(4));
  372 static_assert(!is_trivially_copyable<Optional<Immovable>>::value,
  376   Optional<Immovable> A;
  388   Optional<MoveOnly> A;
  443 void CheckRelation(const Optional<T> &Lhs, const Optional<T> &Rhs,
  443 void CheckRelation(const Optional<T> &Lhs, const Optional<T> &Rhs,
  459 const Optional<EqualityMock> NoneEq, EqualityLhs((EqualityMock())),
  492 const Optional<InequalityMock> NoneIneq, InequalityLhs((InequalityMock())),
  556   static Optional<ComparableAndStreamable> get() {
  577   static Optional<Comparable> get() { return Comparable(); }
unittests/ADT/StatisticTest.cpp
   14 using OptionalStatistic = Optional<std::pair<StringRef, unsigned>>;
unittests/Analysis/BasicAliasAnalysisTest.cpp
   54   llvm::Optional<TestAnalyses> Analyses;
unittests/Analysis/LoopInfoTest.cpp
  272         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  330         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  388         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  446         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  504         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  563         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  621         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  676         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  734         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  793         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  852         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  912         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
  972         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
 1024         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
 1081         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
 1151         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
 1176         Optional<Loop::LoopBounds> InnerBounds = L->getBounds(SE);
 1242         Optional<Loop::LoopBounds> Bounds = L->getBounds(SE);
unittests/Analysis/ScalarEvolutionTest.cpp
   61   static Optional<APInt> computeConstantDifference(ScalarEvolution &SE,
unittests/BinaryFormat/DwarfTest.cpp
  143   Optional<uint8_t> RefSize;
  144   Optional<uint8_t> AddrSize;
unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
   83   Optional<APInt> FoldGAddInt =
   88   Optional<APInt> FoldGAddMix =
   95   Optional<APInt> FoldGAndInt =
  100   Optional<APInt> FoldGAndMix =
  107   Optional<APInt> FoldGAShrInt =
  112   Optional<APInt> FoldGAShrMix =
  119   Optional<APInt> FoldGLShrInt =
  124   Optional<APInt> FoldGLShrMix =
  131   Optional<APInt> FoldGMulInt =
  136   Optional<APInt> FoldGMulMix =
  143   Optional<APInt> FoldGOrInt =
  148   Optional<APInt> FoldGOrMix =
  155   Optional<APInt> FoldGShlInt =
  160   Optional<APInt> FoldGShlMix =
  167   Optional<APInt> FoldGSubInt =
  172   Optional<APInt> FoldGSubMix =
  179   Optional<APInt> FoldGXorInt =
  184   Optional<APInt> FoldGXorMix =
  191   Optional<APInt> FoldGUdivInt =
  196   Optional<APInt> FoldGUdivMix =
  203   Optional<APInt> FoldGSdivInt =
  208   Optional<APInt> FoldGSdivMix =
  215   Optional<APInt> FoldGUremInt =
  220   Optional<APInt> FoldGUremMix =
  227   Optional<APInt> FoldGSremInt =
  232   Optional<APInt> FoldGSremMix =
unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
  246   Optional<DWARFFormValue> FormValue;
  248   Optional<ArrayRef<uint8_t>> BlockDataOpt;
  894   Optional<uint64_t> OptU64;
 1058   Optional<DWARFFormValue> Form2 = DieDG.find(Attr2);
 1065   Optional<DWARFFormValue> Form3 = DieDG.find(Attr3);
 1563   Optional<DWARFFormValue> FormValOpt1 = DWARFFormValue();
 1580   Optional<DWARFFormValue> FormValOpt2 =
 1599   Optional<DWARFFormValue> FormValOpt3 =
 1618   Optional<DWARFFormValue> FormValOpt4 =
 1637   Optional<DWARFFormValue> FormValOpt5 =
 1657   Optional<DWARFFormValue> FormValOpt6 =
unittests/DebugInfo/DWARF/DwarfGenerator.h
  217   llvm::Optional<DWARFDebugLine::Prologue> Prologue;
unittests/ExecutionEngine/Orc/CoreAPIsTest.cpp
  124   Optional<MaterializationResponsibility> BazR;
  360   Optional<MaterializationResponsibility> FooR;
  394   Optional<MaterializationResponsibility> FooR;
  395   Optional<MaterializationResponsibility> BarR;
  396   Optional<MaterializationResponsibility> BazR;
  531   Optional<MaterializationResponsibility> FooR;
  532   Optional<MaterializationResponsibility> BarR;
  594   Optional<MaterializationResponsibility> FooR;
  595   Optional<MaterializationResponsibility> BarR;
  658   Optional<MaterializationResponsibility> FooR;
  659   Optional<MaterializationResponsibility> BarR;
  722   Optional<MaterializationResponsibility> FooR;
  723   Optional<MaterializationResponsibility> BarR;
unittests/IR/CFGBuilder.cpp
  129 Optional<CFGBuilder::Update> CFGBuilder::getNextUpdate() const {
  135 Optional<CFGBuilder::Update> CFGBuilder::applyUpdate() {
unittests/IR/CFGBuilder.h
   75   Optional<Update> getNextUpdate() const;
   76   Optional<Update> applyUpdate();
unittests/IR/DominatorTreeTest.cpp
  694   Optional<CFGBuilder::Update> LastUpdate;
  720   Optional<CFGBuilder::Update> LastUpdate = B.applyUpdate();
  748   Optional<CFGBuilder::Update> LastUpdate;
  769   Optional<CFGBuilder::Update> LastUpdate = B.applyUpdate();
  799   Optional<CFGBuilder::Update> LastUpdate;
  829     Optional<CFGBuilder::Update> LastUpdate;
  856   Optional<CFGBuilder::Update> LastUpdate;
  882   Optional<CFGBuilder::Update> LastUpdate;
  912   Optional<CFGBuilder::Update> LastUpdate;
  950     Optional<CFGBuilder::Update> LastUpdate;
unittests/Remarks/BitstreamRemarksSerializerTest.cpp
   36                   StringRef ExpectedR, Optional<StringRef> ExpectedMeta,
   37                   Optional<remarks::StringTable> StrTab) {
   69                   Optional<remarks::StringTable> StrTab = None) {
   75                             Optional<remarks::StringTable> StrTab = None) {
unittests/Remarks/YAMLRemarksParsingTest.cpp
   72                           Optional<StringRef> ExternalFilePrependPath = None) {
unittests/Remarks/YAMLRemarksSerializerTest.cpp
   27                   StringRef ExpectedR, Optional<StringRef> ExpectedMeta,
   28                   Optional<remarks::StringTable> StrTab = None) {
   56                   Optional<remarks::StringTable> StrTab = None) {
   64                             Optional<remarks::StringTable> StrTab = None) {
unittests/Support/FileCheckTest.cpp
   76   Optional<uint64_t> Value = FooVar.getValue();
  244     Optional<FileCheckNumericVariable *> DefinedNumericVariable;
  518   Optional<FileCheckNumericVariable *> DefinedNumericVariable;
unittests/Support/JSONTest.cpp
  273     llvm::Optional<int64_t> AsInt;
  274     llvm::Optional<double> AsNumber;
  330   CustomStruct(std::string S, llvm::Optional<int> I, bool B)
  333   llvm::Optional<int> I;
unittests/Support/NativeFormatTests.cpp
   29                           Optional<size_t> Width = None) {
   38                           Optional<size_t> Precision = None) {
unittests/Support/Path.cpp
 1335   Optional<FileDescriptorCloser> Closer;
 1359   Optional<FileDescriptorCloser> Closer;
 1437     Optional<FileDescriptorCloser> Closer;
unittests/Support/ProgramTest.cpp
  184   Optional<StringRef> redirects[] = { nul, nul, None };
unittests/Support/raw_ostream_test.cpp
  190                                        llvm::Optional<uint64_t> Offset = None,
  201                                                Optional<uint64_t> Offset = None,
usr/include/c++/7.4.0/bits/ptr_traits.h
  141       pointer_to(__make_not_void<element_type>& __r) noexcept
usr/include/c++/7.4.0/future
  766         friend future<__async_result_of<_Fn, _Args...>>
usr/include/c++/7.4.0/tuple
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1468 			tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
utils/TableGen/CodeGenRegisters.cpp
  990 Optional<std::pair<CodeGenRegisterClass *, CodeGenRegisterClass *>>
utils/TableGen/CodeGenRegisters.h
  392     Optional<std::pair<CodeGenRegisterClass *, CodeGenRegisterClass *>>
utils/TableGen/CodeGenSchedule.cpp
  104       Optional<Regex> Regexpr = None;
utils/TableGen/CodeGenTarget.cpp
  300 Optional<CodeGenRegisterClass *>
utils/TableGen/CodeGenTarget.h
  108   Optional<CodeGenRegisterClass *>
utils/TableGen/GlobalISelEmitter.cpp
  187 static Optional<LLTCodeGen> MVTToLLT(MVT::SimpleValueType SVT) {
  445   MatchTableRecord(Optional<unsigned> LabelID_, StringRef EmitStr,
  933   Optional<DefinedComplexPatternSubOperand>
  998   Optional<Kind *> addPredicate(Args &&... args);
 1506   Optional<Kind *> addPredicate(Args &&... args) {
 2061   Optional<Kind *> addPredicate(Args &&... args) {
 2667   Optional<unsigned> SubOperand;
 2676                               Optional<unsigned> SubOperand = None)
 3265   Optional<CodeGenCoverage> RuleCoverage;
 3335   Optional<const CodeGenRegisterClass *>
 3339   Optional<CodeGenSubRegIndex *>
 3344   Optional<const CodeGenRegisterClass *>
 3349   Optional<const CodeGenRegisterClass *>
 3354   Optional<const CodeGenRegisterClass *>
 3579         Optional<LLTCodeGen> MemTyOrNone =
 3985       Optional<LLTCodeGen> OpTyOrNone = None;
 4023     Optional<LLTCodeGen> OpTyOrNone = None;
 4135     Optional<const CodeGenRegisterClass *> SuperClass =
 4354     Optional<LLTCodeGen> OpTyOrNone = None;
 4406 Optional<const CodeGenRegisterClass *>
 4419 Optional<const CodeGenRegisterClass *>
 4476 Optional<const CodeGenRegisterClass *>
 4499 Optional<const CodeGenRegisterClass *>
 4509   if (Optional<const CodeGenRegisterClass *> SuperRegisterClass =
 4515 Optional<CodeGenSubRegIndex *>
utils/TableGen/X86RecognizableInstr.cpp
  726   llvm::Optional<OpcodeType> opcodeType;
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h
   75 struct StreamSwitch<llvm::Optional<T>,
   78   static const RawStreamProxy<llvm::Optional<T>>
   79   printable(const llvm::Optional<T> &V) {