Author: Fangrui Song Date: 2022-12-16T08:49:10Z New Revision: b1df3a2c0b6a42570042934cb79ca0e4359f863b
URL: https://github.com/llvm/llvm-project/commit/b1df3a2c0b6a42570042934cb79ca0e4359f863b DIFF: https://github.com/llvm/llvm-project/commit/b1df3a2c0b6a42570042934cb79ca0e4359f863b.diff LOG: [Support] llvm::Optional => std::optional https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716 Added: Modified: clang-tools-extra/clangd/support/Threading.cpp clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h clang/lib/CodeGen/CGObjC.cpp clang/lib/Lex/Lexer.cpp clang/lib/Lex/LiteralSupport.cpp clang/lib/Sema/SemaDeclAttr.cpp clang/lib/Serialization/ASTWriter.cpp clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp clang/tools/libclang/CIndex.cpp llvm/include/llvm/Support/Allocator.h llvm/include/llvm/Support/BinaryStreamRef.h llvm/include/llvm/Support/Casting.h llvm/include/llvm/Support/Error.h llvm/include/llvm/Support/FileUtilities.h llvm/include/llvm/Support/FormatProviders.h llvm/include/llvm/Support/FormatVariadic.h llvm/include/llvm/Support/KnownBits.h llvm/include/llvm/Support/LockFileManager.h llvm/include/llvm/Support/MemoryBuffer.h llvm/include/llvm/Support/NativeFormatting.h llvm/include/llvm/Support/SMTAPI.h llvm/include/llvm/Support/Unicode.h llvm/include/llvm/Support/VersionTuple.h llvm/include/llvm/Support/VirtualFileSystem.h llvm/include/llvm/Support/thread.h llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp llvm/lib/Support/BinaryStreamRef.cpp llvm/lib/Support/CrashRecoveryContext.cpp llvm/lib/Support/DJB.cpp llvm/lib/Support/FileUtilities.cpp llvm/lib/Support/FormatVariadic.cpp llvm/lib/Support/KnownBits.cpp llvm/lib/Support/LockFileManager.cpp llvm/lib/Support/MemoryBuffer.cpp llvm/lib/Support/NativeFormatting.cpp llvm/lib/Support/OptimizedStructLayout.cpp llvm/lib/Support/SymbolRemappingReader.cpp llvm/lib/Support/Threading.cpp llvm/lib/Support/UnicodeNameToCodepoint.cpp llvm/lib/Support/Unix/Threading.inc llvm/lib/Support/VersionTuple.cpp llvm/lib/Support/VirtualFileSystem.cpp llvm/lib/Support/Windows/Threading.inc llvm/lib/Support/Z3Solver.cpp llvm/unittests/ADT/StatisticTest.cpp llvm/unittests/Support/Casting.cpp llvm/unittests/Support/ErrorTest.cpp llvm/unittests/Support/KnownBitsTest.cpp llvm/unittests/Support/NativeFormatTests.cpp llvm/unittests/Support/Path.cpp llvm/unittests/Support/TypeTraitsTest.cpp mlir/lib/Support/FileUtilities.cpp Removed: ################################################################################ diff --git a/clang-tools-extra/clangd/support/Threading.cpp b/clang-tools-extra/clangd/support/Threading.cpp index 06d00c32d57d..be0d84cae3de 100644 --- a/clang-tools-extra/clangd/support/Threading.cpp +++ b/clang-tools-extra/clangd/support/Threading.cpp @@ -104,7 +104,7 @@ void AsyncTaskRunner::runAsync(const llvm::Twine &Name, // Ensure our worker threads have big enough stacks to run clang. llvm::thread Thread( - /*clang::DesiredStackSize*/ llvm::Optional<unsigned>(8 << 20), + /*clang::DesiredStackSize*/ std::optional<unsigned>(8 << 20), std::move(Task)); Thread.detach(); } diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h index cf515c5a809a..c4ed790f5a7b 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h @@ -128,7 +128,7 @@ class SMTConstraintManager : public clang::ento::SimpleConstraintManager { addStateConstraints(State); // Constraints are unsatisfiable - Optional<bool> isSat = Solver->check(); + std::optional<bool> isSat = Solver->check(); if (!isSat || !*isSat) return nullptr; @@ -145,7 +145,7 @@ class SMTConstraintManager : public clang::ento::SimpleConstraintManager { Solver->addConstraint(NotExp); - Optional<bool> isNotSat = Solver->check(); + std::optional<bool> isNotSat = Solver->check(); if (!isNotSat || *isNotSat) return nullptr; @@ -340,7 +340,7 @@ class SMTConstraintManager : public clang::ento::SimpleConstraintManager { Solver->reset(); addStateConstraints(NewState); - Optional<bool> res = Solver->check(); + std::optional<bool> res = Solver->check(); if (!res) Cached[hash] = ConditionTruthVal(); else diff --git a/clang/lib/CodeGen/CGObjC.cpp b/clang/lib/CodeGen/CGObjC.cpp index 961410c5b53e..42c766a3ec0e 100644 --- a/clang/lib/CodeGen/CGObjC.cpp +++ b/clang/lib/CodeGen/CGObjC.cpp @@ -3984,7 +3984,8 @@ static llvm::Value *emitIsPlatformVersionAtLeast(CodeGenFunction &CGF, llvm::SmallVector<llvm::Value *, 8> Args; auto EmitArgs = [&](const VersionTuple &Version, const llvm::Triple &TT) { - Optional<unsigned> Min = Version.getMinor(), SMin = Version.getSubminor(); + std::optional<unsigned> Min = Version.getMinor(), + SMin = Version.getSubminor(); Args.push_back( llvm::ConstantInt::get(CGM.Int32Ty, getBaseMachOPlatformID(TT))); Args.push_back(llvm::ConstantInt::get(CGM.Int32Ty, Version.getMajor())); @@ -4022,7 +4023,8 @@ CodeGenFunction::EmitBuiltinAvailable(const VersionTuple &Version) { CGM.CreateRuntimeFunction(FTy, "__isOSVersionAtLeast"); } - Optional<unsigned> Min = Version.getMinor(), SMin = Version.getSubminor(); + std::optional<unsigned> Min = Version.getMinor(), + SMin = Version.getSubminor(); llvm::Value *Args[] = { llvm::ConstantInt::get(CGM.Int32Ty, Version.getMajor()), llvm::ConstantInt::get(CGM.Int32Ty, Min.value_or(0)), diff --git a/clang/lib/Lex/Lexer.cpp b/clang/lib/Lex/Lexer.cpp index 4a9c5b5cd680..c93d3349c9ac 100644 --- a/clang/lib/Lex/Lexer.cpp +++ b/clang/lib/Lex/Lexer.cpp @@ -3355,9 +3355,9 @@ llvm::Optional<uint32_t> Lexer::tryReadNamedUCN(const char *&StartPtr, } StringRef Name(Buffer.data(), Buffer.size()); - llvm::Optional<char32_t> Match = + std::optional<char32_t> Match = llvm::sys::unicode::nameToCodepointStrict(Name); - llvm::Optional<llvm::sys::unicode::LooseMatchingResult> LooseMatch; + std::optional<llvm::sys::unicode::LooseMatchingResult> LooseMatch; if (!Match) { LooseMatch = llvm::sys::unicode::nameToCodepointLooseMatching(Name); if (Diagnose) { diff --git a/clang/lib/Lex/LiteralSupport.cpp b/clang/lib/Lex/LiteralSupport.cpp index 4ba4d94a600f..05575e8d6e2a 100644 --- a/clang/lib/Lex/LiteralSupport.cpp +++ b/clang/lib/Lex/LiteralSupport.cpp @@ -358,7 +358,7 @@ void clang::expandUCNs(SmallVectorImpl<char> &Buf, StringRef Input) { ++I; auto Delim = std::find(I, Input.end(), '}'); assert(Delim != Input.end()); - llvm::Optional<llvm::sys::unicode::LooseMatchingResult> Res = + std::optional<llvm::sys::unicode::LooseMatchingResult> Res = llvm::sys::unicode::nameToCodepointLooseMatching( StringRef(I, std::distance(I, Delim))); assert(Res); @@ -487,7 +487,7 @@ static void DiagnoseInvalidUnicodeCharacterName( namespace u = llvm::sys::unicode; - llvm::Optional<u::LooseMatchingResult> Res = + std::optional<u::LooseMatchingResult> Res = u::nameToCodepointLooseMatching(Name); if (Res) { Diag(Diags, Features, Loc, TokBegin, TokRangeBegin, TokRangeEnd, @@ -565,8 +565,7 @@ static bool ProcessNamedUCNEscape(const char *ThisTokBegin, } StringRef Name(ThisTokBuf, ClosingBrace - ThisTokBuf); ThisTokBuf = ClosingBrace + 1; - llvm::Optional<char32_t> Res = - llvm::sys::unicode::nameToCodepointStrict(Name); + std::optional<char32_t> Res = llvm::sys::unicode::nameToCodepointStrict(Name); if (!Res) { if (Diags) DiagnoseInvalidUnicodeCharacterName(Diags, Features, Loc, ThisTokBegin, diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index 93cc897e393f..a9fe447ef6a6 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -2634,7 +2634,7 @@ static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { } if (II->isStr("fuchsia")) { - Optional<unsigned> Min, Sub; + std::optional<unsigned> Min, Sub; if ((Min = Introduced.Version.getMinor()) || (Sub = Introduced.Version.getSubminor())) { S.Diag(AL.getLoc(), diag::warn_availability_fuchsia_unavailable_minor); diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 7469bcac18ee..935f3e7535cc 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -4466,11 +4466,11 @@ void ASTWriter::EmitRecordWithPath(unsigned Abbrev, RecordDataRef Record, void ASTWriter::AddVersionTuple(const VersionTuple &Version, RecordDataImpl &Record) { Record.push_back(Version.getMajor()); - if (Optional<unsigned> Minor = Version.getMinor()) + if (std::optional<unsigned> Minor = Version.getMinor()) Record.push_back(*Minor + 1); else Record.push_back(0); - if (Optional<unsigned> Subminor = Version.getSubminor()) + if (std::optional<unsigned> Subminor = Version.getSubminor()) Record.push_back(*Subminor + 1); else Record.push_back(0); diff --git a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp index e36716fe2aac..f47a524cadd6 100644 --- a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -3449,7 +3449,7 @@ void FalsePositiveRefutationBRVisitor::finalizeVisitor( } // And check for satisfiability - Optional<bool> IsSAT = RefutationSolver->check(); + std::optional<bool> IsSAT = RefutationSolver->check(); if (!IsSAT) return; diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp index 2c75e956ac70..f99275e4f243 100644 --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -7032,7 +7032,7 @@ void clang_enableStackTraces(void) { void clang_executeOnThread(void (*fn)(void *), void *user_data, unsigned stack_size) { llvm::thread Thread(stack_size == 0 ? clang::DesiredStackSize - : llvm::Optional<unsigned>(stack_size), + : std::optional<unsigned>(stack_size), fn, user_data); Thread.join(); } @@ -8236,13 +8236,13 @@ static CXVersion convertVersion(VersionTuple In) { Out.Major = In.getMajor(); - Optional<unsigned> Minor = In.getMinor(); + std::optional<unsigned> Minor = In.getMinor(); if (Minor) Out.Minor = *Minor; else return Out; - Optional<unsigned> Subminor = In.getSubminor(); + std::optional<unsigned> Subminor = In.getSubminor(); if (Subminor) Out.Subminor = *Subminor; diff --git a/llvm/include/llvm/Support/Allocator.h b/llvm/include/llvm/Support/Allocator.h index 8a70709c6784..ab3e12216d98 100644 --- a/llvm/include/llvm/Support/Allocator.h +++ b/llvm/include/llvm/Support/Allocator.h @@ -229,7 +229,7 @@ class BumpPtrAllocatorImpl /// The returned value is negative iff the object is inside a custom-size /// slab. /// Returns an empty optional if the pointer is not found in the allocator. - llvm::Optional<int64_t> identifyObject(const void *Ptr) { + std::optional<int64_t> identifyObject(const void *Ptr) { const char *P = static_cast<const char *>(Ptr); int64_t InSlabIdx = 0; for (size_t Idx = 0, E = Slabs.size(); Idx < E; Idx++) { @@ -256,7 +256,7 @@ class BumpPtrAllocatorImpl /// \return An index uniquely and reproducibly identifying /// an input pointer \p Ptr in the given allocator. int64_t identifyKnownObject(const void *Ptr) { - Optional<int64_t> Out = identifyObject(Ptr); + std::optional<int64_t> Out = identifyObject(Ptr); assert(Out && "Wrong allocator used"); return *Out; } diff --git a/llvm/include/llvm/Support/BinaryStreamRef.h b/llvm/include/llvm/Support/BinaryStreamRef.h index 46fc9fb293df..0cea224527ac 100644 --- a/llvm/include/llvm/Support/BinaryStreamRef.h +++ b/llvm/include/llvm/Support/BinaryStreamRef.h @@ -10,12 +10,12 @@ #define LLVM_SUPPORT_BINARYSTREAMREF_H #include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/Optional.h" #include "llvm/Support/BinaryStream.h" #include "llvm/Support/BinaryStreamError.h" #include "llvm/Support/Error.h" #include <cstdint> #include <memory> +#include <optional> namespace llvm { @@ -30,11 +30,11 @@ template <class RefType, class StreamType> class BinaryStreamRefBase { } BinaryStreamRefBase(std::shared_ptr<StreamType> SharedImpl, uint64_t Offset, - Optional<uint64_t> Length) + std::optional<uint64_t> Length) : SharedImpl(SharedImpl), BorrowedImpl(SharedImpl.get()), ViewOffset(Offset), Length(Length) {} BinaryStreamRefBase(StreamType &BorrowedImpl, uint64_t Offset, - Optional<uint64_t> Length) + std::optional<uint64_t> Length) : BorrowedImpl(&BorrowedImpl), ViewOffset(Offset), Length(Length) {} BinaryStreamRefBase(const BinaryStreamRefBase &Other) = default; BinaryStreamRefBase &operator=(const BinaryStreamRefBase &Other) = default; @@ -142,7 +142,7 @@ template <class RefType, class StreamType> class BinaryStreamRefBase { std::shared_ptr<StreamType> SharedImpl; StreamType *BorrowedImpl = nullptr; uint64_t ViewOffset = 0; - Optional<uint64_t> Length; + std::optional<uint64_t> Length; }; /// BinaryStreamRef is to BinaryStream what ArrayRef is to an Array. It @@ -157,14 +157,14 @@ class BinaryStreamRef friend BinaryStreamRefBase<BinaryStreamRef, BinaryStream>; friend class WritableBinaryStreamRef; BinaryStreamRef(std::shared_ptr<BinaryStream> Impl, uint64_t ViewOffset, - Optional<uint64_t> Length) + std::optional<uint64_t> Length) : BinaryStreamRefBase(Impl, ViewOffset, Length) {} public: BinaryStreamRef() = default; BinaryStreamRef(BinaryStream &Stream); BinaryStreamRef(BinaryStream &Stream, uint64_t Offset, - Optional<uint64_t> Length); + std::optional<uint64_t> Length); explicit BinaryStreamRef(ArrayRef<uint8_t> Data, llvm::support::endianness Endian); explicit BinaryStreamRef(StringRef Data, llvm::support::endianness Endian); @@ -222,7 +222,7 @@ class WritableBinaryStreamRef WritableBinaryStream> { friend BinaryStreamRefBase<WritableBinaryStreamRef, WritableBinaryStream>; WritableBinaryStreamRef(std::shared_ptr<WritableBinaryStream> Impl, - uint64_t ViewOffset, Optional<uint64_t> Length) + uint64_t ViewOffset, std::optional<uint64_t> Length) : BinaryStreamRefBase(Impl, ViewOffset, Length) {} Error checkOffsetForWrite(uint64_t Offset, uint64_t DataSize) const { @@ -238,7 +238,7 @@ class WritableBinaryStreamRef WritableBinaryStreamRef() = default; WritableBinaryStreamRef(WritableBinaryStream &Stream); WritableBinaryStreamRef(WritableBinaryStream &Stream, uint64_t Offset, - Optional<uint64_t> Length); + std::optional<uint64_t> Length); explicit WritableBinaryStreamRef(MutableArrayRef<uint8_t> Data, llvm::support::endianness Endian); WritableBinaryStreamRef(const WritableBinaryStreamRef &Other) = default; diff --git a/llvm/include/llvm/Support/Casting.h b/llvm/include/llvm/Support/Casting.h index 8a2fa94f9cca..9d1228b5a134 100644 --- a/llvm/include/llvm/Support/Casting.h +++ b/llvm/include/llvm/Support/Casting.h @@ -14,11 +14,11 @@ #ifndef LLVM_SUPPORT_CASTING_H #define LLVM_SUPPORT_CASTING_H -#include "llvm/ADT/Optional.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/type_traits.h" #include <cassert> #include <memory> +#include <optional> #include <type_traits> namespace llvm { @@ -263,8 +263,8 @@ struct CastIsPossible { // over. In fact, some of the isa_impl templates should be moved over to // CastIsPossible. template <typename To, typename From> -struct CastIsPossible<To, Optional<From>> { - static inline bool isPossible(const Optional<From> &f) { +struct CastIsPossible<To, std::optional<From>> { + static inline bool isPossible(const std::optional<From> &f) { assert(f && "CastIsPossible::isPossible called on a nullopt!"); return isa_impl_wrap< To, const From, @@ -359,18 +359,18 @@ struct UniquePtrCast : public CastIsPossible<To, From *> { } }; -/// This cast trait provides Optional<T> casting. This means that if you have a -/// value type, you can cast it to another value type and have dyn_cast return -/// an Optional<T>. +/// This cast trait provides std::optional<T> casting. This means that if you +/// have a value type, you can cast it to another value type and have dyn_cast +/// return an std::optional<T>. template <typename To, typename From, typename Derived = void> struct OptionalValueCast : public CastIsPossible<To, From>, public DefaultDoCastIfPossible< - Optional<To>, From, + std::optional<To>, From, detail::SelfType<Derived, OptionalValueCast<To, From>>> { - static inline Optional<To> castFailed() { return Optional<To>{}; } + static inline std::optional<To> castFailed() { return std::optional<To>{}; } - static inline Optional<To> doCast(const From &f) { return To(f); } + static inline std::optional<To> doCast(const From &f) { return To(f); } }; /// Provides a cast trait that strips `const` from types to make it easier to @@ -533,11 +533,12 @@ struct CastInfo<To, From, std::enable_if_t<!is_simple_type<From>::value>> { template <typename To, typename From> struct CastInfo<To, std::unique_ptr<From>> : public UniquePtrCast<To, From> {}; -/// Provide a CastInfo specialized for Optional<From>. It's assumed that if the -/// input is Optional<From> that the output can be Optional<To>. If that's not -/// the case, specialize CastInfo for your use case. +/// Provide a CastInfo specialized for std::optional<From>. It's assumed that if +/// the input is std::optional<From> that the output can be std::optional<To>. +/// If that's not the case, specialize CastInfo for your use case. template <typename To, typename From> -struct CastInfo<To, Optional<From>> : public OptionalValueCast<To, From> {}; +struct CastInfo<To, std::optional<From>> : public OptionalValueCast<To, From> { +}; /// isa<X> - Return true if the parameter to the template is an instance of one /// of the template type arguments. Used like this: @@ -606,10 +607,14 @@ template <typename T, typename Enable = void> struct ValueIsPresent { }; // Optional provides its own way to check if something is present. -template <typename T> struct ValueIsPresent<Optional<T>> { +template <typename T> struct ValueIsPresent<std::optional<T>> { using UnwrappedType = T; - static inline bool isPresent(const Optional<T> &t) { return t.has_value(); } - static inline decltype(auto) unwrapValue(Optional<T> &t) { return t.value(); } + static inline bool isPresent(const std::optional<T> &t) { + return t.has_value(); + } + static inline decltype(auto) unwrapValue(std::optional<T> &t) { + return t.value(); + } }; // If something is "nullable" then we just compare it to nullptr to see if it diff --git a/llvm/include/llvm/Support/Error.h b/llvm/include/llvm/Support/Error.h index c5eb4b3bf4d7..d821ab5b88fe 100644 --- a/llvm/include/llvm/Support/Error.h +++ b/llvm/include/llvm/Support/Error.h @@ -1039,7 +1039,7 @@ inline std::string toString(Error E) { /// /// Uses of this method are potentially indicative of design problems: If it's /// legitimate to do nothing while processing an "error", the error-producer -/// might be more clearly refactored to return an Optional<T>. +/// might be more clearly refactored to return an std::optional<T>. inline void consumeError(Error Err) { handleAllErrors(std::move(Err), [](const ErrorInfoBase &) {}); } @@ -1298,7 +1298,7 @@ class FileError final : public ErrorInfo<FileError> { static char ID; private: - FileError(const Twine &F, Optional<size_t> LineNum, + FileError(const Twine &F, std::optional<size_t> LineNum, std::unique_ptr<ErrorInfoBase> E) { assert(E && "Cannot create FileError from Error success value."); FileName = F.str(); @@ -1306,7 +1306,7 @@ class FileError final : public ErrorInfo<FileError> { Line = std::move(LineNum); } - static Error build(const Twine &F, Optional<size_t> Line, Error E) { + static Error build(const Twine &F, std::optional<size_t> Line, Error E) { std::unique_ptr<ErrorInfoBase> Payload; handleAllErrors(std::move(E), [&](std::unique_ptr<ErrorInfoBase> EIB) -> Error { @@ -1318,20 +1318,20 @@ class FileError final : public ErrorInfo<FileError> { } std::string FileName; - Optional<size_t> Line; + std::optional<size_t> Line; std::unique_ptr<ErrorInfoBase> Err; }; /// Concatenate a source file path and/or name with an Error. The resulting /// Error is unchecked. inline Error createFileError(const Twine &F, Error E) { - return FileError::build(F, Optional<size_t>(), std::move(E)); + return FileError::build(F, std::optional<size_t>(), std::move(E)); } /// Concatenate a source file path and/or name with line number and an Error. /// The resulting Error is unchecked. inline Error createFileError(const Twine &F, size_t Line, Error E) { - return FileError::build(F, Optional<size_t>(Line), std::move(E)); + return FileError::build(F, std::optional<size_t>(Line), std::move(E)); } /// Concatenate a source file path and/or name with a std::error_code diff --git a/llvm/include/llvm/Support/FileUtilities.h b/llvm/include/llvm/Support/FileUtilities.h index b641781da4ab..c9a72d5d14ec 100644 --- a/llvm/include/llvm/Support/FileUtilities.h +++ b/llvm/include/llvm/Support/FileUtilities.h @@ -121,8 +121,9 @@ namespace llvm { /// Apply stored permissions to the \p OutputFilename. /// Copy LastAccess and ModificationTime if \p CopyDates is true. /// Overwrite stored permissions if \p OverwritePermissions is specified. - Error apply(StringRef OutputFilename, bool CopyDates = false, - Optional<sys::fs::perms> OverwritePermissions = std::nullopt); + Error + apply(StringRef OutputFilename, bool CopyDates = false, + std::optional<sys::fs::perms> OverwritePermissions = std::nullopt); private: FilePermissionsApplier(StringRef InputFilename, sys::fs::file_status Status) diff --git a/llvm/include/llvm/Support/FormatProviders.h b/llvm/include/llvm/Support/FormatProviders.h index ab1245cfd4c0..3fcd1b38a967 100644 --- a/llvm/include/llvm/Support/FormatProviders.h +++ b/llvm/include/llvm/Support/FormatProviders.h @@ -59,9 +59,9 @@ struct use_double_formatter class HelperFunctions { protected: - static Optional<size_t> parseNumericPrecision(StringRef Str) { + static std::optional<size_t> parseNumericPrecision(StringRef Str) { size_t Prec; - Optional<size_t> Result; + std::optional<size_t> Result; if (Str.empty()) Result = std::nullopt; else if (Str.getAsInteger(10, Prec)) { @@ -312,7 +312,7 @@ struct format_provider<T, else S = FloatStyle::Fixed; - Optional<size_t> Precision = parseNumericPrecision(Style); + std::optional<size_t> Precision = parseNumericPrecision(Style); if (!Precision) Precision = getDefaultPrecision(S); diff --git a/llvm/include/llvm/Support/FormatVariadic.h b/llvm/include/llvm/Support/FormatVariadic.h index bc5cd3edf66f..ddd80d89f1cd 100644 --- a/llvm/include/llvm/Support/FormatVariadic.h +++ b/llvm/include/llvm/Support/FormatVariadic.h @@ -26,7 +26,6 @@ #define LLVM_SUPPORT_FORMATVARIADIC_H #include "llvm/ADT/ArrayRef.h" -#include "llvm/ADT/Optional.h" #include "llvm/ADT/STLExtras.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallVector.h" @@ -37,6 +36,7 @@ #include "llvm/Support/raw_ostream.h" #include <array> #include <cstddef> +#include <optional> #include <string> #include <tuple> #include <utility> @@ -103,7 +103,7 @@ class formatv_object_base { } static SmallVector<ReplacementItem, 2> parseFormatString(StringRef Fmt); - static Optional<ReplacementItem> parseReplacementItem(StringRef Spec); + static std::optional<ReplacementItem> parseReplacementItem(StringRef Spec); std::string str() const { std::string Result; diff --git a/llvm/include/llvm/Support/KnownBits.h b/llvm/include/llvm/Support/KnownBits.h index dbb3237bc59e..f20d3e112b83 100644 --- a/llvm/include/llvm/Support/KnownBits.h +++ b/llvm/include/llvm/Support/KnownBits.h @@ -15,7 +15,7 @@ #define LLVM_SUPPORT_KNOWNBITS_H #include "llvm/ADT/APInt.h" -#include "llvm/ADT/Optional.h" +#include <optional> namespace llvm { @@ -373,34 +373,34 @@ struct KnownBits { static KnownBits ashr(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_EQ result. - static Optional<bool> eq(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> eq(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_NE result. - static Optional<bool> ne(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> ne(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_UGT result. - static Optional<bool> ugt(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> ugt(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_UGE result. - static Optional<bool> uge(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> uge(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_ULT result. - static Optional<bool> ult(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> ult(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_ULE result. - static Optional<bool> ule(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> ule(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_SGT result. - static Optional<bool> sgt(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> sgt(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_SGE result. - static Optional<bool> sge(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> sge(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_SLT result. - static Optional<bool> slt(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> slt(const KnownBits &LHS, const KnownBits &RHS); /// Determine if these known bits always give the same ICMP_SLE result. - static Optional<bool> sle(const KnownBits &LHS, const KnownBits &RHS); + static std::optional<bool> sle(const KnownBits &LHS, const KnownBits &RHS); /// Update known bits based on ANDing with RHS. KnownBits &operator&=(const KnownBits &RHS); diff --git a/llvm/include/llvm/Support/LockFileManager.h b/llvm/include/llvm/Support/LockFileManager.h index ab66621e6756..92c7ceed6a92 100644 --- a/llvm/include/llvm/Support/LockFileManager.h +++ b/llvm/include/llvm/Support/LockFileManager.h @@ -8,8 +8,8 @@ #ifndef LLVM_SUPPORT_LOCKFILEMANAGER_H #define LLVM_SUPPORT_LOCKFILEMANAGER_H -#include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallString.h" +#include <optional> #include <system_error> #include <utility> // for std::pair @@ -54,14 +54,14 @@ class LockFileManager { SmallString<128> LockFileName; SmallString<128> UniqueLockFileName; - Optional<std::pair<std::string, int> > Owner; + std::optional<std::pair<std::string, int>> Owner; std::error_code ErrorCode; std::string ErrorDiagMsg; LockFileManager(const LockFileManager &) = delete; LockFileManager &operator=(const LockFileManager &) = delete; - static Optional<std::pair<std::string, int> > + static std::optional<std::pair<std::string, int>> readLockFile(StringRef LockFileName); static bool processStillExecuting(StringRef Hostname, int PID); diff --git a/llvm/include/llvm/Support/MemoryBuffer.h b/llvm/include/llvm/Support/MemoryBuffer.h index d6ae98e341f0..b3477f1db0e9 100644 --- a/llvm/include/llvm/Support/MemoryBuffer.h +++ b/llvm/include/llvm/Support/MemoryBuffer.h @@ -97,7 +97,7 @@ class MemoryBuffer { static ErrorOr<std::unique_ptr<MemoryBuffer>> getFile(const Twine &Filename, bool IsText = false, bool RequiresNullTerminator = true, bool IsVolatile = false, - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); /// Read all of the specified file into a MemoryBuffer as a stream /// (i.e. until EOF reached). This is useful for special files that @@ -111,7 +111,7 @@ class MemoryBuffer { static ErrorOr<std::unique_ptr<MemoryBuffer>> getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize, int64_t Offset, bool IsVolatile = false, - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); /// Given an already-open file descriptor, read the file and return a /// MemoryBuffer. @@ -125,7 +125,7 @@ class MemoryBuffer { static ErrorOr<std::unique_ptr<MemoryBuffer>> getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator = true, bool IsVolatile = false, - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); /// Open the specified memory range as a MemoryBuffer. Note that InputData /// must be null terminated if RequiresNullTerminator is true. @@ -149,13 +149,13 @@ class MemoryBuffer { static ErrorOr<std::unique_ptr<MemoryBuffer>> getFileOrSTDIN(const Twine &Filename, bool IsText = false, bool RequiresNullTerminator = true, - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); /// Map a subrange of the specified file as a MemoryBuffer. static ErrorOr<std::unique_ptr<MemoryBuffer>> getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsVolatile = false, - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); //===--------------------------------------------------------------------===// // Provided for performance analysis. @@ -201,13 +201,13 @@ class WritableMemoryBuffer : public MemoryBuffer { static ErrorOr<std::unique_ptr<WritableMemoryBuffer>> getFile(const Twine &Filename, bool IsVolatile = false, - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); /// Map a subrange of the specified file as a WritableMemoryBuffer. static ErrorOr<std::unique_ptr<WritableMemoryBuffer>> getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsVolatile = false, - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); /// Allocate a new MemoryBuffer of the specified size that is not initialized. /// Note that the caller should initialize the memory allocated by this @@ -217,7 +217,7 @@ class WritableMemoryBuffer : public MemoryBuffer { /// least the specified alignment. static std::unique_ptr<WritableMemoryBuffer> getNewUninitMemBuffer(size_t Size, const Twine &BufferName = "", - Optional<Align> Alignment = std::nullopt); + std::optional<Align> Alignment = std::nullopt); /// Allocate a new zero-initialized MemoryBuffer of the specified size. Note /// that the caller need not initialize the memory allocated by this method. diff --git a/llvm/include/llvm/Support/NativeFormatting.h b/llvm/include/llvm/Support/NativeFormatting.h index f94b0174edd4..6fc1ee8d190e 100644 --- a/llvm/include/llvm/Support/NativeFormatting.h +++ b/llvm/include/llvm/Support/NativeFormatting.h @@ -38,9 +38,9 @@ void write_integer(raw_ostream &S, long long N, size_t MinDigits, IntegerStyle Style); void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, - Optional<size_t> Width = std::nullopt); + std::optional<size_t> Width = std::nullopt); void write_double(raw_ostream &S, double D, FloatStyle Style, - Optional<size_t> Precision = std::nullopt); + std::optional<size_t> Precision = std::nullopt); } #endif diff --git a/llvm/include/llvm/Support/SMTAPI.h b/llvm/include/llvm/Support/SMTAPI.h index 24dcd124593e..9389c96956dd 100644 --- a/llvm/include/llvm/Support/SMTAPI.h +++ b/llvm/include/llvm/Support/SMTAPI.h @@ -419,7 +419,7 @@ class SMTSolver { llvm::APFloat &Float) = 0; /// Check if the constraints are satisfiable - virtual Optional<bool> check() const = 0; + virtual std::optional<bool> check() const = 0; /// Push the current solver state virtual void push() = 0; diff --git a/llvm/include/llvm/Support/Unicode.h b/llvm/include/llvm/Support/Unicode.h index 729775431e16..861548728d4f 100644 --- a/llvm/include/llvm/Support/Unicode.h +++ b/llvm/include/llvm/Support/Unicode.h @@ -14,8 +14,8 @@ #ifndef LLVM_SUPPORT_UNICODE_H #define LLVM_SUPPORT_UNICODE_H -#include "llvm/ADT/Optional.h" #include "llvm/ADT/SmallString.h" +#include <optional> #include <string> namespace llvm { @@ -67,14 +67,14 @@ int foldCharSimple(int C); /// For compatibility with the semantics of named character escape sequences in /// C++, this mapping does an exact match sensitive to casing and spacing. /// \return The codepoint of the corresponding character, if any. -Optional<char32_t> nameToCodepointStrict(StringRef Name); +std::optional<char32_t> nameToCodepointStrict(StringRef Name); struct LooseMatchingResult { char32_t CodePoint; SmallString<64> Name; }; -Optional<LooseMatchingResult> nameToCodepointLooseMatching(StringRef Name); +std::optional<LooseMatchingResult> nameToCodepointLooseMatching(StringRef Name); struct MatchForCodepointName { std::string Name; diff --git a/llvm/include/llvm/Support/VersionTuple.h b/llvm/include/llvm/Support/VersionTuple.h index a525fbe7009f..1483252f4f7d 100644 --- a/llvm/include/llvm/Support/VersionTuple.h +++ b/llvm/include/llvm/Support/VersionTuple.h @@ -72,21 +72,21 @@ class VersionTuple { unsigned getMajor() const { return Major; } /// Retrieve the minor version number, if provided. - Optional<unsigned> getMinor() const { + std::optional<unsigned> getMinor() const { if (!HasMinor) return std::nullopt; return Minor; } /// Retrieve the subminor version number, if provided. - Optional<unsigned> getSubminor() const { + std::optional<unsigned> getSubminor() const { if (!HasSubminor) return std::nullopt; return Subminor; } /// Retrieve the build version number, if provided. - Optional<unsigned> getBuild() const { + std::optional<unsigned> getBuild() const { if (!HasBuild) return std::nullopt; return Build; diff --git a/llvm/include/llvm/Support/VirtualFileSystem.h b/llvm/include/llvm/Support/VirtualFileSystem.h index a2ce22ebd5af..295ed63def9b 100644 --- a/llvm/include/llvm/Support/VirtualFileSystem.h +++ b/llvm/include/llvm/Support/VirtualFileSystem.h @@ -509,9 +509,9 @@ class InMemoryFileSystem : public FileSystem { /// Create node with \p MakeNode and add it into this filesystem at \p Path. bool addFile(const Twine &Path, time_t ModificationTime, std::unique_ptr<llvm::MemoryBuffer> Buffer, - Optional<uint32_t> User, Optional<uint32_t> Group, - Optional<llvm::sys::fs::file_type> Type, - Optional<llvm::sys::fs::perms> Perms, MakeNodeFn MakeNode); + std::optional<uint32_t> User, std::optional<uint32_t> Group, + std::optional<llvm::sys::fs::file_type> Type, + std::optional<llvm::sys::fs::perms> Perms, MakeNodeFn MakeNode); /// Looks up the in-memory node for the path \p P. /// If \p FollowFinalSymlink is true, the returned node is guaranteed to @@ -533,10 +533,10 @@ class InMemoryFileSystem : public FileSystem { /// diff erent contents. bool addFile(const Twine &Path, time_t ModificationTime, std::unique_ptr<llvm::MemoryBuffer> Buffer, - Optional<uint32_t> User = std::nullopt, - Optional<uint32_t> Group = std::nullopt, - Optional<llvm::sys::fs::file_type> Type = std::nullopt, - Optional<llvm::sys::fs::perms> Perms = std::nullopt); + std::optional<uint32_t> User = std::nullopt, + std::optional<uint32_t> Group = std::nullopt, + std::optional<llvm::sys::fs::file_type> Type = std::nullopt, + std::optional<llvm::sys::fs::perms> Perms = std::nullopt); /// Add a hard link to a file. /// @@ -561,11 +561,12 @@ class InMemoryFileSystem : public FileSystem { /// Add a symbolic link. Unlike a HardLink, because \p Target doesn't need /// to refer to a file (or refer to anything, as it happens). Also, an /// in-memory directory for \p Target isn't automatically created. - bool addSymbolicLink(const Twine &NewLink, const Twine &Target, - time_t ModificationTime, - Optional<uint32_t> User = std::nullopt, - Optional<uint32_t> Group = std::nullopt, - Optional<llvm::sys::fs::perms> Perms = std::nullopt); + bool + addSymbolicLink(const Twine &NewLink, const Twine &Target, + time_t ModificationTime, + std::optional<uint32_t> User = std::nullopt, + std::optional<uint32_t> Group = std::nullopt, + std::optional<llvm::sys::fs::perms> Perms = std::nullopt); /// Add a buffer to the VFS with a path. The VFS does not own the buffer. /// If present, User, Group, Type and Perms apply to the newly-created file @@ -575,10 +576,10 @@ class InMemoryFileSystem : public FileSystem { /// diff erent contents. bool addFileNoOwn(const Twine &Path, time_t ModificationTime, const llvm::MemoryBufferRef &Buffer, - Optional<uint32_t> User = std::nullopt, - Optional<uint32_t> Group = std::nullopt, - Optional<llvm::sys::fs::file_type> Type = std::nullopt, - Optional<llvm::sys::fs::perms> Perms = std::nullopt); + std::optional<uint32_t> User = std::nullopt, + std::optional<uint32_t> Group = std::nullopt, + std::optional<llvm::sys::fs::file_type> Type = std::nullopt, + std::optional<llvm::sys::fs::perms> Perms = std::nullopt); std::string toString() const; @@ -858,7 +859,7 @@ class RedirectingFileSystem : public vfs::FileSystem { /// When the found Entry is a DirectoryRemapEntry, stores the path in the /// external file system that the looked-up path in the virtual file system // corresponds to. - Optional<std::string> ExternalRedirect; + std::optional<std::string> ExternalRedirect; public: LookupResult(Entry *E, sys::path::const_iterator Start, @@ -867,7 +868,7 @@ class RedirectingFileSystem : public vfs::FileSystem { /// If the found Entry maps the the input path to a path in the external /// file system (i.e. it is a FileEntry or DirectoryRemapEntry), returns /// that path. - Optional<StringRef> getExternalRedirect() const { + std::optional<StringRef> getExternalRedirect() const { if (isa<DirectoryRemapEntry>(E)) return StringRef(*ExternalRedirect); if (auto *FE = dyn_cast<FileEntry>(E)) @@ -1016,9 +1017,9 @@ void collectVFSFromYAML( class YAMLVFSWriter { std::vector<YAMLVFSEntry> Mappings; - Optional<bool> IsCaseSensitive; - Optional<bool> IsOverlayRelative; - Optional<bool> UseExternalNames; + std::optional<bool> IsCaseSensitive; + std::optional<bool> IsOverlayRelative; + std::optional<bool> UseExternalNames; std::string OverlayDir; void addEntry(StringRef VirtualPath, StringRef RealPath, bool IsDirectory); diff --git a/llvm/include/llvm/Support/thread.h b/llvm/include/llvm/Support/thread.h index 660d31573a86..32599b9f7121 100644 --- a/llvm/include/llvm/Support/thread.h +++ b/llvm/include/llvm/Support/thread.h @@ -16,8 +16,8 @@ #ifndef LLVM_SUPPORT_THREAD_H #define LLVM_SUPPORT_THREAD_H -#include "llvm/ADT/Optional.h" #include "llvm/Config/llvm-config.h" +#include <optional> #ifdef _WIN32 typedef unsigned long DWORD; @@ -72,7 +72,7 @@ class thread { } #endif - static const llvm::Optional<unsigned> DefaultStackSize; + static const std::optional<unsigned> DefaultStackSize; thread() : Thread(native_handle_type()) {} thread(thread &&Other) noexcept @@ -83,7 +83,7 @@ class thread { : thread(DefaultStackSize, f, args...) {} template <class Function, class... Args> - explicit thread(llvm::Optional<unsigned> StackSizeInBytes, Function &&f, + explicit thread(std::optional<unsigned> StackSizeInBytes, Function &&f, Args &&...args); thread(const thread &) = delete; @@ -120,14 +120,14 @@ class thread { thread::native_handle_type llvm_execute_on_thread_impl(thread::start_routine_type ThreadFunc, void *Arg, - llvm::Optional<unsigned> StackSizeInBytes); + std::optional<unsigned> StackSizeInBytes); void llvm_thread_join_impl(thread::native_handle_type Thread); void llvm_thread_detach_impl(thread::native_handle_type Thread); thread::id llvm_thread_get_id_impl(thread::native_handle_type Thread); thread::id llvm_thread_get_current_id_impl(); template <class Function, class... Args> -thread::thread(llvm::Optional<unsigned> StackSizeInBytes, Function &&f, +thread::thread(std::optional<unsigned> StackSizeInBytes, Function &&f, Args &&...args) { typedef std::tuple<std::decay_t<Function>, std::decay_t<Args>...> CalleeTuple; std::unique_ptr<CalleeTuple> Callee( @@ -171,7 +171,7 @@ class thread { : Thread(std::exchange(Other.Thread, std::thread())) {} template <class Function, class... Args> - explicit thread(llvm::Optional<unsigned> StackSizeInBytes, Function &&f, + explicit thread(std::optional<unsigned> StackSizeInBytes, Function &&f, Args &&...args) : Thread(std::forward<Function>(f), std::forward<Args>(args)...) {} @@ -224,7 +224,7 @@ struct thread { thread() {} thread(thread &&other) {} template <class Function, class... Args> - explicit thread(llvm::Optional<unsigned> StackSizeInBytes, Function &&f, + explicit thread(std::optional<unsigned> StackSizeInBytes, Function &&f, Args &&...args) { f(std::forward<Args>(args)...); } diff --git a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp index c5d5d68d849c..5ff3dd26f5fc 100644 --- a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp +++ b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp @@ -4216,7 +4216,7 @@ bool CombinerHelper::matchICmpToTrueFalseKnownBits(MachineInstr &MI, auto Pred = static_cast<CmpInst::Predicate>(MI.getOperand(1).getPredicate()); auto KnownLHS = KB->getKnownBits(MI.getOperand(2).getReg()); auto KnownRHS = KB->getKnownBits(MI.getOperand(3).getReg()); - Optional<bool> KnownVal; + std::optional<bool> KnownVal; switch (Pred) { default: llvm_unreachable("Unexpected G_ICMP predicate?"); diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp index a0e7705e5843..a7716e893aa1 100644 --- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp @@ -2103,9 +2103,9 @@ bool TargetLowering::SimplifyDemandedBits( KnownBits Known0 = TLO.DAG.computeKnownBits(Op0, DemandedElts, Depth + 1); KnownBits Known1 = TLO.DAG.computeKnownBits(Op1, DemandedElts, Depth + 1); Known = KnownBits::umin(Known0, Known1); - if (Optional<bool> IsULE = KnownBits::ule(Known0, Known1)) + if (std::optional<bool> IsULE = KnownBits::ule(Known0, Known1)) return TLO.CombineTo(Op, IsULE.value() ? Op0 : Op1); - if (Optional<bool> IsULT = KnownBits::ult(Known0, Known1)) + if (std::optional<bool> IsULT = KnownBits::ult(Known0, Known1)) return TLO.CombineTo(Op, IsULT.value() ? Op0 : Op1); break; } @@ -2116,9 +2116,9 @@ bool TargetLowering::SimplifyDemandedBits( KnownBits Known0 = TLO.DAG.computeKnownBits(Op0, DemandedElts, Depth + 1); KnownBits Known1 = TLO.DAG.computeKnownBits(Op1, DemandedElts, Depth + 1); Known = KnownBits::umax(Known0, Known1); - if (Optional<bool> IsUGE = KnownBits::uge(Known0, Known1)) + if (std::optional<bool> IsUGE = KnownBits::uge(Known0, Known1)) return TLO.CombineTo(Op, IsUGE.value() ? Op0 : Op1); - if (Optional<bool> IsUGT = KnownBits::ugt(Known0, Known1)) + if (std::optional<bool> IsUGT = KnownBits::ugt(Known0, Known1)) return TLO.CombineTo(Op, IsUGT.value() ? Op0 : Op1); break; } diff --git a/llvm/lib/Support/BinaryStreamRef.cpp b/llvm/lib/Support/BinaryStreamRef.cpp index 6d79d95e1bf0..06b4999d949b 100644 --- a/llvm/lib/Support/BinaryStreamRef.cpp +++ b/llvm/lib/Support/BinaryStreamRef.cpp @@ -67,7 +67,7 @@ class MutableArrayRefImpl : public WritableBinaryStream { BinaryStreamRef::BinaryStreamRef(BinaryStream &Stream) : BinaryStreamRefBase(Stream) {} BinaryStreamRef::BinaryStreamRef(BinaryStream &Stream, uint64_t Offset, - Optional<uint64_t> Length) + std::optional<uint64_t> Length) : BinaryStreamRefBase(Stream, Offset, Length) {} BinaryStreamRef::BinaryStreamRef(ArrayRef<uint8_t> Data, endianness Endian) : BinaryStreamRefBase(std::make_shared<ArrayRefImpl>(Data, Endian), 0, @@ -105,7 +105,7 @@ WritableBinaryStreamRef::WritableBinaryStreamRef(WritableBinaryStream &Stream) WritableBinaryStreamRef::WritableBinaryStreamRef(WritableBinaryStream &Stream, uint64_t Offset, - Optional<uint64_t> Length) + std::optional<uint64_t> Length) : BinaryStreamRefBase(Stream, Offset, Length) {} WritableBinaryStreamRef::WritableBinaryStreamRef(MutableArrayRef<uint8_t> Data, diff --git a/llvm/lib/Support/CrashRecoveryContext.cpp b/llvm/lib/Support/CrashRecoveryContext.cpp index 7fe09eb95892..c7c384c9edc2 100644 --- a/llvm/lib/Support/CrashRecoveryContext.cpp +++ b/llvm/lib/Support/CrashRecoveryContext.cpp @@ -519,7 +519,7 @@ bool CrashRecoveryContext::RunSafelyOnThread(function_ref<void()> Fn, RunSafelyOnThreadInfo Info = { Fn, this, UseBackgroundPriority, false }; llvm::thread Thread(RequestedStackSize == 0 ? std::nullopt - : llvm::Optional<unsigned>(RequestedStackSize), + : std::optional<unsigned>(RequestedStackSize), RunSafelyOnThread_Dispatch, &Info); Thread.join(); diff --git a/llvm/lib/Support/DJB.cpp b/llvm/lib/Support/DJB.cpp index 2701d5da2fb2..b9d159cdb3a6 100644 --- a/llvm/lib/Support/DJB.cpp +++ b/llvm/lib/Support/DJB.cpp @@ -57,7 +57,8 @@ static UTF32 foldCharDwarf(UTF32 C) { return sys::unicode::foldCharSimple(C); } -static Optional<uint32_t> fastCaseFoldingDjbHash(StringRef Buffer, uint32_t H) { +static std::optional<uint32_t> fastCaseFoldingDjbHash(StringRef Buffer, + uint32_t H) { bool AllASCII = true; for (unsigned char C : Buffer) { H = H * 33 + ('A' <= C && C <= 'Z' ? C - 'A' + 'a' : C); @@ -69,7 +70,7 @@ static Optional<uint32_t> fastCaseFoldingDjbHash(StringRef Buffer, uint32_t H) { } uint32_t llvm::caseFoldingDjbHash(StringRef Buffer, uint32_t H) { - if (Optional<uint32_t> Result = fastCaseFoldingDjbHash(Buffer, H)) + if (std::optional<uint32_t> Result = fastCaseFoldingDjbHash(Buffer, H)) return *Result; std::array<UTF8, UNI_MAX_UTF8_BYTES_PER_CODE_POINT> Storage; diff --git a/llvm/lib/Support/FileUtilities.cpp b/llvm/lib/Support/FileUtilities.cpp index 24960cc96bde..d01a41a46489 100644 --- a/llvm/lib/Support/FileUtilities.cpp +++ b/llvm/lib/Support/FileUtilities.cpp @@ -341,7 +341,7 @@ FilePermissionsApplier::create(StringRef InputFilename) { Error FilePermissionsApplier::apply( StringRef OutputFilename, bool CopyDates, - Optional<sys::fs::perms> OverwritePermissions) { + std::optional<sys::fs::perms> OverwritePermissions) { sys::fs::file_status Status = InputStatus; if (OverwritePermissions) diff --git a/llvm/lib/Support/FormatVariadic.cpp b/llvm/lib/Support/FormatVariadic.cpp index 169cea445e93..10de7f16dcf8 100644 --- a/llvm/lib/Support/FormatVariadic.cpp +++ b/llvm/lib/Support/FormatVariadic.cpp @@ -55,7 +55,7 @@ bool formatv_object_base::consumeFieldLayout(StringRef &Spec, AlignStyle &Where, return !Failed; } -Optional<ReplacementItem> +std::optional<ReplacementItem> formatv_object_base::parseReplacementItem(StringRef Spec) { StringRef RepString = Spec.trim("{}"); diff --git a/llvm/lib/Support/KnownBits.cpp b/llvm/lib/Support/KnownBits.cpp index c62a1a35d188..745c46fb6ffb 100644 --- a/llvm/lib/Support/KnownBits.cpp +++ b/llvm/lib/Support/KnownBits.cpp @@ -330,65 +330,65 @@ KnownBits KnownBits::ashr(const KnownBits &LHS, const KnownBits &RHS) { return Known; } -Optional<bool> KnownBits::eq(const KnownBits &LHS, const KnownBits &RHS) { +std::optional<bool> KnownBits::eq(const KnownBits &LHS, const KnownBits &RHS) { if (LHS.isConstant() && RHS.isConstant()) - return Optional<bool>(LHS.getConstant() == RHS.getConstant()); + return std::optional<bool>(LHS.getConstant() == RHS.getConstant()); if (LHS.One.intersects(RHS.Zero) || RHS.One.intersects(LHS.Zero)) - return Optional<bool>(false); + return std::optional<bool>(false); return std::nullopt; } -Optional<bool> KnownBits::ne(const KnownBits &LHS, const KnownBits &RHS) { - if (Optional<bool> KnownEQ = eq(LHS, RHS)) - return Optional<bool>(!*KnownEQ); +std::optional<bool> KnownBits::ne(const KnownBits &LHS, const KnownBits &RHS) { + if (std::optional<bool> KnownEQ = eq(LHS, RHS)) + return std::optional<bool>(!*KnownEQ); return std::nullopt; } -Optional<bool> KnownBits::ugt(const KnownBits &LHS, const KnownBits &RHS) { +std::optional<bool> KnownBits::ugt(const KnownBits &LHS, const KnownBits &RHS) { // LHS >u RHS -> false if umax(LHS) <= umax(RHS) if (LHS.getMaxValue().ule(RHS.getMinValue())) - return Optional<bool>(false); + return std::optional<bool>(false); // LHS >u RHS -> true if umin(LHS) > umax(RHS) if (LHS.getMinValue().ugt(RHS.getMaxValue())) - return Optional<bool>(true); + return std::optional<bool>(true); return std::nullopt; } -Optional<bool> KnownBits::uge(const KnownBits &LHS, const KnownBits &RHS) { - if (Optional<bool> IsUGT = ugt(RHS, LHS)) - return Optional<bool>(!*IsUGT); +std::optional<bool> KnownBits::uge(const KnownBits &LHS, const KnownBits &RHS) { + if (std::optional<bool> IsUGT = ugt(RHS, LHS)) + return std::optional<bool>(!*IsUGT); return std::nullopt; } -Optional<bool> KnownBits::ult(const KnownBits &LHS, const KnownBits &RHS) { +std::optional<bool> KnownBits::ult(const KnownBits &LHS, const KnownBits &RHS) { return ugt(RHS, LHS); } -Optional<bool> KnownBits::ule(const KnownBits &LHS, const KnownBits &RHS) { +std::optional<bool> KnownBits::ule(const KnownBits &LHS, const KnownBits &RHS) { return uge(RHS, LHS); } -Optional<bool> KnownBits::sgt(const KnownBits &LHS, const KnownBits &RHS) { +std::optional<bool> KnownBits::sgt(const KnownBits &LHS, const KnownBits &RHS) { // LHS >s RHS -> false if smax(LHS) <= smax(RHS) if (LHS.getSignedMaxValue().sle(RHS.getSignedMinValue())) - return Optional<bool>(false); + return std::optional<bool>(false); // LHS >s RHS -> true if smin(LHS) > smax(RHS) if (LHS.getSignedMinValue().sgt(RHS.getSignedMaxValue())) - return Optional<bool>(true); + return std::optional<bool>(true); return std::nullopt; } -Optional<bool> KnownBits::sge(const KnownBits &LHS, const KnownBits &RHS) { - if (Optional<bool> KnownSGT = sgt(RHS, LHS)) - return Optional<bool>(!*KnownSGT); +std::optional<bool> KnownBits::sge(const KnownBits &LHS, const KnownBits &RHS) { + if (std::optional<bool> KnownSGT = sgt(RHS, LHS)) + return std::optional<bool>(!*KnownSGT); return std::nullopt; } -Optional<bool> KnownBits::slt(const KnownBits &LHS, const KnownBits &RHS) { +std::optional<bool> KnownBits::slt(const KnownBits &LHS, const KnownBits &RHS) { return sgt(RHS, LHS); } -Optional<bool> KnownBits::sle(const KnownBits &LHS, const KnownBits &RHS) { +std::optional<bool> KnownBits::sle(const KnownBits &LHS, const KnownBits &RHS) { return sge(RHS, LHS); } diff --git a/llvm/lib/Support/LockFileManager.cpp b/llvm/lib/Support/LockFileManager.cpp index 9059473cee86..b64d48302775 100644 --- a/llvm/lib/Support/LockFileManager.cpp +++ b/llvm/lib/Support/LockFileManager.cpp @@ -51,7 +51,7 @@ using namespace llvm; /// \param LockFileName The name of the lock file to read. /// /// \returns The process ID of the process that owns this lock file -Optional<std::pair<std::string, int> > +std::optional<std::pair<std::string, int>> LockFileManager::readLockFile(StringRef LockFileName) { // Read the owning host and PID out of the lock file. If it appears that the // owning process is dead, the lock file is invalid. diff --git a/llvm/lib/Support/MemoryBuffer.cpp b/llvm/lib/Support/MemoryBuffer.cpp index 77c509cedcdb..0bb11725d2fc 100644 --- a/llvm/lib/Support/MemoryBuffer.cpp +++ b/llvm/lib/Support/MemoryBuffer.cpp @@ -114,7 +114,7 @@ template <typename MB> static ErrorOr<std::unique_ptr<MB>> getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsText, bool RequiresNullTerminator, bool IsVolatile, - Optional<Align> Alignment); + std::optional<Align> Alignment); std::unique_ptr<MemoryBuffer> MemoryBuffer::getMemBuffer(StringRef InputData, StringRef BufferName, @@ -150,7 +150,7 @@ MemoryBuffer::getMemBufferCopy(StringRef InputData, const Twine &BufferName) { ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText, bool RequiresNullTerminator, - Optional<Align> Alignment) { + std::optional<Align> Alignment) { SmallString<256> NameBuf; StringRef NameRef = Filename.toStringRef(NameBuf); @@ -163,7 +163,7 @@ MemoryBuffer::getFileOrSTDIN(const Twine &Filename, bool IsText, ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getFileSlice(const Twine &FilePath, uint64_t MapSize, uint64_t Offset, bool IsVolatile, - Optional<Align> Alignment) { + std::optional<Align> Alignment) { return getFileAux<MemoryBuffer>(FilePath, MapSize, Offset, /*IsText=*/false, /*RequiresNullTerminator=*/false, IsVolatile, Alignment); @@ -247,7 +247,7 @@ getMemoryBufferForStream(sys::fs::file_t FD, const Twine &BufferName) { ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getFile(const Twine &Filename, bool IsText, bool RequiresNullTerminator, bool IsVolatile, - Optional<Align> Alignment) { + std::optional<Align> Alignment) { return getFileAux<MemoryBuffer>(Filename, /*MapSize=*/-1, /*Offset=*/0, IsText, RequiresNullTerminator, IsVolatile, Alignment); @@ -257,13 +257,13 @@ template <typename MB> static ErrorOr<std::unique_ptr<MB>> getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, - bool IsVolatile, Optional<Align> Alignment); + bool IsVolatile, std::optional<Align> Alignment); template <typename MB> static ErrorOr<std::unique_ptr<MB>> getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsText, bool RequiresNullTerminator, bool IsVolatile, - Optional<Align> Alignment) { + std::optional<Align> Alignment) { Expected<sys::fs::file_t> FDOrErr = sys::fs::openNativeFileForRead( Filename, IsText ? sys::fs::OF_TextWithCRLF : sys::fs::OF_None); if (!FDOrErr) @@ -277,7 +277,7 @@ getFileAux(const Twine &Filename, uint64_t MapSize, uint64_t Offset, ErrorOr<std::unique_ptr<WritableMemoryBuffer>> WritableMemoryBuffer::getFile(const Twine &Filename, bool IsVolatile, - Optional<Align> Alignment) { + std::optional<Align> Alignment) { return getFileAux<WritableMemoryBuffer>( Filename, /*MapSize=*/-1, /*Offset=*/0, /*IsText=*/false, /*RequiresNullTerminator=*/false, IsVolatile, Alignment); @@ -286,7 +286,7 @@ WritableMemoryBuffer::getFile(const Twine &Filename, bool IsVolatile, ErrorOr<std::unique_ptr<WritableMemoryBuffer>> WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize, uint64_t Offset, bool IsVolatile, - Optional<Align> Alignment) { + std::optional<Align> Alignment) { return getFileAux<WritableMemoryBuffer>( Filename, MapSize, Offset, /*IsText=*/false, /*RequiresNullTerminator=*/false, IsVolatile, Alignment); @@ -295,7 +295,7 @@ WritableMemoryBuffer::getFileSlice(const Twine &Filename, uint64_t MapSize, std::unique_ptr<WritableMemoryBuffer> WritableMemoryBuffer::getNewUninitMemBuffer(size_t Size, const Twine &BufferName, - Optional<Align> Alignment) { + std::optional<Align> Alignment) { using MemBuffer = MemoryBufferMem<WritableMemoryBuffer>; // Use 16-byte alignment if no alignment is specified. @@ -447,7 +447,7 @@ template <typename MB> static ErrorOr<std::unique_ptr<MB>> getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, uint64_t MapSize, int64_t Offset, bool RequiresNullTerminator, - bool IsVolatile, Optional<Align> Alignment) { + bool IsVolatile, std::optional<Align> Alignment) { static int PageSize = sys::Process::getPageSizeEstimate(); // Default is to map the full file. @@ -518,16 +518,15 @@ getOpenFileImpl(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getOpenFile(sys::fs::file_t FD, const Twine &Filename, uint64_t FileSize, bool RequiresNullTerminator, - bool IsVolatile, Optional<Align> Alignment) { + bool IsVolatile, std::optional<Align> Alignment) { return getOpenFileImpl<MemoryBuffer>(FD, Filename, FileSize, FileSize, 0, RequiresNullTerminator, IsVolatile, Alignment); } -ErrorOr<std::unique_ptr<MemoryBuffer>> -MemoryBuffer::getOpenFileSlice(sys::fs::file_t FD, const Twine &Filename, - uint64_t MapSize, int64_t Offset, - bool IsVolatile, Optional<Align> Alignment) { +ErrorOr<std::unique_ptr<MemoryBuffer>> MemoryBuffer::getOpenFileSlice( + sys::fs::file_t FD, const Twine &Filename, uint64_t MapSize, int64_t Offset, + bool IsVolatile, std::optional<Align> Alignment) { assert(MapSize != uint64_t(-1)); return getOpenFileImpl<MemoryBuffer>(FD, Filename, -1, MapSize, Offset, false, IsVolatile, Alignment); diff --git a/llvm/lib/Support/NativeFormatting.cpp b/llvm/lib/Support/NativeFormatting.cpp index ee2d8853dd62..fb02de792cb6 100644 --- a/llvm/lib/Support/NativeFormatting.cpp +++ b/llvm/lib/Support/NativeFormatting.cpp @@ -136,7 +136,7 @@ void llvm::write_integer(raw_ostream &S, long long N, size_t MinDigits, } void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, - Optional<size_t> Width) { + std::optional<size_t> Width) { const size_t kMaxWidth = 128u; size_t W = std::min(kMaxWidth, Width.value_or(0u)); @@ -166,7 +166,7 @@ void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, } void llvm::write_double(raw_ostream &S, double N, FloatStyle Style, - Optional<size_t> Precision) { + std::optional<size_t> Precision) { size_t Prec = Precision.value_or(getDefaultPrecision(Style)); if (std::isnan(N)) { diff --git a/llvm/lib/Support/OptimizedStructLayout.cpp b/llvm/lib/Support/OptimizedStructLayout.cpp index 8f0431106657..c64eff60c0b1 100644 --- a/llvm/lib/Support/OptimizedStructLayout.cpp +++ b/llvm/lib/Support/OptimizedStructLayout.cpp @@ -346,9 +346,8 @@ llvm::performOptimizedStructLayout(MutableArrayRef<Field> Fields) { // Helper function to try to find a field in the given queue that'll // fit starting at StartOffset but before EndOffset (if present). // Note that this never fails if EndOffset is not provided. - auto tryAddFillerFromQueue = [&](AlignmentQueue *Queue, - uint64_t StartOffset, - Optional<uint64_t> EndOffset) -> bool { + auto tryAddFillerFromQueue = [&](AlignmentQueue *Queue, uint64_t StartOffset, + std::optional<uint64_t> EndOffset) -> bool { assert(Queue->Head); assert(StartOffset == alignTo(LastEnd, Queue->Alignment)); assert(!EndOffset || StartOffset < *EndOffset); @@ -357,7 +356,8 @@ llvm::performOptimizedStructLayout(MutableArrayRef<Field> Fields) { // queue if there's nothing in it that small. auto MaxViableSize = (EndOffset ? *EndOffset - StartOffset : ~(uint64_t)0); - if (Queue->MinSize > MaxViableSize) return false; + if (Queue->MinSize > MaxViableSize) + return false; // Find the matching field. Note that this should always find // something because of the MinSize check above. @@ -373,7 +373,7 @@ llvm::performOptimizedStructLayout(MutableArrayRef<Field> Fields) { // Helper function to find the "best" flexible-offset field according // to the criteria described above. - auto tryAddBestField = [&](Optional<uint64_t> BeforeOffset) -> bool { + auto tryAddBestField = [&](std::optional<uint64_t> BeforeOffset) -> bool { assert(!BeforeOffset || LastEnd < *BeforeOffset); auto QueueB = FlexibleFieldsByAlignment.begin(); auto QueueE = FlexibleFieldsByAlignment.end(); diff --git a/llvm/lib/Support/SymbolRemappingReader.cpp b/llvm/lib/Support/SymbolRemappingReader.cpp index 3cae57770c37..0082696038e3 100644 --- a/llvm/lib/Support/SymbolRemappingReader.cpp +++ b/llvm/lib/Support/SymbolRemappingReader.cpp @@ -48,11 +48,11 @@ Error SymbolRemappingReader::read(MemoryBuffer &B) { "found '" + Line + "'"); using FK = ItaniumManglingCanonicalizer::FragmentKind; - Optional<FK> FragmentKind = StringSwitch<Optional<FK>>(Parts[0]) - .Case("name", FK::Name) - .Case("type", FK::Type) - .Case("encoding", FK::Encoding) - .Default(std::nullopt); + std::optional<FK> FragmentKind = StringSwitch<std::optional<FK>>(Parts[0]) + .Case("name", FK::Name) + .Case("type", FK::Type) + .Case("encoding", FK::Encoding) + .Default(std::nullopt); if (!FragmentKind) return ReportError("Invalid kind, expected 'name', 'type', or 'encoding'," " found '" + Parts[0] + "'"); diff --git a/llvm/lib/Support/Threading.cpp b/llvm/lib/Support/Threading.cpp index 24962ae20919..f4e3331a4b9b 100644 --- a/llvm/lib/Support/Threading.cpp +++ b/llvm/lib/Support/Threading.cpp @@ -82,9 +82,9 @@ unsigned llvm::ThreadPoolStrategy::compute_thread_count() const { // which is not enough for some/many normal LLVM compilations. This implements // the same interface as std::thread but requests the same stack size as the // main thread (8MB) before creation. -const llvm::Optional<unsigned> llvm::thread::DefaultStackSize = 8 * 1024 * 1024; +const std::optional<unsigned> llvm::thread::DefaultStackSize = 8 * 1024 * 1024; #else -const llvm::Optional<unsigned> llvm::thread::DefaultStackSize; +const std::optional<unsigned> llvm::thread::DefaultStackSize; #endif diff --git a/llvm/lib/Support/UnicodeNameToCodepoint.cpp b/llvm/lib/Support/UnicodeNameToCodepoint.cpp index 5fb61250705c..a10a7e8082ac 100644 --- a/llvm/lib/Support/UnicodeNameToCodepoint.cpp +++ b/llvm/lib/Support/UnicodeNameToCodepoint.cpp @@ -285,7 +285,7 @@ static std::size_t findSyllable(StringRef Name, bool Strict, return size_t(Len); } -static llvm::Optional<char32_t> +static std::optional<char32_t> nameToHangulCodePoint(StringRef Name, bool Strict, BufferType &Buffer) { Buffer.clear(); // Hangul Syllable Decomposition @@ -343,7 +343,7 @@ static const GeneratedNamesData GeneratedNamesDataTable[] = { {"CJK COMPATIBILITY IDEOGRAPH-", 0x2F800, 0x2FA1D}, }; -static llvm::Optional<char32_t> +static std::optional<char32_t> nameToGeneratedCodePoint(StringRef Name, bool Strict, BufferType &Buffer) { for (auto &&Item : GeneratedNamesDataTable) { Buffer.clear(); @@ -370,12 +370,12 @@ nameToGeneratedCodePoint(StringRef Name, bool Strict, BufferType &Buffer) { return std::nullopt; } -static llvm::Optional<char32_t> nameToCodepoint(StringRef Name, bool Strict, - BufferType &Buffer) { +static std::optional<char32_t> nameToCodepoint(StringRef Name, bool Strict, + BufferType &Buffer) { if (Name.empty()) return std::nullopt; - llvm::Optional<char32_t> Res = nameToHangulCodePoint(Name, Strict, Buffer); + std::optional<char32_t> Res = nameToHangulCodePoint(Name, Strict, Buffer); if (!Res) Res = nameToGeneratedCodePoint(Name, Strict, Buffer); if (Res) @@ -400,14 +400,14 @@ static llvm::Optional<char32_t> nameToCodepoint(StringRef Name, bool Strict, return std::nullopt; } -llvm::Optional<char32_t> nameToCodepointStrict(StringRef Name) { +std::optional<char32_t> nameToCodepointStrict(StringRef Name) { BufferType Buffer; auto Opt = nameToCodepoint(Name, true, Buffer); return Opt; } -llvm::Optional<LooseMatchingResult> +std::optional<LooseMatchingResult> nameToCodepointLooseMatching(StringRef Name) { BufferType Buffer; auto Opt = nameToCodepoint(Name, false, Buffer); diff --git a/llvm/lib/Support/Unix/Threading.inc b/llvm/lib/Support/Unix/Threading.inc index def6afad38c7..819748db4ec2 100644 --- a/llvm/lib/Support/Unix/Threading.inc +++ b/llvm/lib/Support/Unix/Threading.inc @@ -58,7 +58,7 @@ namespace llvm { pthread_t llvm_execute_on_thread_impl(void *(*ThreadFunc)(void *), void *Arg, - llvm::Optional<unsigned> StackSizeInBytes) { + std::optional<unsigned> StackSizeInBytes) { int errnum; // Construct the attributes object. diff --git a/llvm/lib/Support/VersionTuple.cpp b/llvm/lib/Support/VersionTuple.cpp index 6a516481ac25..c0e007215a5d 100644 --- a/llvm/lib/Support/VersionTuple.cpp +++ b/llvm/lib/Support/VersionTuple.cpp @@ -29,11 +29,11 @@ std::string VersionTuple::getAsString() const { raw_ostream &llvm::operator<<(raw_ostream &Out, const VersionTuple &V) { Out << V.getMajor(); - if (Optional<unsigned> Minor = V.getMinor()) + if (std::optional<unsigned> Minor = V.getMinor()) Out << '.' << *Minor; - if (Optional<unsigned> Subminor = V.getSubminor()) + if (std::optional<unsigned> Subminor = V.getSubminor()) Out << '.' << *Subminor; - if (Optional<unsigned> Build = V.getBuild()) + if (std::optional<unsigned> Build = V.getBuild()) Out << '.' << *Build; return Out; } diff --git a/llvm/lib/Support/VirtualFileSystem.cpp b/llvm/lib/Support/VirtualFileSystem.cpp index f210143b1204..eac6fc9a9e35 100644 --- a/llvm/lib/Support/VirtualFileSystem.cpp +++ b/llvm/lib/Support/VirtualFileSystem.cpp @@ -814,10 +814,10 @@ std::string InMemoryFileSystem::toString() const { bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime, std::unique_ptr<llvm::MemoryBuffer> Buffer, - Optional<uint32_t> User, - Optional<uint32_t> Group, - Optional<llvm::sys::fs::file_type> Type, - Optional<llvm::sys::fs::perms> Perms, + std::optional<uint32_t> User, + std::optional<uint32_t> Group, + std::optional<llvm::sys::fs::file_type> Type, + std::optional<llvm::sys::fs::perms> Perms, MakeNodeFn MakeNode) { SmallString<128> Path; P.toVector(Path); @@ -891,10 +891,10 @@ bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime, bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime, std::unique_ptr<llvm::MemoryBuffer> Buffer, - Optional<uint32_t> User, - Optional<uint32_t> Group, - Optional<llvm::sys::fs::file_type> Type, - Optional<llvm::sys::fs::perms> Perms) { + std::optional<uint32_t> User, + std::optional<uint32_t> Group, + std::optional<llvm::sys::fs::file_type> Type, + std::optional<llvm::sys::fs::perms> Perms) { return addFile(P, ModificationTime, std::move(Buffer), User, Group, Type, Perms, [](detail::NewInMemoryNodeInfo NNI) @@ -907,12 +907,11 @@ bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime, }); } -bool InMemoryFileSystem::addFileNoOwn(const Twine &P, time_t ModificationTime, - const llvm::MemoryBufferRef &Buffer, - Optional<uint32_t> User, - Optional<uint32_t> Group, - Optional<llvm::sys::fs::file_type> Type, - Optional<llvm::sys::fs::perms> Perms) { +bool InMemoryFileSystem::addFileNoOwn( + const Twine &P, time_t ModificationTime, + const llvm::MemoryBufferRef &Buffer, std::optional<uint32_t> User, + std::optional<uint32_t> Group, std::optional<llvm::sys::fs::file_type> Type, + std::optional<llvm::sys::fs::perms> Perms) { return addFile(P, ModificationTime, llvm::MemoryBuffer::getMemBuffer(Buffer), std::move(User), std::move(Group), std::move(Type), std::move(Perms), @@ -1020,12 +1019,10 @@ bool InMemoryFileSystem::addHardLink(const Twine &NewLink, }); } -bool InMemoryFileSystem::addSymbolicLink(const Twine &NewLink, - const Twine &Target, - time_t ModificationTime, - Optional<uint32_t> User, - Optional<uint32_t> Group, - Optional<llvm::sys::fs::perms> Perms) { +bool InMemoryFileSystem::addSymbolicLink( + const Twine &NewLink, const Twine &Target, time_t ModificationTime, + std::optional<uint32_t> User, std::optional<uint32_t> Group, + std::optional<llvm::sys::fs::perms> Perms) { auto NewLinkNode = lookupNode(NewLink, /*FollowFinalSymlink=*/false); if (NewLinkNode) return false; @@ -2272,7 +2269,7 @@ static Status getRedirectedFileStatus(const Twine &OriginalPath, ErrorOr<Status> RedirectingFileSystem::status( const Twine &CanonicalPath, const Twine &OriginalPath, const RedirectingFileSystem::LookupResult &Result) { - if (Optional<StringRef> ExtRedirect = Result.getExternalRedirect()) { + if (std::optional<StringRef> ExtRedirect = Result.getExternalRedirect()) { SmallString<256> CanonicalRemappedPath((*ExtRedirect).str()); if (std::error_code EC = makeCanonical(CanonicalRemappedPath)) return EC; @@ -2603,9 +2600,10 @@ class JSONWriter { public: JSONWriter(llvm::raw_ostream &OS) : OS(OS) {} - void write(ArrayRef<YAMLVFSEntry> Entries, Optional<bool> UseExternalNames, - Optional<bool> IsCaseSensitive, Optional<bool> IsOverlayRelative, - StringRef OverlayDir); + void write(ArrayRef<YAMLVFSEntry> Entries, + std::optional<bool> UseExternalNames, + std::optional<bool> IsCaseSensitive, + std::optional<bool> IsOverlayRelative, StringRef OverlayDir); }; } // namespace @@ -2660,9 +2658,9 @@ void JSONWriter::writeEntry(StringRef VPath, StringRef RPath) { } void JSONWriter::write(ArrayRef<YAMLVFSEntry> Entries, - Optional<bool> UseExternalNames, - Optional<bool> IsCaseSensitive, - Optional<bool> IsOverlayRelative, + std::optional<bool> UseExternalNames, + std::optional<bool> IsCaseSensitive, + std::optional<bool> IsOverlayRelative, StringRef OverlayDir) { using namespace llvm::sys; diff --git a/llvm/lib/Support/Windows/Threading.inc b/llvm/lib/Support/Windows/Threading.inc index aaeda2ff85f8..2c16fe442b70 100644 --- a/llvm/lib/Support/Windows/Threading.inc +++ b/llvm/lib/Support/Windows/Threading.inc @@ -26,7 +26,7 @@ namespace llvm { HANDLE llvm_execute_on_thread_impl(unsigned(__stdcall *ThreadFunc)(void *), void *Arg, - llvm::Optional<unsigned> StackSizeInBytes) { + std::optional<unsigned> StackSizeInBytes) { HANDLE hThread = (HANDLE)::_beginthreadex(NULL, StackSizeInBytes.value_or(0), ThreadFunc, Arg, 0, NULL); diff --git a/llvm/lib/Support/Z3Solver.cpp b/llvm/lib/Support/Z3Solver.cpp index 499548e91286..a49bedcfd2b0 100644 --- a/llvm/lib/Support/Z3Solver.cpp +++ b/llvm/lib/Support/Z3Solver.cpp @@ -870,7 +870,7 @@ class Z3Solver : public SMTSolver { return toAPFloat(Sort, Assign, Float, true); } - Optional<bool> check() const override { + std::optional<bool> check() const override { Z3_lbool res = Z3_solver_check(Context.Context, Solver); if (res == Z3_L_TRUE) return true; diff --git a/llvm/unittests/ADT/StatisticTest.cpp b/llvm/unittests/ADT/StatisticTest.cpp index e4c144289bb8..91bc7f24c7f2 100644 --- a/llvm/unittests/ADT/StatisticTest.cpp +++ b/llvm/unittests/ADT/StatisticTest.cpp @@ -11,7 +11,7 @@ #include "gtest/gtest.h" using namespace llvm; -using OptionalStatistic = Optional<std::pair<StringRef, uint64_t>>; +using OptionalStatistic = std::optional<std::pair<StringRef, uint64_t>>; namespace { #define DEBUG_TYPE "unittest" diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp index 8ccabaeea5de..ed05963bc105 100644 --- a/llvm/unittests/Support/Casting.cpp +++ b/llvm/unittests/Support/Casting.cpp @@ -235,7 +235,7 @@ TEST(CastingTest, dyn_cast_or_null) { TEST(CastingTest, dyn_cast_value_types) { T1 t1; - Optional<T2> t2 = dyn_cast<T2>(t1); + std::optional<T2> t2 = dyn_cast<T2>(t1); EXPECT_TRUE(t2); T2 *t2ptr = dyn_cast<T2>(&t1); @@ -246,12 +246,12 @@ TEST(CastingTest, dyn_cast_value_types) { } TEST(CastingTest, dyn_cast_if_present) { - Optional<T1> empty{}; - Optional<T2> F1 = dyn_cast_if_present<T2>(empty); + std::optional<T1> empty{}; + std::optional<T2> F1 = dyn_cast_if_present<T2>(empty); EXPECT_FALSE(F1.has_value()); T1 t1; - Optional<T2> F2 = dyn_cast_if_present<T2>(t1); + std::optional<T2> F2 = dyn_cast_if_present<T2>(t1); EXPECT_TRUE(F2.has_value()); T1 *t1Null = nullptr; diff --git a/llvm/unittests/Support/ErrorTest.cpp b/llvm/unittests/Support/ErrorTest.cpp index 16118a966015..11f93203597b 100644 --- a/llvm/unittests/Support/ErrorTest.cpp +++ b/llvm/unittests/Support/ErrorTest.cpp @@ -1070,7 +1070,7 @@ static Error createAnyError() { } struct MoveOnlyBox { - Optional<int> Box; + std::optional<int> Box; explicit MoveOnlyBox(int I) : Box(I) {} MoveOnlyBox() = default; @@ -1117,7 +1117,7 @@ TEST(Error, moveInto) { // Check that this works with optionals too. { // Same cases as above. - Optional<MoveOnlyBox> MaybeV; + std::optional<MoveOnlyBox> MaybeV; EXPECT_THAT_ERROR(makeFailure().moveInto(MaybeV), Failed()); EXPECT_EQ(std::nullopt, MaybeV); diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp index 1d609e9d2c10..0c3d9dfa7630 100644 --- a/llvm/unittests/Support/KnownBitsTest.cpp +++ b/llvm/unittests/Support/KnownBitsTest.cpp @@ -347,16 +347,16 @@ TEST(KnownBitsTest, ICmpExhaustive) { }); }); - Optional<bool> KnownEQ = KnownBits::eq(Known1, Known2); - Optional<bool> KnownNE = KnownBits::ne(Known1, Known2); - Optional<bool> KnownUGT = KnownBits::ugt(Known1, Known2); - Optional<bool> KnownUGE = KnownBits::uge(Known1, Known2); - Optional<bool> KnownULT = KnownBits::ult(Known1, Known2); - Optional<bool> KnownULE = KnownBits::ule(Known1, Known2); - Optional<bool> KnownSGT = KnownBits::sgt(Known1, Known2); - Optional<bool> KnownSGE = KnownBits::sge(Known1, Known2); - Optional<bool> KnownSLT = KnownBits::slt(Known1, Known2); - Optional<bool> KnownSLE = KnownBits::sle(Known1, Known2); + std::optional<bool> KnownEQ = KnownBits::eq(Known1, Known2); + std::optional<bool> KnownNE = KnownBits::ne(Known1, Known2); + std::optional<bool> KnownUGT = KnownBits::ugt(Known1, Known2); + std::optional<bool> KnownUGE = KnownBits::uge(Known1, Known2); + std::optional<bool> KnownULT = KnownBits::ult(Known1, Known2); + std::optional<bool> KnownULE = KnownBits::ule(Known1, Known2); + std::optional<bool> KnownSGT = KnownBits::sgt(Known1, Known2); + std::optional<bool> KnownSGE = KnownBits::sge(Known1, Known2); + std::optional<bool> KnownSLT = KnownBits::slt(Known1, Known2); + std::optional<bool> KnownSLE = KnownBits::sle(Known1, Known2); EXPECT_EQ(AllEQ || NoneEQ, KnownEQ.has_value()); EXPECT_EQ(AllNE || NoneNE, KnownNE.has_value()); diff --git a/llvm/unittests/Support/NativeFormatTests.cpp b/llvm/unittests/Support/NativeFormatTests.cpp index 591a68f1380c..197fad1f83cf 100644 --- a/llvm/unittests/Support/NativeFormatTests.cpp +++ b/llvm/unittests/Support/NativeFormatTests.cpp @@ -26,7 +26,7 @@ template <typename T> std::string format_number(T N, IntegerStyle Style) { } std::string format_number(uint64_t N, HexPrintStyle Style, - Optional<size_t> Width = std::nullopt) { + std::optional<size_t> Width = std::nullopt) { std::string S; llvm::raw_string_ostream Str(S); write_hex(Str, N, Style, Width); @@ -35,7 +35,7 @@ std::string format_number(uint64_t N, HexPrintStyle Style, } std::string format_number(double D, FloatStyle Style, - Optional<size_t> Precision = std::nullopt) { + std::optional<size_t> Precision = std::nullopt) { std::string S; llvm::raw_string_ostream Str(S); write_double(Str, D, Style, Precision); diff --git a/llvm/unittests/Support/Path.cpp b/llvm/unittests/Support/Path.cpp index d649debeed42..16e0f048ccb7 100644 --- a/llvm/unittests/Support/Path.cpp +++ b/llvm/unittests/Support/Path.cpp @@ -454,7 +454,7 @@ std::string getEnvWin(const wchar_t *Var) { // RAII helper to set and restore an environment variable. class WithEnv { const char *Var; - llvm::Optional<std::string> OriginalValue; + std::optional<std::string> OriginalValue; public: WithEnv(const char *Var, const char *Value) : Var(Var) { @@ -1767,7 +1767,7 @@ static void verifyFileContents(const Twine &Path, StringRef Contents) { TEST_F(FileSystemTest, CreateNew) { int FD; - Optional<FileDescriptorCloser> Closer; + std::optional<FileDescriptorCloser> Closer; // Succeeds if the file does not exist. ASSERT_FALSE(fs::exists(NonExistantFile)); @@ -1791,7 +1791,7 @@ TEST_F(FileSystemTest, CreateNew) { TEST_F(FileSystemTest, CreateAlways) { int FD; - Optional<FileDescriptorCloser> Closer; + std::optional<FileDescriptorCloser> Closer; // Succeeds if the file does not exist. ASSERT_FALSE(fs::exists(NonExistantFile)); @@ -1869,7 +1869,7 @@ TEST_F(FileSystemTest, AppendSetsCorrectFileOffset) { // the specified disposition. for (fs::CreationDisposition Disp : Disps) { int FD; - Optional<FileDescriptorCloser> Closer; + std::optional<FileDescriptorCloser> Closer; createFileWithData(NonExistantFile, false, fs::CD_CreateNew, "Fizz"); @@ -1975,7 +1975,7 @@ TEST_F(FileSystemTest, readNativeFileToEOF) { createFileWithData(NonExistantFile, false, fs::CD_CreateNew, Content); FileRemover Cleanup(NonExistantFile); const auto &Read = [&](SmallVectorImpl<char> &V, - Optional<ssize_t> ChunkSize) { + std::optional<ssize_t> ChunkSize) { Expected<fs::file_t> FD = fs::openNativeFileForRead(NonExistantFile); if (!FD) return FD.takeError(); diff --git a/llvm/unittests/Support/TypeTraitsTest.cpp b/llvm/unittests/Support/TypeTraitsTest.cpp index 734e50afa2db..71383ac63359 100644 --- a/llvm/unittests/Support/TypeTraitsTest.cpp +++ b/llvm/unittests/Support/TypeTraitsTest.cpp @@ -118,7 +118,7 @@ TEST(Triviality, ADT) { TrivialityTester<llvm::StringRef, true, true>(); TrivialityTester<llvm::ArrayRef<int>, true, true>(); TrivialityTester<llvm::PointerIntPair<int *, 2>, true, true>(); - TrivialityTester<llvm::Optional<int>, true, true>(); + TrivialityTester<std::optional<int>, true, true>(); } } // namespace triviality diff --git a/mlir/lib/Support/FileUtilities.cpp b/mlir/lib/Support/FileUtilities.cpp index 9fc86fcd6202..a5c44d3a9c8e 100644 --- a/mlir/lib/Support/FileUtilities.cpp +++ b/mlir/lib/Support/FileUtilities.cpp @@ -21,7 +21,7 @@ using namespace mlir; static std::unique_ptr<llvm::MemoryBuffer> openInputFileImpl(StringRef inputFilename, std::string *errorMessage, - Optional<llvm::Align> alignment) { + std::optional<llvm::Align> alignment) { auto fileOrErr = llvm::MemoryBuffer::getFileOrSTDIN( inputFilename, /*IsText=*/false, /*RequiresNullTerminator=*/true, alignment); _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
