diff options
| author | David Blaikie <dblaikie@gmail.com> | 2013-02-20 22:23:23 +0000 |
|---|---|---|
| committer | David Blaikie <dblaikie@gmail.com> | 2013-02-20 22:23:23 +0000 |
| commit | dc84cd5efdd3430efb22546b4ac656aa0540b210 (patch) | |
| tree | 665bcfc03575e55f8d053acf20ff6d8979b3bd14 | |
| parent | 9e85b29dd17fd3878134216f9abaf5ec4774b2a5 (diff) | |
| download | clang-dc84cd5efdd3430efb22546b4ac656aa0540b210.tar.gz | |
Include llvm::Optional in clang/Basic/LLVM.h
Post-commit CR feedback from Jordan Rose regarding r175594.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@175679 91177308-0d34-0410-b5e6-96231b3b80d8
79 files changed, 374 insertions, 425 deletions
diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h index 1c505295a4..b483535205 100644 --- a/include/clang/AST/ASTContext.h +++ b/include/clang/AST/ASTContext.h @@ -1023,7 +1023,7 @@ public: const TemplateArgument *Args) const; QualType getPackExpansionType(QualType Pattern, - llvm::Optional<unsigned> NumExpansions); + Optional<unsigned> NumExpansions); QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl = 0) const; diff --git a/include/clang/AST/Decl.h b/include/clang/AST/Decl.h index f6c912a38b..614b2762e6 100644 --- a/include/clang/AST/Decl.h +++ b/include/clang/AST/Decl.h @@ -308,7 +308,7 @@ public: /// \brief If visibility was explicitly specified for this /// declaration, return that visibility. - llvm::Optional<Visibility> + Optional<Visibility> getExplicitVisibility(ExplicitVisibilityKind kind) const; /// \brief Clear the linkage cache in response to a change diff --git a/include/clang/AST/ExprCXX.h b/include/clang/AST/ExprCXX.h index 9958218e1a..7665dbce4c 100644 --- a/include/clang/AST/ExprCXX.h +++ b/include/clang/AST/ExprCXX.h @@ -3346,7 +3346,7 @@ class PackExpansionExpr : public Expr { public: PackExpansionExpr(QualType T, Expr *Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions) + Optional<unsigned> NumExpansions) : Expr(PackExpansionExprClass, T, Pattern->getValueKind(), Pattern->getObjectKind(), /*TypeDependent=*/true, /*ValueDependent=*/true, /*InstantiationDependent=*/true, @@ -3369,11 +3369,11 @@ public: /// \brief Determine the number of expansions that will be produced when /// this pack expansion is instantiated, if already known. - llvm::Optional<unsigned> getNumExpansions() const { + Optional<unsigned> getNumExpansions() const { if (NumExpansions) return NumExpansions - 1; - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); } SourceLocation getLocStart() const LLVM_READONLY { diff --git a/include/clang/AST/ExprObjC.h b/include/clang/AST/ExprObjC.h index 798b0423cb..2b88dfdcb2 100644 --- a/include/clang/AST/ExprObjC.h +++ b/include/clang/AST/ExprObjC.h @@ -206,7 +206,7 @@ struct ObjCDictionaryElement { /// \brief The number of elements this pack expansion will expand to, if /// this is a pack expansion and is known. - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; /// \brief Determines whether this dictionary element is a pack expansion. bool isPackExpansion() const { return EllipsisLoc.isValid(); } @@ -301,7 +301,7 @@ public: assert((Index < NumElements) && "Arg access out of range!"); const KeyValuePair &KV = getKeyValues()[Index]; ObjCDictionaryElement Result = { KV.Key, KV.Value, SourceLocation(), - llvm::Optional<unsigned>() }; + Optional<unsigned>() }; if (HasPackExpansions) { const ExpansionData &Expansion = getExpansionData()[Index]; Result.EllipsisLoc = Expansion.EllipsisLoc; diff --git a/include/clang/AST/NSAPI.h b/include/clang/AST/NSAPI.h index 47797d0346..0b21b03348 100644 --- a/include/clang/AST/NSAPI.h +++ b/include/clang/AST/NSAPI.h @@ -52,7 +52,7 @@ public: Selector getNSStringSelector(NSStringMethodKind MK) const; /// \brief Return NSStringMethodKind if \param Sel is such a selector. - llvm::Optional<NSStringMethodKind> getNSStringMethodKind(Selector Sel) const; + Optional<NSStringMethodKind> getNSStringMethodKind(Selector Sel) const; /// \brief Returns true if the expression \param E is a reference of /// "NSUTF8StringEncoding" enum constant. @@ -84,7 +84,7 @@ public: Selector getNSArraySelector(NSArrayMethodKind MK) const; /// \brief Return NSArrayMethodKind if \p Sel is such a selector. - llvm::Optional<NSArrayMethodKind> getNSArrayMethodKind(Selector Sel); + Optional<NSArrayMethodKind> getNSArrayMethodKind(Selector Sel); /// \brief Enumerates the NSDictionary methods used to generate literals. enum NSDictionaryMethodKind { @@ -106,8 +106,7 @@ public: Selector getNSDictionarySelector(NSDictionaryMethodKind MK) const; /// \brief Return NSDictionaryMethodKind if \p Sel is such a selector. - llvm::Optional<NSDictionaryMethodKind> - getNSDictionaryMethodKind(Selector Sel); + Optional<NSDictionaryMethodKind> getNSDictionaryMethodKind(Selector Sel); /// \brief Returns selector for "objectForKeyedSubscript:". Selector getObjectForKeyedSubscriptSelector() const { @@ -171,12 +170,12 @@ public: } /// \brief Return NSNumberLiteralMethodKind if \p Sel is such a selector. - llvm::Optional<NSNumberLiteralMethodKind> + Optional<NSNumberLiteralMethodKind> getNSNumberLiteralMethodKind(Selector Sel) const; /// \brief Determine the appropriate NSNumber factory method kind for a /// literal of the given type. - llvm::Optional<NSNumberLiteralMethodKind> + Optional<NSNumberLiteralMethodKind> getNSNumberFactoryMethodKind(QualType T) const; /// \brief Returns true if \param T is a typedef of "BOOL" in objective-c. diff --git a/include/clang/AST/TemplateBase.h b/include/clang/AST/TemplateBase.h index da57293b08..c2dddf6461 100644 --- a/include/clang/AST/TemplateBase.h +++ b/include/clang/AST/TemplateBase.h @@ -158,7 +158,7 @@ public: /// /// \param NumExpansions The number of expansions that will be generated by /// instantiating - TemplateArgument(TemplateName Name, llvm::Optional<unsigned> NumExpansions) + TemplateArgument(TemplateName Name, Optional<unsigned> NumExpansions) : Kind(TemplateExpansion) { TemplateArg.Name = Name.getAsVoidPointer(); @@ -261,7 +261,7 @@ public: /// \brief Retrieve the number of expansions that a template template argument /// expansion will produce, if known. - llvm::Optional<unsigned> getNumTemplateExpansions() const; + Optional<unsigned> getNumTemplateExpansions() const; /// \brief Retrieve the template argument as an integral value. // FIXME: Provide a way to read the integral data without copying the value. @@ -496,7 +496,7 @@ public: /// \param NumExpansions Will be set to the number of expansions that will /// be generated from this pack expansion, if known a priori. TemplateArgumentLoc getPackExpansionPattern(SourceLocation &Ellipsis, - llvm::Optional<unsigned> &NumExpansions, + Optional<unsigned> &NumExpansions, ASTContext &Context) const; }; diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h index 3e6297aeb8..f0a7ae888d 100644 --- a/include/clang/AST/Type.h +++ b/include/clang/AST/Type.h @@ -4133,7 +4133,7 @@ class PackExpansionType : public Type, public llvm::FoldingSetNode { unsigned NumExpansions; PackExpansionType(QualType Pattern, QualType Canon, - llvm::Optional<unsigned> NumExpansions) + Optional<unsigned> NumExpansions) : Type(PackExpansion, Canon, /*Dependent=*/Pattern->isDependentType(), /*InstantiationDependent=*/true, /*VariableModified=*/Pattern->isVariablyModifiedType(), @@ -4151,11 +4151,11 @@ public: /// \brief Retrieve the number of expansions that this pack expansion will /// generate, if known. - llvm::Optional<unsigned> getNumExpansions() const { + Optional<unsigned> getNumExpansions() const { if (NumExpansions) return NumExpansions - 1; - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); } bool isSugared() const { return false; } @@ -4166,7 +4166,7 @@ public: } static void Profile(llvm::FoldingSetNodeID &ID, QualType Pattern, - llvm::Optional<unsigned> NumExpansions) { + Optional<unsigned> NumExpansions) { ID.AddPointer(Pattern.getAsOpaquePtr()); ID.AddBoolean(NumExpansions); if (NumExpansions) diff --git a/include/clang/Analysis/Analyses/FormatString.h b/include/clang/Analysis/Analyses/FormatString.h index 5cb973122d..4bd989cf4e 100644 --- a/include/clang/Analysis/Analyses/FormatString.h +++ b/include/clang/Analysis/Analyses/FormatString.h @@ -201,7 +201,7 @@ public: bool isPrintfKind() const { return IsPrintf; } - llvm::Optional<ConversionSpecifier> getStandardSpecifier() const; + Optional<ConversionSpecifier> getStandardSpecifier() const; protected: bool IsPrintf; @@ -361,7 +361,7 @@ public: bool hasStandardLengthModifier() const; - llvm::Optional<LengthModifier> getCorrectedLengthModifier() const; + Optional<LengthModifier> getCorrectedLengthModifier() const; bool hasStandardConversionSpecifier(const LangOptions &LangOpt) const; diff --git a/include/clang/Basic/LLVM.h b/include/clang/Basic/LLVM.h index 13c5b445b8..abeec15741 100644 --- a/include/clang/Basic/LLVM.h +++ b/include/clang/Basic/LLVM.h @@ -25,10 +25,11 @@ namespace llvm { class StringRef; class Twine; template<typename T> class ArrayRef; - template<class T> class OwningPtr; + template<typename T> class OwningPtr; template<unsigned InternalLen> class SmallString; template<typename T, unsigned N> class SmallVector; template<typename T> class SmallVectorImpl; + template<typename T> class Optional; template<typename T> struct SaveAndRestore; @@ -53,6 +54,7 @@ namespace clang { using llvm::cast_or_null; // ADT's. + using llvm::Optional; using llvm::StringRef; using llvm::Twine; using llvm::ArrayRef; diff --git a/include/clang/Basic/VersionTuple.h b/include/clang/Basic/VersionTuple.h index a94f76c182..059b7f7239 100644 --- a/include/clang/Basic/VersionTuple.h +++ b/include/clang/Basic/VersionTuple.h @@ -55,16 +55,16 @@ public: unsigned getMajor() const { return Major; } /// \brief Retrieve the minor version number, if provided. - llvm::Optional<unsigned> getMinor() const { + Optional<unsigned> getMinor() const { if (!HasMinor) - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); return Minor; } /// \brief Retrieve the subminor version number, if provided. - llvm::Optional<unsigned> getSubminor() const { + Optional<unsigned> getSubminor() const { if (!HasSubminor) - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); return Subminor; } diff --git a/include/clang/Lex/PreprocessingRecord.h b/include/clang/Lex/PreprocessingRecord.h index 74a430cb77..926da52675 100644 --- a/include/clang/Lex/PreprocessingRecord.h +++ b/include/clang/Lex/PreprocessingRecord.h @@ -277,9 +277,9 @@ namespace clang { /// \brief Optionally returns true or false if the preallocated preprocessed /// entity with index \p Index came from file \p FID. - virtual llvm::Optional<bool> isPreprocessedEntityInFileID(unsigned Index, - FileID FID) { - return llvm::Optional<bool>(); + virtual Optional<bool> isPreprocessedEntityInFileID(unsigned Index, + FileID FID) { + return Optional<bool>(); } }; diff --git a/include/clang/Parse/Parser.h b/include/clang/Parse/Parser.h index c0044cbba0..8e69b64c1a 100644 --- a/include/clang/Parse/Parser.h +++ b/include/clang/Parse/Parser.h @@ -1298,7 +1298,7 @@ private: // [...] () -> type {...} ExprResult ParseLambdaExpression(); ExprResult TryParseLambdaExpression(); - llvm::Optional<unsigned> ParseLambdaIntroducer(LambdaIntroducer &Intro); + Optional<unsigned> ParseLambdaIntroducer(LambdaIntroducer &Intro); bool TryParseLambdaIntroducer(LambdaIntroducer &Intro); ExprResult ParseLambdaExpressionAfterIntroducer( LambdaIntroducer &Intro); diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index 4d37c89edb..2d86787494 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -5335,14 +5335,14 @@ public: /// expansion. TypeSourceInfo *CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions); + Optional<unsigned> NumExpansions); /// \brief Construct a pack expansion type from the pattern of the pack /// expansion. QualType CheckPackExpansion(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions); + Optional<unsigned> NumExpansions); /// \brief Invoked when parsing an expression followed by an ellipsis, which /// creates a pack expansion. @@ -5361,7 +5361,7 @@ public: /// /// \param EllipsisLoc The location of the ellipsis. ExprResult CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions); + Optional<unsigned> NumExpansions); /// \brief Determine whether we could expand a pack expansion with the /// given set of parameter packs into separate arguments by repeatedly @@ -5403,7 +5403,7 @@ public: const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, bool &RetainExpansion, - llvm::Optional<unsigned> &NumExpansions); + Optional<unsigned> &NumExpansions); /// \brief Determine the number of arguments in the given pack expansion /// type. @@ -5412,8 +5412,8 @@ public: /// consistent across all of the unexpanded parameter packs in its pattern. /// /// Returns an empty Optional if the type can't be expanded. - llvm::Optional<unsigned> getNumArgumentsInExpansion(QualType T, - const MultiLevelTemplateArgumentList &TemplateArgs); + Optional<unsigned> getNumArgumentsInExpansion(QualType T, + const MultiLevelTemplateArgumentList &TemplateArgs); /// \brief Determine whether the given declarator contains any unexpanded /// parameter packs. @@ -5898,11 +5898,11 @@ public: /// template argument substitution failures are not considered /// errors. /// - /// \returns An empty \c llvm::Optional if we're not in a SFINAE context. + /// \returns An empty \c Optional if we're not in a SFINAE context. /// Otherwise, contains a pointer that, if non-NULL, contains the nearest /// template-deduction context object, which can be used to capture /// diagnostics that will be suppressed. - llvm::Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const; + Optional<sema::TemplateDeductionInfo *> isSFINAEContext() const; /// \brief Determines whether we are currently in a context that /// is not evaluated as per C++ [expr] p5. @@ -6013,7 +6013,7 @@ public: ParmVarDecl *SubstParmVarDecl(ParmVarDecl *D, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, - llvm::Optional<unsigned> NumExpansions, + Optional<unsigned> NumExpansions, bool ExpectParameterPack); bool SubstParmTypes(SourceLocation Loc, ParmVarDecl **Params, unsigned NumParams, diff --git a/include/clang/Serialization/ASTReader.h b/include/clang/Serialization/ASTReader.h index 68f7720771..df3c74c98f 100644 --- a/include/clang/Serialization/ASTReader.h +++ b/include/clang/Serialization/ASTReader.h @@ -1274,8 +1274,8 @@ public: /// \brief Optionally returns true or false if the preallocated preprocessed /// entity with index \p Index came from file \p FID. - virtual llvm::Optional<bool> isPreprocessedEntityInFileID(unsigned Index, - FileID FID); + virtual Optional<bool> isPreprocessedEntityInFileID(unsigned Index, + FileID FID); /// \brief Read the header file information for the given file entry. virtual HeaderFileInfo GetHeaderFileInfo(const FileEntry *FE); diff --git a/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h b/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h index e1fe082049..0a869e05f3 100644 --- a/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h +++ b/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h @@ -190,38 +190,38 @@ private: CXXInlineableMemberKind CXXMemberInliningMode; /// \sa includeTemporaryDtorsInCFG - llvm::Optional<bool> IncludeTemporaryDtorsInCFG; + Optional<bool> IncludeTemporaryDtorsInCFG; /// \sa mayInlineCXXStandardLibrary - llvm::Optional<bool> InlineCXXStandardLibrary; + Optional<bool> InlineCXXStandardLibrary; /// \sa mayInlineTemplateFunctions - llvm::Optional<bool> InlineTemplateFunctions; + Optional<bool> InlineTemplateFunctions; /// \sa mayInlineObjCMethod - llvm::Optional<bool> ObjCInliningMode; + Optional<bool> ObjCInliningMode; // Cache of the "ipa-always-inline-size" setting. // \sa getAlwaysInlineSize - llvm::Optional<unsigned> AlwaysInlineSize; + Optional<unsigned> AlwaysInlineSize; /// \sa shouldSuppressNullReturnPaths - llvm::Optional<bool> SuppressNullReturnPaths; + Optional<bool> SuppressNullReturnPaths; // \sa getMaxInlinableSize - llvm::Optional<unsigned> MaxInlinableSize; + Optional<unsigned> MaxInlinableSize; /// \sa shouldAvoidSuppressingNullArgumentPaths - llvm::Optional<bool> AvoidSuppressingNullArgumentPaths; + Optional<bool> AvoidSuppressingNullArgumentPaths; /// \sa getGraphTrimInterval - llvm::Optional<unsigned> GraphTrimInterval; + Optional<unsigned> GraphTrimInterval; /// \sa getMaxTimesInlineLarge - llvm::Optional<unsigned> MaxTimesInlineLarge; + Optional<unsigned> MaxTimesInlineLarge; /// \sa getMaxNodesPerTopLevelFunction - llvm::Optional<unsigned> MaxNodesPerTopLevelFunction; + Optional<unsigned> MaxNodesPerTopLevelFunction; /// Interprets an option's string value as a boolean. /// @@ -230,9 +230,8 @@ private: bool getBooleanOption(StringRef Name, bool DefaultVal); /// Variant that accepts a Optional value to cache the result. - bool getBooleanOption(llvm::Optional<bool> &V, StringRef Name, - bool DefaultVal); - + bool getBooleanOption(Optional<bool> &V, StringRef Name, bool DefaultVal); + /// Interprets an option's string value as an integer value. int getOptionAsInteger(StringRef Name, int DefaultVal); diff --git a/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitor.h b/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitor.h index 10fd445b8c..75bf9613e2 100644 --- a/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitor.h +++ b/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitor.h @@ -227,7 +227,7 @@ public: BugReporterContext &BRC, BugReport &R, const ExplodedNode *N, - llvm::Optional<bool> &prunable); + Optional<bool> &prunable); }; /// \brief Suppress reports that might lead to known false positives. diff --git a/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h b/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h index fa02c88387..3f0a1b1bc1 100644 --- a/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h +++ b/include/clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h @@ -461,7 +461,7 @@ public: }; class PathDiagnosticEventPiece : public PathDiagnosticSpotPiece { - llvm::Optional<bool> IsPrunable; + Optional<bool> IsPrunable; /// If the event occurs in a different frame than the final diagnostic, /// supply a message that will be used to construct an extra hint on the diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h b/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h index 3afe5e77b9..1e76ea6ed6 100644 --- a/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h +++ b/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h @@ -28,7 +28,7 @@ namespace ento { class SubEngine; class ConditionTruthVal { - llvm::Optional<bool> Val; + Optional<bool> Val; public: /// Construct a ConditionTruthVal indicating the constraint is constrained /// to either true or false, depending on the boolean value provided. diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h b/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h index c23cc49a21..eab248bac2 100644 --- a/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h +++ b/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h @@ -635,7 +635,7 @@ ProgramState::assume(DefinedOrUnknownSVal Cond) const { } inline ProgramStateRef ProgramState::bindLoc(SVal LV, SVal V) const { - if (llvm::Optional<Loc> L = LV.getAs<Loc>()) + if (Optional<Loc> L = LV.getAs<Loc>()) return bindLoc(*L, V); return this; } @@ -671,7 +671,7 @@ inline SVal ProgramState::getLValue(const IndirectFieldDecl *D, } inline SVal ProgramState::getLValue(QualType ElementType, SVal Idx, SVal Base) const{ - if (llvm::Optional<NonLoc> N = Idx.getAs<NonLoc>()) + if (Optional<NonLoc> N = Idx.getAs<NonLoc>()) return getStateManager().StoreMgr->getLValueElement(ElementType, *N, Base); return UnknownVal(); } diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h b/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h index 9b6dc53ce1..2391d49c73 100644 --- a/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h +++ b/include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h @@ -79,9 +79,9 @@ public: } template<typename T> - llvm::Optional<T> getAs() const { + Optional<T> getAs() const { if (!T::isKind(*this)) - return llvm::Optional<T>(); + return Optional<T>(); T t; SVal& sv = t; sv = *this; diff --git a/lib/ARCMigrate/Internals.h b/lib/ARCMigrate/Internals.h index fac0d23528..3690c83d84 100644 --- a/lib/ARCMigrate/Internals.h +++ b/lib/ARCMigrate/Internals.h @@ -148,7 +148,7 @@ public: TransformActions &TA; const CapturedDiagList &CapturedDiags; std::vector<SourceLocation> &ARCMTMacroLocs; - llvm::Optional<bool> EnableCFBridgeFns; + Optional<bool> EnableCFBridgeFns; MigrationPass(ASTContext &Ctx, LangOptions::GCMode OrigGCMode, Sema &sema, TransformActions &TA, diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index 952162e909..a9df1469fe 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -3234,7 +3234,7 @@ ASTContext::getDependentTemplateSpecializationType( } QualType ASTContext::getPackExpansionType(QualType Pattern, - llvm::Optional<unsigned> NumExpansions) { + Optional<unsigned> NumExpansions) { llvm::FoldingSetNodeID ID; PackExpansionType::Profile(ID, Pattern, NumExpansions); diff --git a/lib/AST/ASTImporter.cpp b/lib/AST/ASTImporter.cpp index 305815ebeb..98ef2378ab 100644 --- a/lib/AST/ASTImporter.cpp +++ b/lib/AST/ASTImporter.cpp @@ -902,14 +902,13 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, /// including the next assigned index (if none of them match). Returns an /// empty option if the context is not a record, i.e.. if the anonymous /// struct/union is at namespace or block scope. -static llvm::Optional<unsigned> -findAnonymousStructOrUnionIndex(RecordDecl *Anon) { +static Optional<unsigned> findAnonymousStructOrUnionIndex(RecordDecl *Anon) { ASTContext &Context = Anon->getASTContext(); QualType AnonTy = Context.getRecordType(Anon); RecordDecl *Owner = dyn_cast<RecordDecl>(Anon->getDeclContext()); if (!Owner) - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); unsigned Index = 0; for (DeclContext::decl_iterator D = Owner->noload_decls_begin(), @@ -944,10 +943,8 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context, if (D1->isAnonymousStructOrUnion() && D2->isAnonymousStructOrUnion()) { // If both anonymous structs/unions are in a record context, make sure // they occur in the same location in the context records. - if (llvm::Optional<unsigned> Index1 - = findAnonymousStructOrUnionIndex(D1)) { - if (llvm::Optional<unsigned> Index2 - = findAnonymousStructOrUnionIndex(D2)) { + if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D1)) { + if (Optional<unsigned> Index2 = findAnonymousStructOrUnionIndex(D2)) { if (*Index1 != *Index2) return false; } @@ -2459,10 +2456,10 @@ Decl *ASTNodeImporter::VisitRecordDecl(RecordDecl *D) { FoundRecord->isAnonymousStructOrUnion()) { // If both anonymous structs/unions are in a record context, make sure // they occur in the same location in the context records. - if (llvm::Optional<unsigned> Index1 + if (Optional<unsigned> Index1 = findAnonymousStructOrUnionIndex(D)) { - if (llvm::Optional<unsigned> Index2 - = findAnonymousStructOrUnionIndex(FoundRecord)) { + if (Optional<unsigned> Index2 = + findAnonymousStructOrUnionIndex(FoundRecord)) { if (*Index1 != *Index2) continue; } diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp index e29c5e3c9b..3ce2f44d2f 100644 --- a/lib/AST/Decl.cpp +++ b/lib/AST/Decl.cpp @@ -121,8 +121,8 @@ withExplicitVisibilityAlready(LVComputationKind oldKind) { return newKind; } -static llvm::Optional<Visibility> getExplicitVisibility(const NamedDecl *D, - LVComputationKind kind) { +static Optional<Visibility> getExplicitVisibility(const NamedDecl *D, + LVComputationKind kind) { assert(!hasExplicitVisibilityAlready(kind) && "asking for explicit visibility when we shouldn't be"); return D->getExplicitVisibility((NamedDecl::ExplicitVisibilityKind) kind); @@ -154,7 +154,7 @@ static Visibility getVisibilityFromAttr(const T *attr) { } /// Return the explicit visibility of the given declaration. -static llvm::Optional<Visibility> getVisibilityOf(const NamedDecl *D, +static Optional<Visibility> getVisibilityOf(const NamedDecl *D, NamedDecl::ExplicitVisibilityKind kind) { // If we're ultimately computing the visibility of a type, look for // a 'type_visibility' attribute before looking for 'visibility'. @@ -180,7 +180,7 @@ static llvm::Optional<Visibility> getVisibilityOf(const NamedDecl *D, return DefaultVisibility; } - return llvm::Optional<Visibility>(); + return Optional<Visibility>(); } static LinkageInfo getLVForType(QualType T) { @@ -517,8 +517,7 @@ static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D, LinkageInfo LV; if (!hasExplicitVisibilityAlready(computation)) { - if (llvm::Optional<Visibility> Vis - = getExplicitVisibility(D, computation)) { + if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) { LV.mergeVisibility(*Vis, true); } else { // If we're declared in a namespace with a visibility attribute, @@ -528,8 +527,7 @@ static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D, DC = DC->getParent()) { const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC); if (!ND) continue; - if (llvm::Optional<Visibility> Vis - = getExplicitVisibility(ND, computation)) { + if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) { LV.mergeVisibility(*Vis, true); break; } @@ -702,8 +700,7 @@ static LinkageInfo getLVForClassMember(const NamedDecl *D, // If we have an explicit visibility attribute, merge that in. if (!hasExplicitVisibilityAlready(computation)) { - if (llvm::Optional<Visibility> Vis - = getExplicitVisibility(D, computation)) + if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) LV.mergeVisibility(*Vis, true); // If we're paying attention to global visibility, apply // -finline-visibility-hidden if this is an inline method. @@ -883,11 +880,11 @@ void NamedDecl::verifyLinkage() const { assert(!D || D->CachedLinkage == CachedLinkage); } -llvm::Optional<Visibility> +Optional<Visibility> NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const { // Use the most recent declaration of a variable. if (const VarDecl *Var = dyn_cast<VarDecl>(this)) { - if (llvm::Optional<Visibility> V = getVisibilityOf(Var, kind)) + if (Optional<Visibility> V = getVisibilityOf(Var, kind)) return V; if (Var->isStaticDataMember()) { @@ -896,12 +893,12 @@ NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const { return getVisibilityOf(InstantiatedFrom, kind); } - return llvm::Optional<Visibility>(); + return Optional<Visibility>(); } // Use the most recent declaration of a function, and also handle // function template specializations. if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(this)) { - if (llvm::Optional<Visibility> V = getVisibilityOf(fn, kind)) + if (Optional<Visibility> V = getVisibilityOf(fn, kind)) return V; // If the function is a specialization of a template with an @@ -917,11 +914,11 @@ NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const { if (InstantiatedFrom) return getVisibilityOf(InstantiatedFrom, kind); - return llvm::Optional<Visibility>(); + return Optional<Visibility>(); } // Otherwise, just check the declaration itself first. - if (llvm::Optional<Visibility> V = getVisibilityOf(this, kind)) + if (Optional<Visibility> V = getVisibilityOf(this, kind)) return V; // The visibility of a template is stored in the templated decl. @@ -944,7 +941,7 @@ NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const { return getVisibilityOf(InstantiatedFrom, kind); } - return llvm::Optional<Visibility>(); + return Optional<Visibility>(); } static LinkageInfo getLVForLocalDecl(const NamedDecl *D, @@ -960,8 +957,8 @@ static LinkageInfo getLVForLocalDecl(const NamedDecl *D, LinkageInfo LV; if (!hasExplicitVisibilityAlready(computation)) { - if (llvm::Optional<Visibility> Vis - = getExplicitVisibility(Function, computation)) + if (Optional<Visibility> Vis = + getExplicitVisibility(Function, computation)) LV.mergeVisibility(*Vis, true); } @@ -987,8 +984,7 @@ static LinkageInfo getLVForLocalDecl(const NamedDecl *D, if (Var->getStorageClass() == SC_PrivateExtern) LV.mergeVisibility(HiddenVisibility, true); else if (!hasExplicitVisibilityAlready(computation)) { - if (llvm::Optional<Visibility> Vis - = getExplicitVisibility(Var, computation)) + if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation)) LV.mergeVisibility(*Vis, true); } diff --git a/lib/AST/DeclTemplate.cpp b/lib/AST/DeclTemplate.cpp index c262e3ff88..49ef5a39a6 100644 --- a/lib/AST/DeclTemplate.cpp +++ b/lib/AST/DeclTemplate.cpp @@ -184,9 +184,8 @@ static void GenerateInjectedTemplateArgs(ASTContext &Context, if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) { QualType ArgType = Context.getTypeDeclType(TTP); if (TTP->isParameterPack()) - ArgType = Context.getPackExpansionType(ArgType, - llvm::Optional<unsigned>()); - + ArgType = Context.getPackExpansionType(ArgType, Optional<unsigned>()); + Arg = TemplateArgument(ArgType); } else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*Param)) { @@ -196,14 +195,13 @@ static void GenerateInjectedTemplateArgs(ASTContext &Context, NTTP->getLocation()); if (NTTP->isParameterPack()) - E = new (Context) PackExpansionExpr(Context.DependentTy, E, - NTTP->getLocation(), - llvm::Optional<unsigned>()); + E = new (Context) PackExpansionExpr( + Context.DependentTy, E, NTTP->getLocation(), Optional<unsigned>()); Arg = TemplateArgument(E); } else { TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*Param); if (TTP->isParameterPack()) - Arg = TemplateArgument(TemplateName(TTP), llvm::Optional<unsigned>()); + Arg = TemplateArgument(TemplateName(TTP), Optional<unsigned>()); else Arg = TemplateArgument(TemplateName(TTP)); } diff --git a/lib/AST/NSAPI.cpp b/lib/AST/NSAPI.cpp index 4c20235ed8..b06769e43c 100644 --- a/lib/AST/NSAPI.cpp +++ b/lib/AST/NSAPI.cpp @@ -67,7 +67,7 @@ Selector NSAPI::getNSStringSelector(NSStringMethodKind MK) const { return NSStringSelectors[MK]; } -llvm::Optional<NSAPI::NSStringMethodKind> +Optional<NSAPI::NSStringMethodKind> NSAPI::getNSStringMethodKind(Selector Sel) const { for (unsigned i = 0; i != NumNSStringMethods; ++i) { NSStringMethodKind MK = NSStringMethodKind(i); @@ -75,7 +75,7 @@ NSAPI::getNSStringMethodKind(Selector Sel) const { return MK; } - return llvm::Optional<NSStringMethodKind>(); + return Optional<NSStringMethodKind>(); } Selector NSAPI::getNSArraySelector(NSArrayMethodKind MK) const { @@ -126,15 +126,14 @@ Selector NSAPI::getNSArraySelector(NSArrayMethodKind MK) const { return NSArraySelectors[MK]; } -llvm::Optional<NSAPI::NSArrayMethodKind> -NSAPI::getNSArrayMethodKind(Selector Sel) { +Optional<NSAPI::NSArrayMethodKind> NSAPI::getNSArrayMethodKind(Selector Sel) { for (unsigned i = 0; i != NumNSArrayMethods; ++i) { NSArrayMethodKind MK = NSArrayMethodKind(i); if (Sel == getNSArraySelector(MK)) return MK; } - return llvm::Optional<NSArrayMethodKind>(); + return Optional<NSArrayMethodKind>(); } Selector NSAPI::getNSDictionarySelector( @@ -212,7 +211,7 @@ Selector NSAPI::getNSDictionarySelector( return NSDictionarySelectors[MK]; } -llvm::Optional<NSAPI::NSDictionaryMethodKind> +Optional<NSAPI::NSDictionaryMethodKind> NSAPI::getNSDictionaryMethodKind(Selector Sel) { for (unsigned i = 0; i != NumNSDictionaryMethods; ++i) { NSDictionaryMethodKind MK = NSDictionaryMethodKind(i); @@ -220,7 +219,7 @@ NSAPI::getNSDictionaryMethodKind(Selector Sel) { return MK; } - return llvm::Optional<NSDictionaryMethodKind>(); + return Optional<NSDictionaryMethodKind>(); } Selector NSAPI::getNSNumberLiteralSelector(NSNumberLiteralMethodKind MK, @@ -275,7 +274,7 @@ Selector NSAPI::getNSNumberLiteralSelector(NSNumberLiteralMethodKind MK, return Sels[MK]; } -llvm::Optional<NSAPI::NSNumberLiteralMethodKind> +Optional<NSAPI::NSNumberLiteralMethodKind> NSAPI::getNSNumberLiteralMethodKind(Selector Sel) const { for (unsigned i = 0; i != NumNSNumberLiteralMethods; ++i) { NSNumberLiteralMethodKind MK = NSNumberLiteralMethodKind(i); @@ -283,14 +282,14 @@ NSAPI::getNSNumberLiteralMethodKind(Selector Sel) const { return MK; } - return llvm::Optional<NSNumberLiteralMethodKind>(); + return Optional<NSNumberLiteralMethodKind>(); } -llvm::Optional<NSAPI::NSNumberLiteralMethodKind> +Optional<NSAPI::NSNumberLiteralMethodKind> NSAPI::getNSNumberFactoryMethodKind(QualType T) const { const BuiltinType *BT = T->getAs<BuiltinType>(); if (!BT) - return llvm::Optional<NSAPI::NSNumberLiteralMethodKind>(); + return Optional<NSAPI::NSNumberLiteralMethodKind>(); const TypedefType *TDT = T->getAs<TypedefType>(); if (TDT) { @@ -364,7 +363,7 @@ NSAPI::getNSNumberFactoryMethodKind(QualType T) const { break; } - return llvm::Optional<NSAPI::NSNumberLiteralMethodKind>(); + return Optional<NSAPI::NSNumberLiteralMethodKind>(); } /// \brief Returns true if \param T is a typedef of "BOOL" in objective-c. diff --git a/lib/AST/TemplateBase.cpp b/lib/AST/TemplateBase.cpp index f1b5e4b0b8..520ca2587d 100644 --- a/lib/AST/TemplateBase.cpp +++ b/lib/AST/TemplateBase.cpp @@ -224,12 +224,12 @@ bool TemplateArgument::containsUnexpandedParameterPack() const { return false; } -llvm::Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const { +Optional<unsigned> TemplateArgument::getNumTemplateExpansions() const { assert(Kind == TemplateExpansion); if (TemplateArg.NumExpansions) return TemplateArg.NumExpansions - 1; - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); } void TemplateArgument::Profile(llvm::FoldingSetNodeID &ID, @@ -451,10 +451,9 @@ SourceRange TemplateArgumentLoc::getSourceRange() const { llvm_unreachable("Invalid TemplateArgument Kind!"); } -TemplateArgumentLoc -TemplateArgumentLoc::getPackExpansionPattern(SourceLocation &Ellipsis, - llvm::Optional<unsigned> &NumExpansions, - ASTContext &Context) const { +TemplateArgumentLoc TemplateArgumentLoc::getPackExpansionPattern( + SourceLocation &Ellipsis, Optional<unsigned> &NumExpansions, + ASTContext &Context) const { assert(Argument.isPackExpansion()); switch (Argument.getKind()) { diff --git a/lib/Analysis/BodyFarm.cpp b/lib/Analysis/BodyFarm.cpp index 277996091c..dda26bfab8 100644 --- a/lib/Analysis/BodyFarm.cpp +++ b/lib/Analysis/BodyFarm.cpp @@ -344,7 +344,7 @@ static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D) Stmt *BodyFarm::getBody(const FunctionDecl *D) { D = D->getCanonicalDecl(); - llvm::Optional<Stmt *> &Val = Bodies[D]; + Optional<Stmt *> &Val = Bodies[D]; if (Val.hasValue()) return Val.getValue(); diff --git a/lib/Analysis/BodyFarm.h b/lib/Analysis/BodyFarm.h index 72752aa9af..96f61df40d 100644 --- a/lib/Analysis/BodyFarm.h +++ b/lib/Analysis/BodyFarm.h @@ -15,6 +15,7 @@ #ifndef LLVM_CLANG_ANALYSIS_BODYFARM_H #define LLVM_CLANG_ANALYSIS_BODYFARM_H +#include "clang/Basic/LLVM.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/Optional.h" @@ -33,7 +34,7 @@ public: Stmt *getBody(const FunctionDecl *D); private: - typedef llvm::DenseMap<const Decl *, llvm::Optional<Stmt *> > BodyMap; + typedef llvm::DenseMap<const Decl *, Optional<Stmt *> > BodyMap; ASTContext &C; BodyMap Bodies; diff --git a/lib/Analysis/FormatString.cpp b/lib/Analysis/FormatString.cpp index 4b18d8ea91..10bb9f30ea 100644 --- a/lib/Analysis/FormatString.cpp +++ b/lib/Analysis/FormatString.cpp @@ -527,13 +527,13 @@ const char *ConversionSpecifier::toString() const { return NULL; } -llvm::Optional<ConversionSpecifier> +Optional<ConversionSpecifier> ConversionSpecifier::getStandardSpecifier() const { ConversionSpecifier::Kind NewKind; switch (getKind()) { default: - return llvm::Optional<ConversionSpecifier>(); + return Optional<ConversionSpecifier>(); case DArg: NewKind = dArg; break; @@ -756,8 +756,7 @@ bool FormatSpecifier::hasStandardLengthConversionCombination() const { return true; } -llvm::Optional<LengthModifier> -FormatSpecifier::getCorrectedLengthModifier() const { +Optional<LengthModifier> FormatSpecifier::getCorrectedLengthModifier() const { if (CS.isAnyIntArg() || CS.getKind() == ConversionSpecifier::nArg) { if (LM.getKind() == LengthModifier::AsLongDouble || LM.getKind() == LengthModifier::AsQuad) { @@ -767,7 +766,7 @@ FormatSpecifier::getCorrectedLengthModifier() const { } } - return llvm::Optional<LengthModifier>(); + return Optional<LengthModifier>(); } bool FormatSpecifier::namedTypeToLengthModifier(QualType QT, diff --git a/lib/Analysis/UninitializedValues.cpp b/lib/Analysis/UninitializedValues.cpp index 0eb96dc925..cf2533c0ed 100644 --- a/lib/Analysis/UninitializedValues.cpp +++ b/lib/Analysis/UninitializedValues.cpp @@ -59,7 +59,7 @@ public: unsigned size() const { return map.size(); } /// Returns the bit vector index for a given declaration. - llvm::Optional<unsigned> getValueIndex(const VarDecl *d) const; + Optional<unsigned> getValueIndex(const VarDecl *d) const; }; } @@ -74,10 +74,10 @@ void DeclToIndex::computeMap(const DeclContext &dc) { } } -llvm::Optional<unsigned> DeclToIndex::getValueIndex(const VarDecl *d) const { +Optional<unsigned> DeclToIndex::getValueIndex(const VarDecl *d) const { llvm::DenseMap<const VarDecl *, unsigned>::const_iterator I = map.find(d); if (I == map.end()) - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); return I->second; } @@ -132,7 +132,7 @@ public: Value getValue(const CFGBlock *block, const CFGBlock *dstBlock, const VarDecl *vd) { - const llvm::Optional<unsigned> &idx = declToIndex.getValueIndex(vd); + const Optional<unsigned> &idx = declToIndex.getValueIndex(vd); assert(idx.hasValue()); return getValueVector(block)[idx.getValue()]; } @@ -193,7 +193,7 @@ void CFGBlockValues::resetScratch() { } ValueVector::reference CFGBlockValues::operator[](const VarDecl *vd) { - const llvm::Optional<unsigned> &idx = declToIndex.getValueIndex(vd); + const Optional<unsigned> &idx = declToIndex.getValueIndex(vd); assert(idx.hasValue()); return scratch[idx.getValue()]; } diff --git a/lib/Basic/SourceManager.cpp b/lib/Basic/SourceManager.cpp index 691019152c..550e82c428 100644 --- a/lib/Basic/SourceManager.cpp +++ b/lib/Basic/SourceManager.cpp @@ -1460,13 +1460,13 @@ unsigned SourceManager::getFileIDSize(FileID FID) const { /// /// This routine involves a system call, and therefore should only be used /// in non-performance-critical code. -static llvm::Optional<ino_t> getActualFileInode(const FileEntry *File) { +static Optional<ino_t> getActualFileInode(const FileEntry *File) { if (!File) - return llvm::Optional<ino_t>(); + return Optional<ino_t>(); struct stat StatBuf; if (::stat(File->getName(), &StatBuf)) - return llvm::Optional<ino_t>(); + return Optional<ino_t>(); return StatBuf.st_ino; } @@ -1497,8 +1497,8 @@ FileID SourceManager::translateFile(const FileEntry *SourceFile) const { // First, check the main file ID, since it is common to look for a // location in the main file. - llvm::Optional<ino_t> SourceFileInode; - llvm::Optional<StringRef> SourceFileName; + Optional<ino_t> SourceFileInode; + Optional<StringRef> SourceFileName; if (!MainFileID.isInvalid()) { bool Invalid = false; const SLocEntry &MainSLoc = getSLocEntry(MainFileID, &Invalid); @@ -1520,8 +1520,7 @@ FileID SourceManager::translateFile(const FileEntry *SourceFile) const { if (*SourceFileName == llvm::sys::path::filename(MainFile->getName())) { SourceFileInode = getActualFileInode(SourceFile); if (SourceFileInode) { - if (llvm::Optional<ino_t> MainFileInode - = getActualFileInode(MainFile)) { + if (Optional<ino_t> MainFileInode = getActualFileInode(MainFile)) { if (*SourceFileInode == *MainFileInode) { FirstFID = MainFileID; SourceFile = MainFile; @@ -1585,7 +1584,7 @@ FileID SourceManager::translateFile(const FileEntry *SourceFile) const { const FileEntry *Entry =FileContentCache? FileContentCache->OrigEntry : 0; if (Entry && *SourceFileName == llvm::sys::path::filename(Entry->getName())) { - if (llvm::Optional<ino_t> EntryInode = getActualFileInode(Entry)) { + if (Optional<ino_t> EntryInode = getActualFileInode(Entry)) { if (*SourceFileInode == *EntryInode) { FirstFID = FileID::get(I); SourceFile = Entry; diff --git a/lib/Basic/VersionTuple.cpp b/lib/Basic/VersionTuple.cpp index 4f479d00d6..8b781ab0a3 100644 --- a/lib/Basic/VersionTuple.cpp +++ b/lib/Basic/VersionTuple.cpp @@ -28,9 +28,9 @@ std::string VersionTuple::getAsString() const { raw_ostream& clang::operator<<(raw_ostream &Out, const VersionTuple &V) { Out << V.getMajor(); - if (llvm::Optional<unsigned> Minor = V.getMinor()) + if (Optional<unsigned> Minor = V.getMinor()) Out << '.' << *Minor; - if (llvm::Optional<unsigned> Subminor = V.getSubminor()) + if (Optional<unsigned> Subminor = V.getSubminor()) Out << '.' << *Subminor; return Out; } diff --git a/lib/Edit/RewriteObjCFoundationAPI.cpp b/lib/Edit/RewriteObjCFoundationAPI.cpp index e04168fc40..f4206fbd8f 100644 --- a/lib/Edit/RewriteObjCFoundationAPI.cpp +++ b/lib/Edit/RewriteObjCFoundationAPI.cpp @@ -693,7 +693,7 @@ static bool getLiteralInfo(SourceRange literalRange, if (text.empty()) return false; - llvm::Optional<bool> UpperU, UpperL; + Optional<bool> UpperU, UpperL; bool UpperF = false; struct Suff { @@ -777,7 +777,7 @@ static bool rewriteToNumberLiteral(const ObjCMessageExpr *Msg, ASTContext &Ctx = NS.getASTContext(); Selector Sel = Msg->getSelector(); - llvm::Optional<NSAPI::NSNumberLiteralMethodKind> + Optional<NSAPI::NSNumberLiteralMethodKind> MKOpt = NS.getNSNumberLiteralMethodKind(Sel); if (!MKOpt) return false; @@ -981,7 +981,7 @@ static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg, ASTContext &Ctx = NS.getASTContext(); Selector Sel = Msg->getSelector(); - llvm::Optional<NSAPI::NSNumberLiteralMethodKind> + Optional<NSAPI::NSNumberLiteralMethodKind> MKOpt = NS.getNSNumberLiteralMethodKind(Sel); if (!MKOpt) return false; diff --git a/lib/Lex/PreprocessingRecord.cpp b/lib/Lex/PreprocessingRecord.cpp index c2a340cae7..ac0985be84 100644 --- a/lib/Lex/PreprocessingRecord.cpp +++ b/lib/Lex/PreprocessingRecord.cpp @@ -103,8 +103,8 @@ bool PreprocessingRecord::isEntityInFileID(iterator PPEI, FileID FID) { // See if the external source can see if the entity is in the file without // deserializing it. - llvm::Optional<bool> - IsInFile = ExternalSource->isPreprocessedEntityInFileID(LoadedIndex, FID); + Optional<bool> IsInFile = + ExternalSource->isPreprocessedEntityInFileID(LoadedIndex, FID); if (IsInFile.hasValue()) return IsInFile.getValue(); diff --git a/lib/Parse/ParseExprCXX.cpp b/lib/Parse/ParseExprCXX.cpp index 0a1111e358..f72e68e2a1 100644 --- a/lib/Parse/ParseExprCXX.cpp +++ b/lib/Parse/ParseExprCXX.cpp @@ -602,7 +602,7 @@ ExprResult Parser::ParseLambdaExpression() { // Parse lambda-introducer. LambdaIntroducer Intro; - llvm::Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro)); + Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro)); if (DiagID) { Diag(Tok, DiagID.getValue()); SkipUntil(tok::r_square); @@ -658,8 +658,8 @@ ExprResult Parser::TryParseLambdaExpression() { /// ParseLambdaExpression - Parse a lambda introducer. /// /// Returns a DiagnosticID if it hit something unexpected. -llvm::Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro){ - typedef llvm::Optional<unsigned> DiagResult; +Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro) { + typedef Optional<unsigned> DiagResult; assert(Tok.is(tok::l_square) && "Lambda expressions begin with '['."); BalancedDelimiterTracker T(*this, tok::l_square); @@ -769,7 +769,7 @@ llvm::Optional<unsigned> Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro){ bool Parser::TryParseLambdaIntroducer(LambdaIntroducer &Intro) { TentativeParsingAction PA(*this); - llvm::Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro)); + Optional<unsigned> DiagID(ParseLambdaIntroducer(Intro)); if (DiagID) { PA.Revert(); diff --git a/lib/Parse/ParseObjc.cpp b/lib/Parse/ParseObjc.cpp index ec4fd821d9..27eeb0545f 100644 --- a/lib/Parse/ParseObjc.cpp +++ b/lib/Parse/ParseObjc.cpp @@ -2730,7 +2730,7 @@ ExprResult Parser::ParseObjCDictionaryLiteral(SourceLocation AtLoc) { // We have a valid expression. Collect it in a vector so we can // build the argument list. ObjCDictionaryElement Element = { - KeyExpr.get(), ValueExpr.get(), EllipsisLoc, llvm::Optional<unsigned>() + KeyExpr.get(), ValueExpr.get(), EllipsisLoc, Optional<unsigned>() }; Elements.push_back(Element); diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp index a52d1f2751..8c79d822cf 100644 --- a/lib/Sema/Sema.cpp +++ b/lib/Sema/Sema.cpp @@ -838,7 +838,7 @@ void Sema::EmitCurrentDiagnostic(unsigned DiagID) { // eliminnated. If it truly cannot be (for example, there is some reentrancy // issue I am not seeing yet), then there should at least be a clarifying // comment somewhere. - if (llvm::Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) { + if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) { switch (DiagnosticIDs::getDiagnosticSFINAEResponse( Diags.getCurrentDiagID())) { case DiagnosticIDs::SFINAE_Report: diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp index f3a290cb8d..e0585df9e5 100644 --- a/lib/Sema/SemaChecking.cpp +++ b/lib/Sema/SemaChecking.cpp @@ -2080,7 +2080,7 @@ void CheckFormatHandler::HandleInvalidLengthModifier( CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength()); // See if we know how to fix this length modifier. - llvm::Optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier(); + Optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier(); if (FixedLM) { EmitFormatDiagnostic(S.PDiag(DiagID) << LM.toString() << CS.toString(), getLocationOfByte(LM.getStart()), @@ -2113,7 +2113,7 @@ void CheckFormatHandler::HandleNonStandardLengthModifier( CharSourceRange LMRange = getSpecifierRange(LM.getStart(), LM.getLength()); // See if we know how to fix this length modifier. - llvm::Optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier(); + Optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier(); if (FixedLM) { EmitFormatDiagnostic(S.PDiag(diag::warn_format_non_standard) << LM.toString() << 0, @@ -2140,7 +2140,7 @@ void CheckFormatHandler::HandleNonStandardConversionSpecifier( using namespace analyze_format_string; // See if we know how to fix this conversion specifier. - llvm::Optional<ConversionSpecifier> FixedCS = CS.getStandardSpecifier(); + Optional<ConversionSpecifier> FixedCS = CS.getStandardSpecifier(); if (FixedCS) { EmitFormatDiagnostic(S.PDiag(diag::warn_format_non_standard) << CS.toString() << /*conversion specifier*/1, diff --git a/lib/Sema/SemaExprObjC.cpp b/lib/Sema/SemaExprObjC.cpp index 76ee983712..c0df31868a 100644 --- a/lib/Sema/SemaExprObjC.cpp +++ b/lib/Sema/SemaExprObjC.cpp @@ -170,9 +170,9 @@ static ObjCMethodDecl *getNSNumberFactoryMethod(Sema &S, SourceLocation Loc, QualType NumberType, bool isLiteral = false, SourceRange R = SourceRange()) { - llvm::Optional<NSAPI::NSNumberLiteralMethodKind> Kind - = S.NSAPIObj->getNSNumberFactoryMethodKind(NumberType); - + Optional<NSAPI::NSNumberLiteralMethodKind> Kind = + S.NSAPIObj->getNSNumberFactoryMethodKind(NumberType); + if (!Kind) { if (isLiteral) { S.Diag(Loc, diag::err_invalid_nsnumber_type) diff --git a/lib/Sema/SemaTemplate.cpp b/lib/Sema/SemaTemplate.cpp index 74a6da1947..c3e3149cf9 100644 --- a/lib/Sema/SemaTemplate.cpp +++ b/lib/Sema/SemaTemplate.cpp @@ -510,7 +510,7 @@ static TemplateArgumentLoc translateTemplateArgument(Sema &SemaRef, TemplateName Template = Arg.getAsTemplate().get(); TemplateArgument TArg; if (Arg.getEllipsisLoc().isValid()) - TArg = TemplateArgument(Template, llvm::Optional<unsigned int>()); + TArg = TemplateArgument(Template, Optional<unsigned int>()); else TArg = Template; return TemplateArgumentLoc(TArg, @@ -3023,7 +3023,7 @@ static bool diagnoseArityMismatch(Sema &S, TemplateDecl *Template, /// /// In \c A<int,int>::B, \c NTs and \c TTs have expanded pack size 2, and \c Us /// is not a pack expansion, so returns an empty Optional. -static llvm::Optional<unsigned> getExpandedPackSize(NamedDecl *Param) { +static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) { if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) { if (NTTP->isExpandedParameterPack()) @@ -3036,7 +3036,7 @@ static llvm::Optional<unsigned> getExpandedPackSize(NamedDecl *Param) { return TTP->getNumExpansionTemplateParameters(); } - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); } /// \brief Check that the given template argument list is well-formed @@ -3068,7 +3068,7 @@ bool Sema::CheckTemplateArgumentList(TemplateDecl *Template, Param != ParamEnd; /* increment in loop */) { // If we have an expanded parameter pack, make sure we don't have too // many arguments. - if (llvm::Optional<unsigned> Expansions = getExpandedPackSize(*Param)) { + if (Optional<unsigned> Expansions = getExpandedPackSize(*Param)) { if (*Expansions == ArgumentPack.size()) { // We're done with this parameter pack. Pack up its arguments and add // them to the list. diff --git a/lib/Sema/SemaTemplateInstantiate.cpp b/lib/Sema/SemaTemplateInstantiate.cpp index 7363bc0fd9..bbf2a98441 100644 --- a/lib/Sema/SemaTemplateInstantiate.cpp +++ b/lib/Sema/SemaTemplateInstantiate.cpp @@ -608,9 +608,9 @@ void Sema::PrintInstantiationStack() { } } -llvm::Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const { +Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const { if (InNonInstantiationSFINAEContext) - return llvm::Optional<TemplateDeductionInfo *>(0); + return Optional<TemplateDeductionInfo *>(0); for (SmallVector<ActiveTemplateInstantiation, 16>::const_reverse_iterator Active = ActiveTemplateInstantiations.rbegin(), @@ -628,7 +628,7 @@ llvm::Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const { case ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation: case ActiveTemplateInstantiation::ExceptionSpecInstantiation: // This is a template instantiation, so there is no SFINAE. - return llvm::Optional<TemplateDeductionInfo *>(); + return Optional<TemplateDeductionInfo *>(); case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: case ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution: @@ -647,7 +647,7 @@ llvm::Optional<TemplateDeductionInfo *> Sema::isSFINAEContext() const { } } - return llvm::Optional<TemplateDeductionInfo *>(); + return Optional<TemplateDeductionInfo *>(); } /// \brief Retrieve the depth and index of a parameter pack. @@ -707,7 +707,7 @@ namespace { llvm::ArrayRef<UnexpandedParameterPack> Unexpanded, bool &ShouldExpand, bool &RetainExpansion, - llvm::Optional<unsigned> &NumExpansions) { + Optional<unsigned> &NumExpansions) { return getSema().CheckParameterPacksForExpansion(EllipsisLoc, PatternRange, Unexpanded, TemplateArgs, @@ -827,7 +827,7 @@ namespace { ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment, - llvm::Optional<unsigned> NumExpansions, + Optional<unsigned> NumExpansions, bool ExpectParameterPack); /// \brief Transforms a template type parameter type by performing @@ -1363,7 +1363,7 @@ QualType TemplateInstantiator::TransformFunctionProtoType(TypeLocBuilder &TLB, ParmVarDecl * TemplateInstantiator::TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment, - llvm::Optional<unsigned> NumExpansions, + Optional<unsigned> NumExpansions, bool ExpectParameterPack) { return SemaRef.SubstParmVarDecl(OldParm, TemplateArgs, indexAdjustment, NumExpansions, ExpectParameterPack); @@ -1629,7 +1629,7 @@ TypeSourceInfo *Sema::SubstFunctionDeclType(TypeSourceInfo *T, ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, - llvm::Optional<unsigned> NumExpansions, + Optional<unsigned> NumExpansions, bool ExpectParameterPack) { TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); TypeSourceInfo *NewDI = 0; @@ -1764,7 +1764,7 @@ Sema::SubstBaseSpecifiers(CXXRecordDecl *Instantiation, Unexpanded); bool ShouldExpand = false; bool RetainExpansion = false; - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; if (CheckParameterPacksForExpansion(Base->getEllipsisLoc(), Base->getSourceRange(), Unexpanded, diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index d854f7a25e..b971a04d61 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -1639,7 +1639,7 @@ Decl *TemplateDeclInstantiator::VisitCXXConversionDecl(CXXConversionDecl *D) { ParmVarDecl *TemplateDeclInstantiator::VisitParmVarDecl(ParmVarDecl *D) { return SemaRef.SubstParmVarDecl(D, TemplateArgs, /*indexAdjustment*/ 0, - llvm::Optional<unsigned>(), + Optional<unsigned>(), /*ExpectParameterPack=*/false); } @@ -1715,9 +1715,9 @@ Decl *TemplateDeclInstantiator::VisitNonTypeTemplateParmDecl( // be expanded. bool Expand = true; bool RetainExpansion = false; - llvm::Optional<unsigned> OrigNumExpansions + Optional<unsigned> OrigNumExpansions = Expansion.getTypePtr()->getNumExpansions(); - llvm::Optional<unsigned> NumExpansions = OrigNumExpansions; + Optional<unsigned> NumExpansions = OrigNumExpansions; if (SemaRef.CheckParameterPacksForExpansion(Expansion.getEllipsisLoc(), Pattern.getSourceRange(), Unexpanded, @@ -1872,7 +1872,7 @@ TemplateDeclInstantiator::VisitTemplateTemplateParmDecl( // be expanded. bool Expand = true; bool RetainExpansion = false; - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; if (SemaRef.CheckParameterPacksForExpansion(D->getLocation(), TempParams->getSourceRange(), Unexpanded, @@ -2345,7 +2345,7 @@ TemplateDeclInstantiator::SubstFunctionType(FunctionDecl *D, ParmVarDecl *OldParam = OldProtoLoc.getArg(OldIdx); LocalInstantiationScope *Scope = SemaRef.CurrentInstantiationScope; - llvm::Optional<unsigned> NumArgumentsInExpansion; + Optional<unsigned> NumArgumentsInExpansion; if (OldParam->isParameterPack()) NumArgumentsInExpansion = SemaRef.getNumArgumentsInExpansion(OldParam->getType(), @@ -2407,7 +2407,7 @@ static void addInstantiatedParametersToScope(Sema &S, FunctionDecl *Function, // Expand the parameter pack. Scope.MakeInstantiatedLocalArgPack(PatternParam); - llvm::Optional<unsigned> NumArgumentsInExpansion + Optional<unsigned> NumArgumentsInExpansion = S.getNumArgumentsInExpansion(PatternParam->getType(), TemplateArgs); assert(NumArgumentsInExpansion && "should only be called when all template arguments are known"); @@ -2456,7 +2456,7 @@ static void InstantiateExceptionSpec(Sema &SemaRef, FunctionDecl *New, bool Expand = false; bool RetainExpansion = false; - llvm::Optional<unsigned> NumExpansions + Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions(); if (SemaRef.CheckParameterPacksForExpansion(New->getLocation(), SourceRange(), @@ -3030,7 +3030,7 @@ Sema::InstantiateMemInitializers(CXXConstructorDecl *New, collectUnexpandedParameterPacks(BaseTL, Unexpanded); bool ShouldExpand = false; bool RetainExpansion = false; - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; if (CheckParameterPacksForExpansion(Init->getEllipsisLoc(), BaseTL.getSourceRange(), Unexpanded, diff --git a/lib/Sema/SemaTemplateVariadic.cpp b/lib/Sema/SemaTemplateVariadic.cpp index f250e30565..2cff7aa6b7 100644 --- a/lib/Sema/SemaTemplateVariadic.cpp +++ b/lib/Sema/SemaTemplateVariadic.cpp @@ -443,17 +443,17 @@ TypeResult Sema::ActOnPackExpansion(ParsedType Type, if (!TSInfo) return true; - TypeSourceInfo *TSResult = CheckPackExpansion(TSInfo, EllipsisLoc, - llvm::Optional<unsigned>()); + TypeSourceInfo *TSResult = + CheckPackExpansion(TSInfo, EllipsisLoc, Optional<unsigned>()); if (!TSResult) return true; return CreateParsedType(TSResult->getType(), TSResult); } -TypeSourceInfo *Sema::CheckPackExpansion(TypeSourceInfo *Pattern, - SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions) { +TypeSourceInfo * +Sema::CheckPackExpansion(TypeSourceInfo *Pattern, SourceLocation EllipsisLoc, + Optional<unsigned> NumExpansions) { // Create the pack expansion type and source-location information. QualType Result = CheckPackExpansion(Pattern->getType(), Pattern->getTypeLoc().getSourceRange(), @@ -473,10 +473,9 @@ TypeSourceInfo *Sema::CheckPackExpansion(TypeSourceInfo *Pattern, return TSResult; } -QualType Sema::CheckPackExpansion(QualType Pattern, - SourceRange PatternRange, +QualType Sema::CheckPackExpansion(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions) { + Optional<unsigned> NumExpansions) { // C++0x [temp.variadic]p5: // The pattern of a pack expansion shall name one or more // parameter packs that are not expanded by a nested pack @@ -491,11 +490,11 @@ QualType Sema::CheckPackExpansion(QualType Pattern, } ExprResult Sema::ActOnPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc) { - return CheckPackExpansion(Pattern, EllipsisLoc, llvm::Optional<unsigned>()); + return CheckPackExpansion(Pattern, EllipsisLoc, Optional<unsigned>()); } ExprResult Sema::CheckPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions) { + Optional<unsigned> NumExpansions) { if (!Pattern) return ExprError(); @@ -527,13 +526,11 @@ getDepthAndIndex(NamedDecl *ND) { return std::make_pair(TTP->getDepth(), TTP->getIndex()); } -bool Sema::CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, - SourceRange PatternRange, - ArrayRef<UnexpandedParameterPack> Unexpanded, - const MultiLevelTemplateArgumentList &TemplateArgs, - bool &ShouldExpand, - bool &RetainExpansion, - llvm::Optional<unsigned> &NumExpansions) { +bool Sema::CheckParameterPacksForExpansion( + SourceLocation EllipsisLoc, SourceRange PatternRange, + ArrayRef<UnexpandedParameterPack> Unexpanded, + const MultiLevelTemplateArgumentList &TemplateArgs, bool &ShouldExpand, + bool &RetainExpansion, Optional<unsigned> &NumExpansions) { ShouldExpand = true; RetainExpansion = false; std::pair<IdentifierInfo *, SourceLocation> FirstPack; @@ -637,13 +634,13 @@ bool Sema::CheckParameterPacksForExpansion(SourceLocation EllipsisLoc, return false; } -llvm::Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T, +Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs) { QualType Pattern = cast<PackExpansionType>(T)->getPattern(); SmallVector<UnexpandedParameterPack, 2> Unexpanded; CollectUnexpandedParameterPacksVisitor(Unexpanded).TraverseType(Pattern); - llvm::Optional<unsigned> Result; + Optional<unsigned> Result; for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { // Compute the depth and index for this parameter pack. unsigned Depth; @@ -665,7 +662,7 @@ llvm::Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T, if (Instantiation->is<Decl*>()) // The pattern refers to an unexpanded pack. We're not ready to expand // this pack yet. - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); unsigned Size = Instantiation->get<DeclArgumentPack *>()->size(); assert((!Result || *Result == Size) && "inconsistent pack sizes"); @@ -679,7 +676,7 @@ llvm::Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T, !TemplateArgs.hasTemplateArgument(Depth, Index)) // The pattern refers to an unknown template argument. We're not ready to // expand this pack yet. - return llvm::Optional<unsigned>(); + return Optional<unsigned>(); // Determine the size of the argument pack. unsigned Size = TemplateArgs(Depth, Index).pack_size(); diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp index 6d2ddd11d3..d4d42cd0ab 100644 --- a/lib/Sema/SemaType.cpp +++ b/lib/Sema/SemaType.cpp @@ -2889,7 +2889,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, << T << D.getSourceRange(); D.setEllipsisLoc(SourceLocation()); } else { - T = Context.getPackExpansionType(T, llvm::Optional<unsigned>()); + T = Context.getPackExpansionType(T, Optional<unsigned>()); } break; @@ -2903,7 +2903,7 @@ static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, // parameter packs in the type of the non-type template parameter, then // it expands those parameter packs. if (T->containsUnexpandedParameterPack()) - T = Context.getPackExpansionType(T, llvm::Optional<unsigned>()); + T = Context.getPackExpansionType(T, Optional<unsigned>()); else S.Diag(D.getEllipsisLoc(), LangOpts.CPlusPlus11 diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index 986e4323d8..0832a24d79 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -250,7 +250,7 @@ public: ArrayRef<UnexpandedParameterPack> Unexpanded, bool &ShouldExpand, bool &RetainExpansion, - llvm::Optional<unsigned> &NumExpansions) { + Optional<unsigned> &NumExpansions) { ShouldExpand = false; return false; } @@ -572,7 +572,7 @@ public: /// scope index; can be negative ParmVarDecl *TransformFunctionTypeParam(ParmVarDecl *OldParm, int indexAdjustment, - llvm::Optional<unsigned> NumExpansions, + Optional<unsigned> NumExpansions, bool ExpectParameterPack); QualType TransformReferenceType(TypeLocBuilder &TLB, ReferenceTypeLoc TL); @@ -950,7 +950,7 @@ public: QualType RebuildPackExpansionType(QualType Pattern, SourceRange PatternRange, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions) { + Optional<unsigned> NumExpansions) { return getSema().CheckPackExpansion(Pattern, PatternRange, EllipsisLoc, NumExpansions); } @@ -2225,7 +2225,7 @@ public: ExprResult RebuildSizeOfPackExpr(SourceLocation OperatorLoc, NamedDecl *Pack, SourceLocation PackLoc, SourceLocation RParenLoc, - llvm::Optional<unsigned> Length) { + Optional<unsigned> Length) { if (Length) return new (SemaRef.Context) SizeOfPackExpr(SemaRef.Context.getSizeType(), OperatorLoc, Pack, PackLoc, @@ -2456,7 +2456,7 @@ public: /// different behavior. TemplateArgumentLoc RebuildPackExpansion(TemplateArgumentLoc Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions) { + Optional<unsigned> NumExpansions) { switch (Pattern.getArgument().getKind()) { case TemplateArgument::Expression: { ExprResult Result @@ -2503,7 +2503,7 @@ public: /// for an expression. Subclasses may override this routine to provide /// different behavior. ExprResult RebuildPackExpansion(Expr *Pattern, SourceLocation EllipsisLoc, - llvm::Optional<unsigned> NumExpansions) { + Optional<unsigned> NumExpansions) { return getSema().CheckPackExpansion(Pattern, EllipsisLoc, NumExpansions); } @@ -2670,9 +2670,8 @@ bool TreeTransform<Derived>::TransformExprs(Expr **Inputs, // be expanded. bool Expand = true; bool RetainExpansion = false; - llvm::Optional<unsigned> OrigNumExpansions - = Expansion->getNumExpansions(); - llvm::Optional<unsigned> NumExpansions = OrigNumExpansions; + Optional<unsigned> OrigNumExpansions = Expansion->getNumExpansions(); + Optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Expansion->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded, @@ -3191,7 +3190,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First, // We have a pack expansion, for which we will be substituting into // the pattern. SourceLocation Ellipsis; - llvm::Optional<unsigned> OrigNumExpansions; + Optional<unsigned> OrigNumExpansions; TemplateArgumentLoc Pattern = In.getPackExpansionPattern(Ellipsis, OrigNumExpansions, getSema().Context); @@ -3204,7 +3203,7 @@ bool TreeTransform<Derived>::TransformTemplateArguments(InputIterator First, // be expanded. bool Expand = true; bool RetainExpansion = false; - llvm::Optional<unsigned> NumExpansions = OrigNumExpansions; + Optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(Ellipsis, Pattern.getSourceRange(), Unexpanded, @@ -3947,12 +3946,10 @@ QualType TreeTransform<Derived>::TransformExtVectorType(TypeLocBuilder &TLB, return Result; } -template<typename Derived> -ParmVarDecl * -TreeTransform<Derived>::TransformFunctionTypeParam(ParmVarDecl *OldParm, - int indexAdjustment, - llvm::Optional<unsigned> NumExpansions, - bool ExpectParameterPack) { +template <typename Derived> +ParmVarDecl *TreeTransform<Derived>::TransformFunctionTypeParam( + ParmVarDecl *OldParm, int indexAdjustment, Optional<unsigned> NumExpansions, + bool ExpectParameterPack) { TypeSourceInfo *OldDI = OldParm->getTypeSourceInfo(); TypeSourceInfo *NewDI = 0; @@ -4018,7 +4015,7 @@ bool TreeTransform<Derived>:: if (ParmVarDecl *OldParm = Params[i]) { assert(OldParm->getFunctionScopeIndex() == i); - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; ParmVarDecl *NewParm = 0; if (OldParm->isParameterPack()) { // We have a function parameter pack that may need to be expanded. @@ -4034,8 +4031,8 @@ bool TreeTransform<Derived>:: // Determine whether we should expand the parameter packs. bool ShouldExpand = false; bool RetainExpansion = false; - llvm::Optional<unsigned> OrigNumExpansions - = ExpansionTL.getTypePtr()->getNumExpansions(); + Optional<unsigned> OrigNumExpansions = + ExpansionTL.getTypePtr()->getNumExpansions(); NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), Pattern.getSourceRange(), @@ -4100,10 +4097,9 @@ bool TreeTransform<Derived>:: NumExpansions, /*ExpectParameterPack=*/true); } else { - NewParm = getDerived().TransformFunctionTypeParam(OldParm, - indexAdjustment, - llvm::Optional<unsigned>(), - /*ExpectParameterPack=*/false); + NewParm = getDerived().TransformFunctionTypeParam( + OldParm, indexAdjustment, Optional<unsigned>(), + /*ExpectParameterPack=*/ false); } if (!NewParm) @@ -4119,7 +4115,7 @@ bool TreeTransform<Derived>:: // declaration for this parameter. QualType OldType = ParamTypes[i]; bool IsPackExpansion = false; - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; QualType NewType; if (const PackExpansionType *Expansion = dyn_cast<PackExpansionType>(OldType)) { @@ -7637,9 +7633,9 @@ TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) { // be expanded. bool Expand = true; bool RetainExpansion = false; - llvm::Optional<unsigned> OrigNumExpansions - = ExpansionTL.getTypePtr()->getNumExpansions(); - llvm::Optional<unsigned> NumExpansions = OrigNumExpansions; + Optional<unsigned> OrigNumExpansions = + ExpansionTL.getTypePtr()->getNumExpansions(); + Optional<unsigned> NumExpansions = OrigNumExpansions; if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(), PatternTL.getSourceRange(), Unexpanded, @@ -8017,7 +8013,7 @@ TreeTransform<Derived>::TransformLambdaScope(LambdaExpr *E, UnexpandedParameterPack Unexpanded(C->getCapturedVar(), C->getLocation()); bool ShouldExpand = false; bool RetainExpansion = false; - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; if (getDerived().TryExpandParameterPacks(C->getEllipsisLoc(), C->getLocation(), Unexpanded, @@ -8360,7 +8356,7 @@ TreeTransform<Derived>::TransformSizeOfPackExpr(SizeOfPackExpr *E) { UnexpandedParameterPack Unexpanded(E->getPack(), E->getPackLoc()); bool ShouldExpand = false; bool RetainExpansion = false; - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; if (getDerived().TryExpandParameterPacks(E->getOperatorLoc(), E->getPackLoc(), Unexpanded, ShouldExpand, RetainExpansion, @@ -8481,8 +8477,8 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( // and should be expanded. bool Expand = true; bool RetainExpansion = false; - llvm::Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; - llvm::Optional<unsigned> NumExpansions = OrigNumExpansions; + Optional<unsigned> OrigNumExpansions = OrigElement.NumExpansions; + Optional<unsigned> NumExpansions = OrigNumExpansions; SourceRange PatternRange(OrigElement.Key->getLocStart(), OrigElement.Value->getLocEnd()); if (getDerived().TryExpandParameterPacks(OrigElement.EllipsisLoc, @@ -8569,7 +8565,7 @@ TreeTransform<Derived>::TransformObjCDictionaryLiteral( ArgChanged = true; ObjCDictionaryElement Element = { - Key.get(), Value.get(), SourceLocation(), llvm::Optional<unsigned>() + Key.get(), Value.get(), SourceLocation(), Optional<unsigned>() }; Elements.push_back(Element); } diff --git a/lib/Serialization/ASTReader.cpp b/lib/Serialization/ASTReader.cpp index f8e1c3ed9c..6dff373fda 100644 --- a/lib/Serialization/ASTReader.cpp +++ b/lib/Serialization/ASTReader.cpp @@ -4045,7 +4045,7 @@ std::pair<unsigned, unsigned> /// \brief Optionally returns true or false if the preallocated preprocessed /// entity with index \arg Index came from file \arg FID. -llvm::Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, +Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, FileID FID) { if (FID.isInvalid()) return false; @@ -4071,7 +4071,7 @@ namespace { ASTReader &Reader; const FileEntry *FE; - llvm::Optional<HeaderFileInfo> HFI; + Optional<HeaderFileInfo> HFI; public: HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE) @@ -4101,14 +4101,14 @@ namespace { return true; } - llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } + Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } }; } HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { HeaderFileInfoVisitor Visitor(*this, FE); ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); - if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { + if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { if (Listener) Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); return *HFI; @@ -4468,7 +4468,7 @@ QualType ASTReader::readTypeRecord(unsigned Index) { QualType Pattern = readType(*Loc.F, Record, Idx); if (Pattern.isNull()) return QualType(); - llvm::Optional<unsigned> NumExpansions; + Optional<unsigned> NumExpansions; if (Record[1]) NumExpansions = Record[1] - 1; return Context.getPackExpansionType(Pattern, NumExpansions); @@ -6542,7 +6542,7 @@ ASTReader::ReadTemplateArgument(ModuleFile &F, return TemplateArgument(ReadTemplateName(F, Record, Idx)); case TemplateArgument::TemplateExpansion: { TemplateName Name = ReadTemplateName(F, Record, Idx); - llvm::Optional<unsigned> NumTemplateExpansions; + Optional<unsigned> NumTemplateExpansions; if (unsigned NumExpansions = Record[Idx++]) NumTemplateExpansions = NumExpansions - 1; return TemplateArgument(Name, NumTemplateExpansions); diff --git a/lib/Serialization/ASTWriter.cpp b/lib/Serialization/ASTWriter.cpp index f33fbc23d8..09c5bbb63b 100644 --- a/lib/Serialization/ASTWriter.cpp +++ b/lib/Serialization/ASTWriter.cpp @@ -353,7 +353,7 @@ ASTTypeWriter::VisitDependentTemplateSpecializationType( void ASTTypeWriter::VisitPackExpansionType(const PackExpansionType *T) { Writer.AddTypeRef(T->getPattern(), Record); - if (llvm::Optional<unsigned> NumExpansions = T->getNumExpansions()) + if (Optional<unsigned> NumExpansions = T->getNumExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); @@ -3301,11 +3301,11 @@ void ASTWriter::AddString(StringRef Str, RecordDataImpl &Record) { void ASTWriter::AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record) { Record.push_back(Version.getMajor()); - if (llvm::Optional<unsigned> Minor = Version.getMinor()) + if (Optional<unsigned> Minor = Version.getMinor()) Record.push_back(*Minor + 1); else Record.push_back(0); - if (llvm::Optional<unsigned> Subminor = Version.getSubminor()) + if (Optional<unsigned> Subminor = Version.getSubminor()) Record.push_back(*Subminor + 1); else Record.push_back(0); @@ -4463,7 +4463,7 @@ void ASTWriter::AddTemplateArgument(const TemplateArgument &Arg, break; case TemplateArgument::TemplateExpansion: AddTemplateName(Arg.getAsTemplateOrTemplatePattern(), Record); - if (llvm::Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions()) + if (Optional<unsigned> NumExpansions = Arg.getNumTemplateExpansions()) Record.push_back(*NumExpansions + 1); else Record.push_back(0); diff --git a/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp b/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp index 27692fe46d..5e4b824df4 100644 --- a/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp +++ b/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp @@ -110,12 +110,12 @@ void ArrayBoundCheckerV2::checkLocation(SVal location, bool isLoad, SVal extentBegin = computeExtentBegin(svalBuilder, rawOffset.getRegion()); - if (llvm::Optional<NonLoc> NV = extentBegin.getAs<NonLoc>()) { + if (Optional<NonLoc> NV = extentBegin.getAs<NonLoc>()) { SVal lowerBound = svalBuilder.evalBinOpNN(state, BO_LT, rawOffset.getByteOffset(), *NV, svalBuilder.getConditionType()); - llvm::Optional<NonLoc> lowerBoundToCheck = lowerBound.getAs<NonLoc>(); + Optional<NonLoc> lowerBoundToCheck = lowerBound.getAs<NonLoc>(); if (!lowerBoundToCheck) return; @@ -147,7 +147,7 @@ void ArrayBoundCheckerV2::checkLocation(SVal location, bool isLoad, extentVal.castAs<NonLoc>(), svalBuilder.getConditionType()); - llvm::Optional<NonLoc> upperboundToCheck = upperbound.getAs<NonLoc>(); + Optional<NonLoc> upperboundToCheck = upperbound.getAs<NonLoc>(); if (!upperboundToCheck) break; diff --git a/lib/StaticAnalyzer/Checkers/AttrNonNullChecker.cpp b/lib/StaticAnalyzer/Checkers/AttrNonNullChecker.cpp index 6185a8ee8c..de5e6dca5e 100644 --- a/lib/StaticAnalyzer/Checkers/AttrNonNullChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/AttrNonNullChecker.cpp @@ -51,7 +51,7 @@ void AttrNonNullChecker::checkPreCall(const CallEvent &Call, continue; SVal V = Call.getArgSVal(idx); - llvm::Optional<DefinedSVal> DV = V.getAs<DefinedSVal>(); + Optional<DefinedSVal> DV = V.getAs<DefinedSVal>(); // If the value is unknown or undefined, we can't perform this check. if (!DV) @@ -69,7 +69,7 @@ void AttrNonNullChecker::checkPreCall(const CallEvent &Call, if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) continue; - if (llvm::Optional<nonloc::CompoundVal> CSV = + if (Optional<nonloc::CompoundVal> CSV = DV->getAs<nonloc::CompoundVal>()) { nonloc::CompoundVal::iterator CSV_I = CSV->begin(); assert(CSV_I != CSV->end()); diff --git a/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp b/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp index 7603f8f04c..ae33a8a18c 100644 --- a/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp +++ b/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp @@ -268,13 +268,12 @@ void CFNumberCreateChecker::checkPreStmt(const CallExpr *CE, // FIXME: We really should allow ranges of valid theType values, and // bifurcate the state appropriately. - llvm::Optional<nonloc::ConcreteInt> V = - TheTypeVal.getAs<nonloc::ConcreteInt>(); + Optional<nonloc::ConcreteInt> V = TheTypeVal.getAs<nonloc::ConcreteInt>(); if (!V) return; uint64_t NumberKind = V->getValue().getLimitedValue(); - llvm::Optional<uint64_t> OptTargetSize = GetCFNumberSize(Ctx, NumberKind); + Optional<uint64_t> OptTargetSize = GetCFNumberSize(Ctx, NumberKind); // FIXME: In some cases we can emit an error. if (!OptTargetSize) @@ -289,8 +288,7 @@ void CFNumberCreateChecker::checkPreStmt(const CallExpr *CE, // FIXME: Eventually we should handle arbitrary locations. We can do this // by having an enhanced memory model that does low-level typing. - llvm::Optional<loc::MemRegionVal> LV = - TheValueExpr.getAs<loc::MemRegionVal>(); + Optional<loc::MemRegionVal> LV = TheValueExpr.getAs<loc::MemRegionVal>(); if (!LV) return; @@ -391,7 +389,7 @@ void CFRetainReleaseChecker::checkPreStmt(const CallExpr *CE, // Get the argument's value. const Expr *Arg = CE->getArg(0); SVal ArgVal = state->getSVal(Arg, C.getLocationContext()); - llvm::Optional<DefinedSVal> DefArgVal = ArgVal.getAs<DefinedSVal>(); + Optional<DefinedSVal> DefArgVal = ArgVal.getAs<DefinedSVal>(); if (!DefArgVal) return; @@ -589,7 +587,7 @@ void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg, return; // Verify that all arguments have Objective-C types. - llvm::Optional<ExplodedNode*> errorNode; + Optional<ExplodedNode*> errorNode; ProgramStateRef state = C.getState(); for (unsigned I = variadicArgsBegin; I != variadicArgsEnd; ++I) { @@ -728,8 +726,7 @@ static ProgramStateRef assumeExprIsNonNull(const Expr *NonNullExpr, ProgramStateRef State, CheckerContext &C) { SVal Val = State->getSVal(NonNullExpr, C.getLocationContext()); - if (llvm::Optional<DefinedOrUnknownSVal> DV = - Val.getAs<DefinedOrUnknownSVal>()) + if (Optional<DefinedOrUnknownSVal> DV = Val.getAs<DefinedOrUnknownSVal>()) return State->assume(*DV, true); return State; } diff --git a/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp b/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp index 3ceb8c4889..5169244a6f 100644 --- a/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp @@ -69,7 +69,7 @@ void BoolAssignmentChecker::checkBind(SVal loc, SVal val, const Stmt *S, // Get the value of the right-hand side. We only care about values // that are defined (UnknownVals and UndefinedVals are handled by other // checkers). - llvm::Optional<DefinedSVal> DV = val.getAs<DefinedSVal>(); + Optional<DefinedSVal> DV = val.getAs<DefinedSVal>(); if (!DV) return; @@ -86,7 +86,7 @@ void BoolAssignmentChecker::checkBind(SVal loc, SVal val, const Stmt *S, svalBuilder.evalBinOp(state, BO_GE, *DV, zeroVal, svalBuilder.getConditionType()); - llvm::Optional<DefinedSVal> greaterThanEqualToZero = + Optional<DefinedSVal> greaterThanEqualToZero = greaterThanOrEqualToZeroVal.getAs<DefinedSVal>(); if (!greaterThanEqualToZero) { @@ -122,7 +122,7 @@ void BoolAssignmentChecker::checkBind(SVal loc, SVal val, const Stmt *S, svalBuilder.evalBinOp(state, BO_LE, *DV, OneVal, svalBuilder.getConditionType()); - llvm::Optional<DefinedSVal> lessThanEqToOne = + Optional<DefinedSVal> lessThanEqToOne = lessThanEqToOneVal.getAs<DefinedSVal>(); if (!lessThanEqToOne) { diff --git a/lib/StaticAnalyzer/Checkers/CStringChecker.cpp b/lib/StaticAnalyzer/Checkers/CStringChecker.cpp index 1c9956727a..d0c4322d50 100644 --- a/lib/StaticAnalyzer/Checkers/CStringChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/CStringChecker.cpp @@ -201,7 +201,7 @@ REGISTER_MAP_WITH_PROGRAMSTATE(CStringLength, const MemRegion *, SVal) std::pair<ProgramStateRef , ProgramStateRef > CStringChecker::assumeZero(CheckerContext &C, ProgramStateRef state, SVal V, QualType Ty) { - llvm::Optional<DefinedSVal> val = V.getAs<DefinedSVal>(); + Optional<DefinedSVal> val = V.getAs<DefinedSVal>(); if (!val) return std::pair<ProgramStateRef , ProgramStateRef >(state, state); @@ -359,7 +359,7 @@ ProgramStateRef CStringChecker::CheckBufferAccess(CheckerContext &C, // FIXME: This assumes the caller has already checked that the access length // is positive. And that it's unsigned. SVal LengthVal = state->getSVal(Size, LCtx); - llvm::Optional<NonLoc> Length = LengthVal.getAs<NonLoc>(); + Optional<NonLoc> Length = LengthVal.getAs<NonLoc>(); if (!Length) return state; @@ -370,7 +370,7 @@ ProgramStateRef CStringChecker::CheckBufferAccess(CheckerContext &C, // Check that the first buffer is sufficiently long. SVal BufStart = svalBuilder.evalCast(BufVal, PtrTy, FirstBuf->getType()); - if (llvm::Optional<Loc> BufLoc = BufStart.getAs<Loc>()) { + if (Optional<Loc> BufLoc = BufStart.getAs<Loc>()) { const Expr *warningExpr = (WarnAboutSize ? Size : FirstBuf); SVal BufEnd = svalBuilder.evalBinOpLN(state, BO_Add, *BufLoc, @@ -390,7 +390,7 @@ ProgramStateRef CStringChecker::CheckBufferAccess(CheckerContext &C, return NULL; BufStart = svalBuilder.evalCast(BufVal, PtrTy, SecondBuf->getType()); - if (llvm::Optional<Loc> BufLoc = BufStart.getAs<Loc>()) { + if (Optional<Loc> BufLoc = BufStart.getAs<Loc>()) { const Expr *warningExpr = (WarnAboutSize ? Size : SecondBuf); SVal BufEnd = svalBuilder.evalBinOpLN(state, BO_Add, *BufLoc, @@ -426,11 +426,11 @@ ProgramStateRef CStringChecker::CheckOverlap(CheckerContext &C, SVal firstVal = state->getSVal(First, LCtx); SVal secondVal = state->getSVal(Second, LCtx); - llvm::Optional<Loc> firstLoc = firstVal.getAs<Loc>(); + Optional<Loc> firstLoc = firstVal.getAs<Loc>(); if (!firstLoc) return state; - llvm::Optional<Loc> secondLoc = secondVal.getAs<Loc>(); + Optional<Loc> secondLoc = secondVal.getAs<Loc>(); if (!secondLoc) return state; @@ -453,7 +453,7 @@ ProgramStateRef CStringChecker::CheckOverlap(CheckerContext &C, QualType cmpTy = svalBuilder.getConditionType(); SVal reverse = svalBuilder.evalBinOpLL(state, BO_GT, *firstLoc, *secondLoc, cmpTy); - llvm::Optional<DefinedOrUnknownSVal> reverseTest = + Optional<DefinedOrUnknownSVal> reverseTest = reverse.getAs<DefinedOrUnknownSVal>(); if (!reverseTest) return state; @@ -474,7 +474,7 @@ ProgramStateRef CStringChecker::CheckOverlap(CheckerContext &C, // Get the length, and make sure it too is known. SVal LengthVal = state->getSVal(Size, LCtx); - llvm::Optional<NonLoc> Length = LengthVal.getAs<NonLoc>(); + Optional<NonLoc> Length = LengthVal.getAs<NonLoc>(); if (!Length) return state; @@ -484,21 +484,21 @@ ProgramStateRef CStringChecker::CheckOverlap(CheckerContext &C, QualType CharPtrTy = Ctx.getPointerType(Ctx.CharTy); SVal FirstStart = svalBuilder.evalCast(*firstLoc, CharPtrTy, First->getType()); - llvm::Optional<Loc> FirstStartLoc = FirstStart.getAs<Loc>(); + Optional<Loc> FirstStartLoc = FirstStart.getAs<Loc>(); if (!FirstStartLoc) return state; // Compute the end of the first buffer. Bail out if THAT fails. SVal FirstEnd = svalBuilder.evalBinOpLN(state, BO_Add, *FirstStartLoc, *Length, CharPtrTy); - llvm::Optional<Loc> FirstEndLoc = FirstEnd.getAs<Loc>(); + Optional<Loc> FirstEndLoc = FirstEnd.getAs<Loc>(); if (!FirstEndLoc) return state; // Is the end of the first buffer past the start of the second buffer? SVal Overlap = svalBuilder.evalBinOpLL(state, BO_GT, *FirstEndLoc, *secondLoc, cmpTy); - llvm::Optional<DefinedOrUnknownSVal> OverlapTest = + Optional<DefinedOrUnknownSVal> OverlapTest = Overlap.getAs<DefinedOrUnknownSVal>(); if (!OverlapTest) return state; @@ -566,7 +566,7 @@ ProgramStateRef CStringChecker::checkAdditionOverflow(CheckerContext &C, left = right; } - if (llvm::Optional<NonLoc> maxMinusRightNL = maxMinusRight.getAs<NonLoc>()) { + if (Optional<NonLoc> maxMinusRightNL = maxMinusRight.getAs<NonLoc>()) { QualType cmpTy = svalBuilder.getConditionType(); // If left > max - right, we have an overflow. SVal willOverflow = svalBuilder.evalBinOpNN(state, BO_GT, left, @@ -681,7 +681,7 @@ SVal CStringChecker::getCStringLength(CheckerContext &C, ProgramStateRef &state, // If we can't get a region, see if it's something we /know/ isn't a // C string. In the context of locations, the only time we can issue such // a warning is for labels. - if (llvm::Optional<loc::GotoLabel> Label = Buf.getAs<loc::GotoLabel>()) { + if (Optional<loc::GotoLabel> Label = Buf.getAs<loc::GotoLabel>()) { if (!Filter.CheckCStringNotNullTerm) return UndefinedVal(); @@ -796,14 +796,14 @@ const StringLiteral *CStringChecker::getCStringLiteral(CheckerContext &C, ProgramStateRef CStringChecker::InvalidateBuffer(CheckerContext &C, ProgramStateRef state, const Expr *E, SVal V) { - llvm::Optional<Loc> L = V.getAs<Loc>(); + Optional<Loc> L = V.getAs<Loc>(); if (!L) return state; // FIXME: This is a simplified version of what's in CFRefCount.cpp -- it makes // some assumptions about the value that CFRefCount can't. Even so, it should // probably be refactored. - if (llvm::Optional<loc::MemRegionVal> MR = L->getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> MR = L->getAs<loc::MemRegionVal>()) { const MemRegion *R = MR->getRegion()->StripCasts(); // Are we dealing with an ElementRegion? If so, we should be invalidating @@ -930,7 +930,7 @@ void CStringChecker::evalCopyCommon(CheckerContext &C, loc::MemRegionVal destRegVal = destVal.castAs<loc::MemRegionVal>(); // Get the length to copy. - if (llvm::Optional<NonLoc> lenValNonLoc = sizeVal.getAs<NonLoc>()) { + if (Optional<NonLoc> lenValNonLoc = sizeVal.getAs<NonLoc>()) { // Get the byte after the last byte copied. SVal lastElement = C.getSValBuilder().evalBinOpLN(state, BO_Add, destRegVal, @@ -1161,8 +1161,8 @@ void CStringChecker::evalstrLengthCommon(CheckerContext &C, const CallExpr *CE, const Expr *maxlenExpr = CE->getArg(1); SVal maxlenVal = state->getSVal(maxlenExpr, LCtx); - llvm::Optional<NonLoc> strLengthNL = strLength.getAs<NonLoc>(); - llvm::Optional<NonLoc> maxlenValNL = maxlenVal.getAs<NonLoc>(); + Optional<NonLoc> strLengthNL = strLength.getAs<NonLoc>(); + Optional<NonLoc> maxlenValNL = maxlenVal.getAs<NonLoc>(); if (strLengthNL && maxlenValNL) { ProgramStateRef stateStringTooLong, stateStringNotTooLong; @@ -1324,8 +1324,8 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, // Protect against misdeclared strncpy(). lenVal = svalBuilder.evalCast(lenVal, sizeTy, lenExpr->getType()); - llvm::Optional<NonLoc> strLengthNL = strLength.getAs<NonLoc>(); - llvm::Optional<NonLoc> lenValNL = lenVal.getAs<NonLoc>(); + Optional<NonLoc> strLengthNL = strLength.getAs<NonLoc>(); + Optional<NonLoc> lenValNL = lenVal.getAs<NonLoc>(); // If we know both values, we might be able to figure out how much // we're copying. @@ -1364,8 +1364,7 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, if (dstStrLength.isUndef()) return; - if (llvm::Optional<NonLoc> dstStrLengthNL = - dstStrLength.getAs<NonLoc>()) { + if (Optional<NonLoc> dstStrLengthNL = dstStrLength.getAs<NonLoc>()) { maxLastElementIndex = svalBuilder.evalBinOpNN(state, BO_Add, *lenValNL, *dstStrLengthNL, @@ -1414,8 +1413,7 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, amountCopied = getCStringLength(C, state, lenExpr, srcVal, true); assert(!amountCopied.isUndef()); - if (llvm::Optional<NonLoc> amountCopiedNL = - amountCopied.getAs<NonLoc>()) { + if (Optional<NonLoc> amountCopiedNL = amountCopied.getAs<NonLoc>()) { if (lenValNL) { // amountCopied <= lenVal SVal copiedLessThanBound = svalBuilder.evalBinOpNN(state, BO_LE, @@ -1465,8 +1463,8 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, if (dstStrLength.isUndef()) return; - llvm::Optional<NonLoc> srcStrLengthNL = amountCopied.getAs<NonLoc>(); - llvm::Optional<NonLoc> dstStrLengthNL = dstStrLength.getAs<NonLoc>(); + Optional<NonLoc> srcStrLengthNL = amountCopied.getAs<NonLoc>(); + Optional<NonLoc> dstStrLengthNL = dstStrLength.getAs<NonLoc>(); // If we know both string lengths, we might know the final string length. if (srcStrLengthNL && dstStrLengthNL) { @@ -1487,8 +1485,7 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, finalStrLength = getCStringLength(C, state, CE, DstVal, true); assert(!finalStrLength.isUndef()); - if (llvm::Optional<NonLoc> finalStrLengthNL = - finalStrLength.getAs<NonLoc>()) { + if (Optional<NonLoc> finalStrLengthNL = finalStrLength.getAs<NonLoc>()) { if (srcStrLengthNL) { // finalStrLength >= srcStrLength SVal sourceInResult = svalBuilder.evalBinOpNN(state, BO_GE, @@ -1529,15 +1526,14 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, // If the destination is a MemRegion, try to check for a buffer overflow and // record the new string length. - if (llvm::Optional<loc::MemRegionVal> dstRegVal = + if (Optional<loc::MemRegionVal> dstRegVal = DstVal.getAs<loc::MemRegionVal>()) { QualType ptrTy = Dst->getType(); // If we have an exact value on a bounded copy, use that to check for // overflows, rather than our estimate about how much is actually copied. if (boundWarning) { - if (llvm::Optional<NonLoc> maxLastNL = - maxLastElementIndex.getAs<NonLoc>()) { + if (Optional<NonLoc> maxLastNL = maxLastElementIndex.getAs<NonLoc>()) { SVal maxLastElement = svalBuilder.evalBinOpLN(state, BO_Add, *dstRegVal, *maxLastNL, ptrTy); state = CheckLocation(C, state, CE->getArg(2), maxLastElement, @@ -1548,8 +1544,7 @@ void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE, } // Then, if the final length is known... - if (llvm::Optional<NonLoc> knownStrLength = - finalStrLength.getAs<NonLoc>()) { + if (Optional<NonLoc> knownStrLength = finalStrLength.getAs<NonLoc>()) { SVal lastElement = svalBuilder.evalBinOpLN(state, BO_Add, *dstRegVal, *knownStrLength, ptrTy); diff --git a/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp b/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp index d5203a80df..37e203df8e 100644 --- a/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp @@ -134,7 +134,7 @@ bool CallAndMessageChecker::PreVisitProcessArg(CheckerContext &C, if (!checkUninitFields) return false; - if (llvm::Optional<nonloc::LazyCompoundVal> LV = + if (Optional<nonloc::LazyCompoundVal> LV = V.getAs<nonloc::LazyCompoundVal>()) { class FindUninitializedField { diff --git a/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp b/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp index 3c14e7e32e..93daf94fbe 100644 --- a/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp @@ -58,7 +58,7 @@ void DivZeroChecker::checkPreStmt(const BinaryOperator *B, return; SVal Denom = C.getState()->getSVal(B->getRHS(), C.getLocationContext()); - llvm::Optional<DefinedSVal> DV = Denom.getAs<DefinedSVal>(); + Optional<DefinedSVal> DV = Denom.getAs<DefinedSVal>(); // Divide-by-undefined handled in the generic checking for uses of // undefined values. diff --git a/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp b/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp index 00ef1f65b4..c67c597fec 100644 --- a/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/GenericTaintChecker.cpp @@ -431,7 +431,7 @@ SymbolRef GenericTaintChecker::getPointedToSymbol(CheckerContext &C, if (AddrVal.isUnknownOrUndef()) return 0; - llvm::Optional<Loc> AddrLoc = AddrVal.getAs<Loc>(); + Optional<Loc> AddrLoc = AddrVal.getAs<Loc>(); if (!AddrLoc) return 0; diff --git a/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp b/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp index 50114e953a..84cad8295c 100644 --- a/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp @@ -217,7 +217,7 @@ static SymbolRef getAsPointeeSymbol(const Expr *Expr, ProgramStateRef State = C.getState(); SVal ArgV = State->getSVal(Expr, C.getLocationContext()); - if (llvm::Optional<loc::MemRegionVal> X = ArgV.getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> X = ArgV.getAs<loc::MemRegionVal>()) { StoreManager& SM = C.getStoreManager(); SymbolRef sym = SM.getBinding(State->getStore(), *X).getAsLocSymbol(); if (sym) diff --git a/lib/StaticAnalyzer/Checkers/MallocChecker.cpp b/lib/StaticAnalyzer/Checkers/MallocChecker.cpp index aaaafeb5ef..38722a2ed5 100644 --- a/lib/StaticAnalyzer/Checkers/MallocChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/MallocChecker.cpp @@ -571,7 +571,7 @@ ProgramStateRef MallocChecker::MallocMemAux(CheckerContext &C, dyn_cast_or_null<SymbolicRegion>(RetVal.getAsRegion()); if (!R) return 0; - if (llvm::Optional<DefinedOrUnknownSVal> DefinedSize = + if (Optional<DefinedOrUnknownSVal> DefinedSize = Size.getAs<DefinedOrUnknownSVal>()) { SValBuilder &svalBuilder = C.getSValBuilder(); DefinedOrUnknownSVal Extent = R->getExtent(svalBuilder); @@ -782,13 +782,11 @@ ProgramStateRef MallocChecker::FreeMemAux(CheckerContext &C, } bool MallocChecker::SummarizeValue(raw_ostream &os, SVal V) { - if (llvm::Optional<nonloc::ConcreteInt> IntVal = - V.getAs<nonloc::ConcreteInt>()) + if (Optional<nonloc::ConcreteInt> IntVal = V.getAs<nonloc::ConcreteInt>()) os << "an integer (" << IntVal->getValue() << ")"; - else if (llvm::Optional<loc::ConcreteInt> ConstAddr = - V.getAs<loc::ConcreteInt>()) + else if (Optional<loc::ConcreteInt> ConstAddr = V.getAs<loc::ConcreteInt>()) os << "a constant address (" << ConstAddr->getValue() << ")"; - else if (llvm::Optional<loc::GotoLabel> Label = V.getAs<loc::GotoLabel>()) + else if (Optional<loc::GotoLabel> Label = V.getAs<loc::GotoLabel>()) os << "the address of the label '" << Label->getLabel()->getName() << "'"; else return false; diff --git a/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp b/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp index 9e2202b842..9f01522ead 100644 --- a/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp @@ -186,7 +186,7 @@ static void setFlag(ProgramStateRef state, SVal val, CheckerContext &C) { static QualType parameterTypeFromSVal(SVal val, CheckerContext &C) { const StackFrameContext * SFC = C.getLocationContext()->getCurrentStackFrame(); - if (llvm::Optional<loc::MemRegionVal> X = val.getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> X = val.getAs<loc::MemRegionVal>()) { const MemRegion* R = X->getRegion(); if (const VarRegion *VR = R->getAs<VarRegion>()) if (const StackArgumentsSpaceRegion * diff --git a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp index cb731fcee1..69191deec3 100644 --- a/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp @@ -3361,8 +3361,7 @@ void RetainCountChecker::checkBind(SVal loc, SVal val, const Stmt *S, // does not understand. ProgramStateRef state = C.getState(); - if (llvm::Optional<loc::MemRegionVal> regionLoc = - loc.getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> regionLoc = loc.getAs<loc::MemRegionVal>()) { escapes = !regionLoc->getRegion()->hasStackStorage(); if (!escapes) { diff --git a/lib/StaticAnalyzer/Checkers/StreamChecker.cpp b/lib/StaticAnalyzer/Checkers/StreamChecker.cpp index 2a6c217f0c..1c38ab0b18 100644 --- a/lib/StaticAnalyzer/Checkers/StreamChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/StreamChecker.cpp @@ -259,7 +259,7 @@ void StreamChecker::Fseek(CheckerContext &C, const CallExpr *CE) const { return; // Check the legality of the 'whence' argument of 'fseek'. SVal Whence = state->getSVal(CE->getArg(2), C.getLocationContext()); - llvm::Optional<nonloc::ConcreteInt> CI = Whence.getAs<nonloc::ConcreteInt>(); + Optional<nonloc::ConcreteInt> CI = Whence.getAs<nonloc::ConcreteInt>(); if (!CI) return; @@ -337,7 +337,7 @@ void StreamChecker::Fileno(CheckerContext &C, const CallExpr *CE) const { ProgramStateRef StreamChecker::CheckNullStream(SVal SV, ProgramStateRef state, CheckerContext &C) const { - llvm::Optional<DefinedSVal> DV = SV.getAs<DefinedSVal>(); + Optional<DefinedSVal> DV = SV.getAs<DefinedSVal>(); if (!DV) return 0; diff --git a/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp b/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp index 3e11fd810e..4ea07e29eb 100644 --- a/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp +++ b/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp @@ -27,7 +27,6 @@ using namespace clang; using namespace ento; -using llvm::Optional; namespace { class UnixAPIChecker : public Checker< check::PreStmt<CallExpr> > { diff --git a/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp b/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp index cb02e94d60..2d6246e510 100644 --- a/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp +++ b/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp @@ -109,8 +109,7 @@ bool AnalyzerOptions::getBooleanOption(StringRef Name, bool DefaultVal) { .Default(DefaultVal); } -bool AnalyzerOptions::getBooleanOption(llvm::Optional<bool> &V, - StringRef Name, +bool AnalyzerOptions::getBooleanOption(Optional<bool> &V, StringRef Name, bool DefaultVal) { if (!V.hasValue()) V = getBooleanOption(Name, DefaultVal); diff --git a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp index 8afd4887cf..05d187e4e0 100644 --- a/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ b/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -475,7 +475,7 @@ PathDiagnosticPiece *FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ, if (!b) os << action << "a null pointer value"; - } else if (llvm::Optional<nonloc::ConcreteInt> CVal = + } else if (Optional<nonloc::ConcreteInt> CVal = V.getAs<nonloc::ConcreteInt>()) { os << action << CVal->getValue(); } @@ -506,7 +506,7 @@ PathDiagnosticPiece *FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ, os << "null pointer value"; } else if (V.isUndef()) { os << "uninitialized value"; - } else if (llvm::Optional<nonloc::ConcreteInt> CI = + } else if (Optional<nonloc::ConcreteInt> CI = V.getAs<nonloc::ConcreteInt>()) { os << "the value " << CI->getValue(); } else { @@ -538,7 +538,7 @@ PathDiagnosticPiece *FindLastStoreBRVisitor::VisitNode(const ExplodedNode *Succ, } else if (V.isUndef()) { os << "Uninitialized value stored to "; - } else if (llvm::Optional<nonloc::ConcreteInt> CV = + } else if (Optional<nonloc::ConcreteInt> CV = V.getAs<nonloc::ConcreteInt>()) { os << "The value " << CV->getValue() << " is assigned to "; } @@ -713,7 +713,7 @@ bool bugreporter::trackNullOrUndefValue(const ExplodedNode *N, const Stmt *S, // assert(!V.isUnknownOrUndef()); // Is it a symbolic value? - if (llvm::Optional<loc::MemRegionVal> L = V.getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> L = V.getAs<loc::MemRegionVal>()) { // At this point we are dealing with the region's LValue. // However, if the rvalue is a symbolic region, we should track it as well. SVal RVal = state->getSVal(L->getRegion()); @@ -766,7 +766,7 @@ PathDiagnosticPiece *NilReceiverBRVisitor::VisitNode(const ExplodedNode *N, return 0; ProgramStateRef state = N->getState(); const SVal &V = state->getSVal(Receiver, N->getLocationContext()); - llvm::Optional<DefinedOrUnknownSVal> DV = V.getAs<DefinedOrUnknownSVal>(); + Optional<DefinedOrUnknownSVal> DV = V.getAs<DefinedOrUnknownSVal>(); if (!DV) return 0; state = state->assume(*DV, true); @@ -951,7 +951,7 @@ bool ConditionBRVisitor::patternMatch(const Expr *Ex, raw_ostream &Out, BugReporterContext &BRC, BugReport &report, const ExplodedNode *N, - llvm::Optional<bool> &prunable) { + Optional<bool> &prunable) { const Expr *OriginalExpr = Ex; Ex = Ex->IgnoreParenCasts(); @@ -1010,7 +1010,7 @@ ConditionBRVisitor::VisitTrueTest(const Expr *Cond, const ExplodedNode *N) { bool shouldInvert = false; - llvm::Optional<bool> shouldPrune; + Optional<bool> shouldPrune; SmallString<128> LhsString, RhsString; { diff --git a/lib/StaticAnalyzer/Core/CallEvent.cpp b/lib/StaticAnalyzer/Core/CallEvent.cpp index a09d483150..c5e3c051da 100644 --- a/lib/StaticAnalyzer/Core/CallEvent.cpp +++ b/lib/StaticAnalyzer/Core/CallEvent.cpp @@ -156,7 +156,7 @@ ProgramStateRef CallEvent::invalidateRegions(unsigned BlockCount, // If we are passing a location wrapped as an integer, unwrap it and // invalidate the values referred by the location. - if (llvm::Optional<nonloc::LocAsInteger> Wrapped = + if (Optional<nonloc::LocAsInteger> Wrapped = V.getAs<nonloc::LocAsInteger>()) V = Wrapped->getLoc(); else if (!V.getAs<Loc>()) @@ -854,12 +854,11 @@ RuntimeDefinition ObjCMethodCall::getRuntimeDefinition() const { typedef std::pair<const ObjCInterfaceDecl*, Selector> PrivateMethodKey; typedef llvm::DenseMap<PrivateMethodKey, - llvm::Optional<const ObjCMethodDecl *> > + Optional<const ObjCMethodDecl *> > PrivateMethodCache; static PrivateMethodCache PMC; - llvm::Optional<const ObjCMethodDecl *> &Val = - PMC[std::make_pair(IDecl, Sel)]; + Optional<const ObjCMethodDecl *> &Val = PMC[std::make_pair(IDecl, Sel)]; // Query lookupPrivateMethod() if the cache does not hit. if (!Val.hasValue()) diff --git a/lib/StaticAnalyzer/Core/Environment.cpp b/lib/StaticAnalyzer/Core/Environment.cpp index 481e1bfd37..fe352aa8b4 100644 --- a/lib/StaticAnalyzer/Core/Environment.cpp +++ b/lib/StaticAnalyzer/Core/Environment.cpp @@ -198,7 +198,7 @@ EnvironmentManager::removeDeadBindings(Environment Env, EBMapRef = EBMapRef.add(BlkExpr, X); // If the block expr's value is a memory region, then mark that region. - if (llvm::Optional<loc::MemRegionVal> R = X.getAs<loc::MemRegionVal>()) + if (Optional<loc::MemRegionVal> R = X.getAs<loc::MemRegionVal>()) SymReaper.markLive(R->getRegion()); // Mark all symbols in the block expr's value live. diff --git a/lib/StaticAnalyzer/Core/ExprEngine.cpp b/lib/StaticAnalyzer/Core/ExprEngine.cpp index a077056174..89df40fecb 100644 --- a/lib/StaticAnalyzer/Core/ExprEngine.cpp +++ b/lib/StaticAnalyzer/Core/ExprEngine.cpp @@ -118,8 +118,8 @@ ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) { svalBuilder.makeZeroVal(T), getContext().IntTy); - llvm::Optional<DefinedOrUnknownSVal> Constraint = - Constraint_untested.getAs<DefinedOrUnknownSVal>(); + Optional<DefinedOrUnknownSVal> Constraint = + Constraint_untested.getAs<DefinedOrUnknownSVal>(); if (!Constraint) break; @@ -138,7 +138,7 @@ ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) { const MemRegion *R = state->getRegion(SelfD, InitLoc); SVal V = state->getSVal(loc::MemRegionVal(R)); - if (llvm::Optional<Loc> LV = V.getAs<Loc>()) { + if (Optional<Loc> LV = V.getAs<Loc>()) { // Assume that the pointer value in 'self' is non-null. state = state->assume(*LV, true); assert(state && "'self' cannot be null"); @@ -154,7 +154,7 @@ ProgramStateRef ExprEngine::getInitialState(const LocationContext *InitLoc) { if (SFC->getParent() == 0) { loc::MemRegionVal L = svalBuilder.getCXXThis(MD, SFC); SVal V = state->getSVal(L); - if (llvm::Optional<Loc> LV = V.getAs<Loc>()) { + if (Optional<Loc> LV = V.getAs<Loc>()) { state = state->assume(*LV, true); assert(state && "'this' cannot be null"); } @@ -1328,7 +1328,7 @@ void ExprEngine::processIndirectGoto(IndirectGotoNodeBuilder &builder) { typedef IndirectGotoNodeBuilder::iterator iterator; - if (llvm::Optional<loc::GotoLabel> LV = V.getAs<loc::GotoLabel>()) { + if (Optional<loc::GotoLabel> LV = V.getAs<loc::GotoLabel>()) { const LabelDecl *L = LV->getLabel(); for (iterator I = builder.begin(), E = builder.end(); I != E; ++I) { @@ -1647,8 +1647,7 @@ ProgramStateRef ExprEngine::processPointerEscapedOnBind(ProgramStateRef State, bool escapes = true; // TODO: Move to StoreManager. - if (llvm::Optional<loc::MemRegionVal> regionLoc = - Loc.getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> regionLoc = Loc.getAs<loc::MemRegionVal>()) { escapes = !regionLoc->getRegion()->hasStackStorage(); if (!escapes) { @@ -1779,7 +1778,7 @@ void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE, Val, /* notifyChanges = */ !atDeclInit); const MemRegion *LocReg = 0; - if (llvm::Optional<loc::MemRegionVal> LocRegVal = + if (Optional<loc::MemRegionVal> LocRegVal = location.getAs<loc::MemRegionVal>()) { LocReg = LocRegVal->getRegion(); } @@ -1958,7 +1957,7 @@ void ExprEngine::evalEagerlyAssumeBinOpBifurcation(ExplodedNodeSet &Dst, ProgramStateRef state = Pred->getState(); SVal V = state->getSVal(Ex, Pred->getLocationContext()); - llvm::Optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>(); + Optional<nonloc::SymbolVal> SEV = V.getAs<nonloc::SymbolVal>(); if (SEV && SEV->isExpression()) { const std::pair<const ProgramPointTag *, const ProgramPointTag*> &tags = geteagerlyAssumeBinOpBifurcationTags(); @@ -2000,7 +1999,7 @@ void ExprEngine::VisitGCCAsmStmt(const GCCAsmStmt *A, ExplodedNode *Pred, SVal X = state->getSVal(*OI, Pred->getLocationContext()); assert (!X.getAs<NonLoc>()); // Should be an Lval, or unknown, undef. - if (llvm::Optional<Loc> LV = X.getAs<Loc>()) + if (Optional<Loc> LV = X.getAs<Loc>()) state = state->bindLoc(*LV, UnknownVal()); } diff --git a/lib/StaticAnalyzer/Core/ExprEngineC.cpp b/lib/StaticAnalyzer/Core/ExprEngineC.cpp index fe132df4b5..b93dfe1619 100644 --- a/lib/StaticAnalyzer/Core/ExprEngineC.cpp +++ b/lib/StaticAnalyzer/Core/ExprEngineC.cpp @@ -482,7 +482,7 @@ void ExprEngine::VisitDeclStmt(const DeclStmt *DS, ExplodedNode *Pred, // the lazy compound value when the variable is not a reference. if (AMgr.getLangOpts().CPlusPlus && VD->getType()->isRecordType() && !VD->getType()->isReferenceType()) { - if (llvm::Optional<loc::MemRegionVal> M = + if (Optional<loc::MemRegionVal> M = InitVal.getAs<loc::MemRegionVal>()) { InitVal = state->getSVal(M->getRegion()); assert(InitVal.getAs<nonloc::LazyCompoundVal>()); @@ -825,7 +825,7 @@ void ExprEngine::VisitUnaryOperator(const UnaryOperator* U, // Note: technically we do "E == 0", but this is the same in the // transfer functions as "0 == E". SVal Result; - if (llvm::Optional<Loc> LV = V.getAs<Loc>()) { + if (Optional<Loc> LV = V.getAs<Loc>()) { Loc X = svalBuilder.makeNull(); Result = evalBinOp(state, BO_EQ, *LV, X, U->getType()); } diff --git a/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp b/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp index 7e86a56759..cb3339d9cc 100644 --- a/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp +++ b/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp @@ -64,7 +64,7 @@ void ExprEngine::performTrivialCopy(NodeBuilder &Bldr, ExplodedNode *Pred, SVal V = Call.getArgSVal(0); // Make sure the value being copied is not unknown. - if (llvm::Optional<Loc> L = V.getAs<Loc>()) + if (Optional<Loc> L = V.getAs<Loc>()) V = Pred->getState()->getSVal(*L); evalBind(Dst, CtorExpr, Pred, ThisVal, V, true); @@ -319,7 +319,7 @@ void ExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred, (void)ObjTy; assert(!ObjTy->isRecordType()); SVal Location = State->getSVal(CNE, LCtx); - if (llvm::Optional<Loc> LV = Location.getAs<Loc>()) + if (Optional<Loc> LV = Location.getAs<Loc>()) State = State->bindLoc(*LV, State->getSVal(Init, LCtx)); } } diff --git a/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp b/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp index 69a5052e90..d276d92446 100644 --- a/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp +++ b/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp @@ -104,8 +104,7 @@ void ExprEngine::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S, SVal FalseV = svalBuilder.makeTruthVal(0); ProgramStateRef noElems = state->BindExpr(S, LCtx, FalseV); - if (llvm::Optional<loc::MemRegionVal> MV = - elementV.getAs<loc::MemRegionVal>()) + if (Optional<loc::MemRegionVal> MV = elementV.getAs<loc::MemRegionVal>()) if (const TypedValueRegion *R = dyn_cast<TypedValueRegion>(MV->getRegion())) { // FIXME: The proper thing to do is to really iterate over the diff --git a/lib/StaticAnalyzer/Core/MemRegion.cpp b/lib/StaticAnalyzer/Core/MemRegion.cpp index c48343a824..922a9849ab 100644 --- a/lib/StaticAnalyzer/Core/MemRegion.cpp +++ b/lib/StaticAnalyzer/Core/MemRegion.cpp @@ -1044,8 +1044,7 @@ RegionRawOffset ElementRegion::getAsArrayOffset() const { // FIXME: generalize to symbolic offsets. SVal index = ER->getIndex(); - if (llvm::Optional<nonloc::ConcreteInt> CI = - index.getAs<nonloc::ConcreteInt>()) { + if (Optional<nonloc::ConcreteInt> CI = index.getAs<nonloc::ConcreteInt>()) { // Update the offset. int64_t i = CI->getValue().getSExtValue(); @@ -1172,7 +1171,7 @@ RegionOffset MemRegion::getAsOffset() const { } SVal Index = ER->getIndex(); - if (llvm::Optional<nonloc::ConcreteInt> CI = + if (Optional<nonloc::ConcreteInt> CI = Index.getAs<nonloc::ConcreteInt>()) { // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. diff --git a/lib/StaticAnalyzer/Core/PathDiagnostic.cpp b/lib/StaticAnalyzer/Core/PathDiagnostic.cpp index c723bc8844..bbf2db3dde 100644 --- a/lib/StaticAnalyzer/Core/PathDiagnostic.cpp +++ b/lib/StaticAnalyzer/Core/PathDiagnostic.cpp @@ -213,9 +213,8 @@ void PathDiagnosticConsumer::HandlePathDiagnostic(PathDiagnostic *D) { Diags.InsertNode(OwningD.take()); } -static llvm::Optional<bool> comparePath(const PathPieces &X, - const PathPieces &Y); -static llvm::Optional<bool> +static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y); +static Optional<bool> compareControlFlow(const PathDiagnosticControlFlowPiece &X, const PathDiagnosticControlFlowPiece &Y) { FullSourceLoc XSL = X.getStartLocation().asLocation(); @@ -226,18 +225,16 @@ compareControlFlow(const PathDiagnosticControlFlowPiece &X, FullSourceLoc YEL = Y.getEndLocation().asLocation(); if (XEL != YEL) return XEL.isBeforeInTranslationUnitThan(YEL); - return llvm::Optional<bool>(); + return Optional<bool>(); } -static llvm::Optional<bool> -compareMacro(const PathDiagnosticMacroPiece &X, - const PathDiagnosticMacroPiece &Y) { +static Optional<bool> compareMacro(const PathDiagnosticMacroPiece &X, + const PathDiagnosticMacroPiece &Y) { return comparePath(X.subPieces, Y.subPieces); } -static llvm::Optional<bool> -compareCall(const PathDiagnosticCallPiece &X, - const PathDiagnosticCallPiece &Y) { +static Optional<bool> compareCall(const PathDiagnosticCallPiece &X, + const PathDiagnosticCallPiece &Y) { FullSourceLoc X_CEL = X.callEnter.asLocation(); FullSourceLoc Y_CEL = Y.callEnter.asLocation(); if (X_CEL != Y_CEL) @@ -253,8 +250,8 @@ compareCall(const PathDiagnosticCallPiece &X, return comparePath(X.path, Y.path); } -static llvm::Optional<bool> comparePiece(const PathDiagnosticPiece &X, - const PathDiagnosticPiece &Y) { +static Optional<bool> comparePiece(const PathDiagnosticPiece &X, + const PathDiagnosticPiece &Y) { if (X.getKind() != Y.getKind()) return X.getKind() < Y.getKind(); @@ -286,7 +283,7 @@ static llvm::Optional<bool> comparePiece(const PathDiagnosticPiece &X, return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X), cast<PathDiagnosticControlFlowPiece>(Y)); case clang::ento::PathDiagnosticPiece::Event: - return llvm::Optional<bool>(); + return Optional<bool>(); case clang::ento::PathDiagnosticPiece::Macro: return compareMacro(cast<PathDiagnosticMacroPiece>(X), cast<PathDiagnosticMacroPiece>(Y)); @@ -297,16 +294,15 @@ static llvm::Optional<bool> comparePiece(const PathDiagnosticPiece &X, llvm_unreachable("all cases handled"); } -static llvm::Optional<bool> comparePath(const PathPieces &X, - const PathPieces &Y) { +static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y) { if (X.size() != Y.size()) return X.size() < Y.size(); for (unsigned i = 0, n = X.size(); i != n; ++i) { - llvm::Optional<bool> b = comparePiece(*X[i], *Y[i]); + Optional<bool> b = comparePiece(*X[i], *Y[i]); if (b.hasValue()) return b.getValue(); } - return llvm::Optional<bool>(); + return Optional<bool>(); } static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) { @@ -344,7 +340,7 @@ static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) { if (*XI != *YI) return (*XI) < (*YI); } - llvm::Optional<bool> b = comparePath(X.path, Y.path); + Optional<bool> b = comparePath(X.path, Y.path); assert(b.hasValue()); return b.getValue(); } @@ -1029,7 +1025,7 @@ std::string StackHintGeneratorForSymbol::getMessage(const ExplodedNode *N){ } // Check if the parameter is a pointer to the symbol. - if (llvm::Optional<loc::MemRegionVal> Reg = SV.getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> Reg = SV.getAs<loc::MemRegionVal>()) { SVal PSV = State->getSVal(Reg->getRegion()); SymbolRef AS = PSV.getAsLocSymbol(); if (AS == Sym) { diff --git a/lib/StaticAnalyzer/Core/ProgramState.cpp b/lib/StaticAnalyzer/Core/ProgramState.cpp index 6c76ebfbe5..400569e49a 100644 --- a/lib/StaticAnalyzer/Core/ProgramState.cpp +++ b/lib/StaticAnalyzer/Core/ProgramState.cpp @@ -508,10 +508,10 @@ bool ScanReachableSymbols::scan(const SymExpr *sym) { } bool ScanReachableSymbols::scan(SVal val) { - if (llvm::Optional<loc::MemRegionVal> X = val.getAs<loc::MemRegionVal>()) + if (Optional<loc::MemRegionVal> X = val.getAs<loc::MemRegionVal>()) return scan(X->getRegion()); - if (llvm::Optional<nonloc::LazyCompoundVal> X = + if (Optional<nonloc::LazyCompoundVal> X = val.getAs<nonloc::LazyCompoundVal>()) { StoreManager &StoreMgr = state->getStateManager().getStoreManager(); // FIXME: We don't really want to use getBaseRegion() here because pointer @@ -523,8 +523,7 @@ bool ScanReachableSymbols::scan(SVal val) { return false; } - if (llvm::Optional<nonloc::LocAsInteger> X = - val.getAs<nonloc::LocAsInteger>()) + if (Optional<nonloc::LocAsInteger> X = val.getAs<nonloc::LocAsInteger>()) return scan(X->getLoc()); if (SymbolRef Sym = val.getAsSymbol()) @@ -533,7 +532,7 @@ bool ScanReachableSymbols::scan(SVal val) { if (const SymExpr *Sym = val.getAsSymbolicExpression()) return scan(Sym); - if (llvm::Optional<nonloc::CompoundVal> X = val.getAs<nonloc::CompoundVal>()) + if (Optional<nonloc::CompoundVal> X = val.getAs<nonloc::CompoundVal>()) return scan(*X); return true; diff --git a/lib/StaticAnalyzer/Core/RegionStore.cpp b/lib/StaticAnalyzer/Core/RegionStore.cpp index b5e31d2f52..799022eee0 100644 --- a/lib/StaticAnalyzer/Core/RegionStore.cpp +++ b/lib/StaticAnalyzer/Core/RegionStore.cpp @@ -30,7 +30,6 @@ using namespace clang; using namespace ento; -using llvm::Optional; //===----------------------------------------------------------------------===// // Representation of binding keys. @@ -753,7 +752,7 @@ static void collectSubRegionKeys(SmallVectorImpl<BindingKey> &Keys, // be using this function anyway. uint64_t Length = UINT64_MAX; SVal Extent = Top->getExtent(SVB); - if (llvm::Optional<nonloc::ConcreteInt> ExtentCI = + if (Optional<nonloc::ConcreteInt> ExtentCI = Extent.getAs<nonloc::ConcreteInt>()) { const llvm::APSInt &ExtentInt = ExtentCI->getValue(); assert(ExtentInt.isNonNegative() || ExtentInt.isUnsigned()); @@ -894,7 +893,7 @@ void invalidateRegionsWorker::VisitBinding(SVal V) { } // Is it a LazyCompoundVal? All references get invalidated as well. - if (llvm::Optional<nonloc::LazyCompoundVal> LCS = + if (Optional<nonloc::LazyCompoundVal> LCS = V.getAs<nonloc::LazyCompoundVal>()) { const RegionStoreManager::SValListTy &Vals = RM.getInterestingValues(*LCS); @@ -939,7 +938,7 @@ void invalidateRegionsWorker::VisitBaseRegion(const MemRegion *baseR) { // a pointer value, but the thing pointed by that pointer may // get invalidated. SVal V = RM.getBinding(B, loc::MemRegionVal(VR)); - if (llvm::Optional<Loc> L = V.getAs<Loc>()) { + if (Optional<Loc> L = V.getAs<Loc>()) { if (const MemRegion *LR = L->getAsRegion()) AddToWorkList(LR); } @@ -1264,7 +1263,7 @@ RegionStoreManager::getLazyBinding(RegionBindingsConstRef B, if (originalRegion != R) { if (Optional<SVal> OV = B.getDefaultBinding(R)) { - if (llvm::Optional<nonloc::LazyCompoundVal> V = + if (Optional<nonloc::LazyCompoundVal> V = OV->getAs<nonloc::LazyCompoundVal>()) return std::make_pair(V->getStore(), V->getRegion()); } @@ -1346,8 +1345,7 @@ SVal RegionStoreManager::getBindingForElement(RegionBindingsConstRef B, const StringLiteral *Str = StrR->getStringLiteral(); SVal Idx = R->getIndex(); - if (llvm::Optional<nonloc::ConcreteInt> CI = - Idx.getAs<nonloc::ConcreteInt>()) { + if (Optional<nonloc::ConcreteInt> CI = Idx.getAs<nonloc::ConcreteInt>()) { int64_t i = CI->getValue().getSExtValue(); // Abort on string underrun. This can be possible by arbitrary // clients of getBindingForElement(). @@ -1652,7 +1650,7 @@ RegionStoreManager::getInterestingValues(nonloc::LazyCompoundVal LCV) { if (V.isUnknownOrUndef() || V.isConstant()) continue; - if (llvm::Optional<nonloc::LazyCompoundVal> InnerLCV = + if (Optional<nonloc::LazyCompoundVal> InnerLCV = V.getAs<nonloc::LazyCompoundVal>()) { const SValListTy &InnerList = getInterestingValues(*InnerLCV); List.insert(List.end(), InnerList.begin(), InnerList.end()); @@ -1670,7 +1668,7 @@ NonLoc RegionStoreManager::createLazyBinding(RegionBindingsConstRef B, // If we already have a lazy binding, and it's for the whole structure, // don't create a new lazy binding. if (Optional<SVal> V = B.getDefaultBinding(R)) { - if (llvm::Optional<nonloc::LazyCompoundVal> LCV = + if (Optional<nonloc::LazyCompoundVal> LCV = V->getAs<nonloc::LazyCompoundVal>()) { QualType RegionTy = R->getValueType(); QualType SourceRegionTy = LCV->getRegion()->getValueType(); @@ -1728,7 +1726,7 @@ bool RegionStoreManager::includedInBindings(Store store, //===----------------------------------------------------------------------===// StoreRef RegionStoreManager::killBinding(Store ST, Loc L) { - if (llvm::Optional<loc::MemRegionVal> LV = L.getAs<loc::MemRegionVal>()) + if (Optional<loc::MemRegionVal> LV = L.getAs<loc::MemRegionVal>()) if (const MemRegion* R = LV->getRegion()) return StoreRef(getRegionBindings(ST).removeBinding(R) .asImmutableMap() @@ -1820,7 +1818,7 @@ RegionStoreManager::bindArray(RegionBindingsConstRef B, Size = CAT->getSize().getZExtValue(); // Check if the init expr is a string literal. - if (llvm::Optional<loc::MemRegionVal> MRV = Init.getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> MRV = Init.getAs<loc::MemRegionVal>()) { const StringRegion *S = cast<StringRegion>(MRV->getRegion()); // Treat the string as a lazy compound value. @@ -2057,7 +2055,7 @@ void removeDeadBindingsWorker::VisitCluster(const MemRegion *baseR, void removeDeadBindingsWorker::VisitBinding(SVal V) { // Is it a LazyCompoundVal? All referenced regions are live as well. - if (llvm::Optional<nonloc::LazyCompoundVal> LCS = + if (Optional<nonloc::LazyCompoundVal> LCS = V.getAs<nonloc::LazyCompoundVal>()) { const RegionStoreManager::SValListTy &Vals = RM.getInterestingValues(*LCS); diff --git a/lib/StaticAnalyzer/Core/SValBuilder.cpp b/lib/StaticAnalyzer/Core/SValBuilder.cpp index d099a8fca8..c72e780801 100644 --- a/lib/StaticAnalyzer/Core/SValBuilder.cpp +++ b/lib/StaticAnalyzer/Core/SValBuilder.cpp @@ -78,8 +78,7 @@ SVal SValBuilder::convertToArrayIndex(SVal val) { return val; // Common case: we have an appropriately sized integer. - if (llvm::Optional<nonloc::ConcreteInt> CI = - val.getAs<nonloc::ConcreteInt>()) { + if (Optional<nonloc::ConcreteInt> CI = val.getAs<nonloc::ConcreteInt>()) { const llvm::APSInt& I = CI->getValue(); if (I.getBitWidth() == ArrayIndexWidth && I.isSigned()) return val; @@ -238,13 +237,11 @@ SVal SValBuilder::makeSymExprValNN(ProgramStateRef State, return makeNonLoc(symLHS, Op, symRHS, ResultTy); if (symLHS && symLHS->computeComplexity() < MaxComp) - if (llvm::Optional<nonloc::ConcreteInt> rInt = - RHS.getAs<nonloc::ConcreteInt>()) + if (Optional<nonloc::ConcreteInt> rInt = RHS.getAs<nonloc::ConcreteInt>()) return makeNonLoc(symLHS, Op, rInt->getValue(), ResultTy); if (symRHS && symRHS->computeComplexity() < MaxComp) - if (llvm::Optional<nonloc::ConcreteInt> lInt = - LHS.getAs<nonloc::ConcreteInt>()) + if (Optional<nonloc::ConcreteInt> lInt = LHS.getAs<nonloc::ConcreteInt>()) return makeNonLoc(lInt->getValue(), Op, symRHS, ResultTy); return UnknownVal(); @@ -260,14 +257,14 @@ SVal SValBuilder::evalBinOp(ProgramStateRef state, BinaryOperator::Opcode op, if (lhs.isUnknown() || rhs.isUnknown()) return UnknownVal(); - if (llvm::Optional<Loc> LV = lhs.getAs<Loc>()) { - if (llvm::Optional<Loc> RV = rhs.getAs<Loc>()) + if (Optional<Loc> LV = lhs.getAs<Loc>()) { + if (Optional<Loc> RV = rhs.getAs<Loc>()) return evalBinOpLL(state, op, *LV, *RV, type); return evalBinOpLN(state, op, *LV, rhs.castAs<NonLoc>(), type); } - if (llvm::Optional<Loc> RV = rhs.getAs<Loc>()) { + if (Optional<Loc> RV = rhs.getAs<Loc>()) { // Support pointer arithmetic where the addend is on the left // and the pointer on the right. assert(op == BO_Add); @@ -335,8 +332,7 @@ SVal SValBuilder::evalCast(SVal val, QualType castTy, QualType originalTy) { // Check for casts from integers to pointers. if (Loc::isLocType(castTy) && originalTy->isIntegerType()) { - if (llvm::Optional<nonloc::LocAsInteger> LV = - val.getAs<nonloc::LocAsInteger>()) { + if (Optional<nonloc::LocAsInteger> LV = val.getAs<nonloc::LocAsInteger>()) { if (const MemRegion *R = LV->getLoc().getAsRegion()) { StoreManager &storeMgr = StateMgr.getStoreManager(); R = storeMgr.castRegion(R, castTy); diff --git a/lib/StaticAnalyzer/Core/SVals.cpp b/lib/StaticAnalyzer/Core/SVals.cpp index 72959f506d..da52a90ec5 100644 --- a/lib/StaticAnalyzer/Core/SVals.cpp +++ b/lib/StaticAnalyzer/Core/SVals.cpp @@ -30,13 +30,13 @@ using llvm::APSInt; //===----------------------------------------------------------------------===// bool SVal::hasConjuredSymbol() const { - if (llvm::Optional<nonloc::SymbolVal> SV = getAs<nonloc::SymbolVal>()) { + if (Optional<nonloc::SymbolVal> SV = getAs<nonloc::SymbolVal>()) { SymbolRef sym = SV->getSymbol(); if (isa<SymbolConjured>(sym)) return true; } - if (llvm::Optional<loc::MemRegionVal> RV = getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> RV = getAs<loc::MemRegionVal>()) { const MemRegion *R = RV->getRegion(); if (const SymbolicRegion *SR = dyn_cast<SymbolicRegion>(R)) { SymbolRef sym = SR->getSymbol(); @@ -49,7 +49,7 @@ bool SVal::hasConjuredSymbol() const { } const FunctionDecl *SVal::getAsFunctionDecl() const { - if (llvm::Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) { const MemRegion* R = X->getRegion(); if (const FunctionTextRegion *CTR = R->getAs<FunctionTextRegion>()) if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CTR->getDecl())) @@ -66,10 +66,10 @@ const FunctionDecl *SVal::getAsFunctionDecl() const { /// region. If that is the case, gets the underlining region. SymbolRef SVal::getAsLocSymbol() const { // FIXME: should we consider SymbolRef wrapped in CodeTextRegion? - if (llvm::Optional<nonloc::LocAsInteger> X = getAs<nonloc::LocAsInteger>()) + if (Optional<nonloc::LocAsInteger> X = getAs<nonloc::LocAsInteger>()) return X->getLoc().getAsLocSymbol(); - if (llvm::Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) { + if (Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) { const MemRegion *R = X->stripCasts(); if (const SymbolicRegion *SymR = dyn_cast<SymbolicRegion>(R)) return SymR->getSymbol(); @@ -79,7 +79,7 @@ SymbolRef SVal::getAsLocSymbol() const { /// Get the symbol in the SVal or its base region. SymbolRef SVal::getLocSymbolInBase() const { - llvm::Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>(); + Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>(); if (!X) return 0; @@ -102,7 +102,7 @@ SymbolRef SVal::getLocSymbolInBase() const { /// Otherwise return 0. SymbolRef SVal::getAsSymbol() const { // FIXME: should we consider SymbolRef wrapped in CodeTextRegion? - if (llvm::Optional<nonloc::SymbolVal> X = getAs<nonloc::SymbolVal>()) + if (Optional<nonloc::SymbolVal> X = getAs<nonloc::SymbolVal>()) return X->getSymbol(); return getAsLocSymbol(); @@ -111,7 +111,7 @@ SymbolRef SVal::getAsSymbol() const { /// getAsSymbolicExpression - If this Sval wraps a symbolic expression then /// return that expression. Otherwise return NULL. const SymExpr *SVal::getAsSymbolicExpression() const { - if (llvm::Optional<nonloc::SymbolVal> X = getAs<nonloc::SymbolVal>()) + if (Optional<nonloc::SymbolVal> X = getAs<nonloc::SymbolVal>()) return X->getSymbol(); return getAsSymbol(); @@ -125,10 +125,10 @@ const SymExpr* SVal::getAsSymExpr() const { } const MemRegion *SVal::getAsRegion() const { - if (llvm::Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) + if (Optional<loc::MemRegionVal> X = getAs<loc::MemRegionVal>()) return X->getRegion(); - if (llvm::Optional<nonloc::LocAsInteger> X = getAs<nonloc::LocAsInteger>()) + if (Optional<nonloc::LocAsInteger> X = getAs<nonloc::LocAsInteger>()) return X->getLoc().getAsRegion(); return 0; @@ -168,9 +168,9 @@ bool SVal::isConstant() const { } bool SVal::isConstant(int I) const { - if (llvm::Optional<loc::ConcreteInt> LV = getAs<loc::ConcreteInt>()) + if (Optional<loc::ConcreteInt> LV = getAs<loc::ConcreteInt>()) return LV->getValue() == I; - if (llvm::Optional<nonloc::ConcreteInt> NV = getAs<nonloc::ConcreteInt>()) + if (Optional<nonloc::ConcreteInt> NV = getAs<nonloc::ConcreteInt>()) return NV->getValue() == I; return false; } diff --git a/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp b/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp index 3838830fa9..de13241cac 100644 --- a/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp +++ b/lib/StaticAnalyzer/Core/SimpleConstraintManager.cpp @@ -24,7 +24,7 @@ namespace ento { SimpleConstraintManager::~SimpleConstraintManager() {} bool SimpleConstraintManager::canReasonAbout(SVal X) const { - llvm::Optional<nonloc::SymbolVal> SymVal = X.getAs<nonloc::SymbolVal>(); + Optional<nonloc::SymbolVal> SymVal = X.getAs<nonloc::SymbolVal>(); if (SymVal && SymVal->isExpression()) { const SymExpr *SE = SymVal->getSymbol(); @@ -58,7 +58,7 @@ bool SimpleConstraintManager::canReasonAbout(SVal X) const { ProgramStateRef SimpleConstraintManager::assume(ProgramStateRef state, DefinedSVal Cond, bool Assumption) { - if (llvm::Optional<NonLoc> NV = Cond.getAs<NonLoc>()) + if (Optional<NonLoc> NV = Cond.getAs<NonLoc>()) return assume(state, *NV, Assumption); return assume(state, Cond.castAs<Loc>(), Assumption); } diff --git a/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp b/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp index 080e81d2ce..3e50c33000 100644 --- a/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp +++ b/lib/StaticAnalyzer/Core/SimpleSValBuilder.cpp @@ -69,8 +69,7 @@ SVal SimpleSValBuilder::evalCastFromNonLoc(NonLoc val, QualType castTy) { bool isLocType = Loc::isLocType(castTy); - if (llvm::Optional<nonloc::LocAsInteger> LI = - val.getAs<nonloc::LocAsInteger>()) { + if (Optional<nonloc::LocAsInteger> LI = val.getAs<nonloc::LocAsInteger>()) { if (isLocType) return LI->getLoc(); @@ -607,10 +606,10 @@ SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state, } // If both operands are constants, just perform the operation. - if (llvm::Optional<loc::ConcreteInt> rInt = rhs.getAs<loc::ConcreteInt>()) { + if (Optional<loc::ConcreteInt> rInt = rhs.getAs<loc::ConcreteInt>()) { SVal ResultVal = lhs.castAs<loc::ConcreteInt>().evalBinOp(BasicVals, op, *rInt); - if (llvm::Optional<Loc> Result = ResultVal.getAs<Loc>()) + if (Optional<Loc> Result = ResultVal.getAs<Loc>()) return evalCastFromLoc(*Result, resultTy); else return UnknownVal(); @@ -641,7 +640,7 @@ SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state, return UnknownVal(); } case loc::MemRegionKind: { - if (llvm::Optional<loc::ConcreteInt> rInt = rhs.getAs<loc::ConcreteInt>()) { + if (Optional<loc::ConcreteInt> rInt = rhs.getAs<loc::ConcreteInt>()) { // If one of the operands is a symbol and the other is a constant, // build an expression for use by the constraint manager. if (SymbolRef lSym = lhs.getAsLocSymbol()) @@ -739,7 +738,7 @@ SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state, // Get the left index and cast it to the correct type. // If the index is unknown or undefined, bail out here. SVal LeftIndexVal = LeftER->getIndex(); - llvm::Optional<NonLoc> LeftIndex = LeftIndexVal.getAs<NonLoc>(); + Optional<NonLoc> LeftIndex = LeftIndexVal.getAs<NonLoc>(); if (!LeftIndex) return UnknownVal(); LeftIndexVal = evalCastFromNonLoc(*LeftIndex, ArrayIndexTy); @@ -749,7 +748,7 @@ SVal SimpleSValBuilder::evalBinOpLL(ProgramStateRef state, // Do the same for the right index. SVal RightIndexVal = RightER->getIndex(); - llvm::Optional<NonLoc> RightIndex = RightIndexVal.getAs<NonLoc>(); + Optional<NonLoc> RightIndex = RightIndexVal.getAs<NonLoc>(); if (!RightIndex) return UnknownVal(); RightIndexVal = evalCastFromNonLoc(*RightIndex, ArrayIndexTy); @@ -863,7 +862,7 @@ SVal SimpleSValBuilder::evalBinOpLN(ProgramStateRef state, // can generate comparisons that trigger this code. // FIXME: Are all locations guaranteed to have pointer width? if (BinaryOperator::isComparisonOp(op)) { - if (llvm::Optional<nonloc::ConcreteInt> rhsInt = + if (Optional<nonloc::ConcreteInt> rhsInt = rhs.getAs<nonloc::ConcreteInt>()) { const llvm::APSInt *x = &rhsInt->getValue(); ASTContext &ctx = Context; @@ -881,10 +880,8 @@ SVal SimpleSValBuilder::evalBinOpLN(ProgramStateRef state, // We are dealing with pointer arithmetic. // Handle pointer arithmetic on constant values. - if (llvm::Optional<nonloc::ConcreteInt> rhsInt = - rhs.getAs<nonloc::ConcreteInt>()) { - if (llvm::Optional<loc::ConcreteInt> lhsInt = - lhs.getAs<loc::ConcreteInt>()) { + if (Optional<nonloc::ConcreteInt> rhsInt = rhs.getAs<nonloc::ConcreteInt>()) { + if (Optional<loc::ConcreteInt> lhsInt = lhs.getAs<loc::ConcreteInt>()) { const llvm::APSInt &leftI = lhsInt->getValue(); assert(leftI.isUnsigned()); llvm::APSInt rightI(rhsInt->getValue(), /* isUnsigned */ true); @@ -933,7 +930,7 @@ SVal SimpleSValBuilder::evalBinOpLN(ProgramStateRef state, elementType = resultTy->getPointeeType(); } - if (llvm::Optional<NonLoc> indexV = index.getAs<NonLoc>()) { + if (Optional<NonLoc> indexV = index.getAs<NonLoc>()) { return loc::MemRegionVal(MemMgr.getElementRegion(elementType, *indexV, superR, getContext())); } @@ -946,10 +943,10 @@ const llvm::APSInt *SimpleSValBuilder::getKnownValue(ProgramStateRef state, if (V.isUnknownOrUndef()) return NULL; - if (llvm::Optional<loc::ConcreteInt> X = V.getAs<loc::ConcreteInt>()) + if (Optional<loc::ConcreteInt> X = V.getAs<loc::ConcreteInt>()) return &X->getValue(); - if (llvm::Optional<nonloc::ConcreteInt> X = V.getAs<nonloc::ConcreteInt>()) + if (Optional<nonloc::ConcreteInt> X = V.getAs<nonloc::ConcreteInt>()) return &X->getValue(); if (SymbolRef Sym = V.getAsSymbol()) diff --git a/lib/StaticAnalyzer/Core/Store.cpp b/lib/StaticAnalyzer/Core/Store.cpp index 5177d0ed6f..3695cbcce8 100644 --- a/lib/StaticAnalyzer/Core/Store.cpp +++ b/lib/StaticAnalyzer/Core/Store.cpp @@ -270,7 +270,7 @@ SVal StoreManager::evalDerivedToBase(SVal Derived, const CXXBasePath &Path) { } SVal StoreManager::evalDerivedToBase(SVal Derived, QualType BaseType) { - llvm::Optional<loc::MemRegionVal> DerivedRegVal = + Optional<loc::MemRegionVal> DerivedRegVal = Derived.getAs<loc::MemRegionVal>(); if (!DerivedRegVal) return Derived; @@ -290,8 +290,7 @@ SVal StoreManager::evalDynamicCast(SVal Base, QualType DerivedType, bool &Failed) { Failed = false; - llvm::Optional<loc::MemRegionVal> BaseRegVal = - Base.getAs<loc::MemRegionVal>(); + Optional<loc::MemRegionVal> BaseRegVal = Base.getAs<loc::MemRegionVal>(); if (!BaseRegVal) return UnknownVal(); const MemRegion *BaseRegion = BaseRegVal->stripCasts(/*StripBases=*/false); |