From 18bd65cd2f69f58b31e3789d1bffe2cf0a8c6d0c Mon Sep 17 00:00:00 2001 From: Florian Mayer Date: Mon, 13 Oct 2025 13:23:12 -0700 Subject: [PATCH 1/6] =?UTF-8?q?[=F0=9D=98=80=F0=9D=97=BD=F0=9D=97=BF]=20ch?= =?UTF-8?q?anges=20to=20main=20this=20commit=20is=20based=20on?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Created using spr 1.3.4 [skip ci] --- .../gn/secondary/clang/lib/Analysis/BUILD.gn | 3 +-- .../lib/Analysis/LifetimeSafety/BUILD.gn | 20 +++++++++++++++++++ 2 files changed, 21 insertions(+), 2 deletions(-) create mode 100644 llvm/utils/gn/secondary/clang/lib/Analysis/LifetimeSafety/BUILD.gn diff --git a/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn index 5f9eb9adce04a..fe212d14b5741 100644 --- a/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn +++ b/llvm/utils/gn/secondary/clang/lib/Analysis/BUILD.gn @@ -5,6 +5,7 @@ static_library("Analysis") { "//clang/include/clang/AST:StmtDataCollectors", "//clang/lib/AST", "//clang/lib/ASTMatchers", + "//clang/lib/Analysis/LifetimeSafety", "//clang/lib/Basic", "//clang/lib/Lex", "//llvm/lib/Support", @@ -27,8 +28,6 @@ static_library("Analysis") { "FixitUtil.cpp", "IntervalPartition.cpp", "IssueHash.cpp", - "LifetimeAnnotations.cpp", - "LifetimeSafety.cpp", "LiveVariables.cpp", "MacroExpansionContext.cpp", "ObjCNoReturn.cpp", diff --git a/llvm/utils/gn/secondary/clang/lib/Analysis/LifetimeSafety/BUILD.gn b/llvm/utils/gn/secondary/clang/lib/Analysis/LifetimeSafety/BUILD.gn new file mode 100644 index 0000000000000..7f962c4d1691c --- /dev/null +++ b/llvm/utils/gn/secondary/clang/lib/Analysis/LifetimeSafety/BUILD.gn @@ -0,0 +1,20 @@ +static_library("LifetimeSafety") { + output_name = "clangAnalysisLifetimeSafety" + configs += [ "//llvm/utils/gn/build:clang_code" ] + deps = [ + "//clang/lib/AST", + "//clang/lib/Basic", + "//llvm/lib/Support", + ] + sources = [ + "Checker.cpp", + "Facts.cpp", + "FactsGenerator.cpp", + "LifetimeAnnotations.cpp", + "LifetimeSafety.cpp", + "LiveOrigins.cpp", + "LoanPropagation.cpp", + "Loans.cpp", + "Origins.cpp", + ] +} From 00a05213acb88c34d004a9b4f1162d9e19a6e67e Mon Sep 17 00:00:00 2001 From: Florian Mayer Date: Mon, 13 Oct 2025 13:30:58 -0700 Subject: [PATCH 2/6] typ Created using spr 1.3.7 --- clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp index 7cb448a709281..7859a78da7af3 100644 --- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp +++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp @@ -30,7 +30,7 @@ using nullptr_t = decltype(nullptr); typedef decltype(sizeof(char)) size_t; typedef decltype(sizeof(char*)) ptrdiff_t; -#endif // CS +#endif // CSTDDEF_H )"; static constexpr char StdTypeTraitsHeader[] = R"( From 7985c07627afa7982451ba42d1bab954c1b21ba0 Mon Sep 17 00:00:00 2001 From: Florian Mayer Date: Mon, 13 Oct 2025 14:05:13 -0700 Subject: [PATCH 3/6] fix Created using spr 1.3.7 --- clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp | 3 --- 1 file changed, 3 deletions(-) diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp index 7859a78da7af3..687f7c6d35f72 100644 --- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp +++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp @@ -829,9 +829,6 @@ struct nullopt_t { }; constexpr nullopt_t nullopt; -struct in_place_t {}; -constexpr in_place_t in_place; - template class optional; From 7e71109b219185b90b85d21c4661915b9dd576c3 Mon Sep 17 00:00:00 2001 From: Florian Mayer Date: Wed, 15 Oct 2025 11:26:49 -0700 Subject: [PATCH 4/6] format Created using spr 1.3.7 --- .../Analysis/FlowSensitive/MockHeaders.cpp | 796 +++++++++--------- 1 file changed, 399 insertions(+), 397 deletions(-) diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp index 687f7c6d35f72..cd60a33aea6f0 100644 --- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp +++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp @@ -1285,79 +1285,80 @@ constexpr const char StatusDefsHeader[] = #include "std_utility.h" #include "std_string.h" - namespace absl { - struct SourceLocation { - static constexpr SourceLocation current(); - static constexpr SourceLocation DoNotInvokeDirectlyNoSeriouslyDont( - int line, const char* file_name); - }; - } // namespace absl - namespace absl { - enum class StatusCode : int { - kOk, - kCancelled, - kUnknown, - kInvalidArgument, - kDeadlineExceeded, - kNotFound, - kAlreadyExists, - kPermissionDenied, - kResourceExhausted, - kFailedPrecondition, - kAborted, - kOutOfRange, - kUnimplemented, - kInternal, - kUnavailable, - kDataLoss, - kUnauthenticated, - }; - } // namespace absl +namespace absl { +struct SourceLocation { +static constexpr SourceLocation current(); +static constexpr SourceLocation DoNotInvokeDirectlyNoSeriouslyDont( + int line, const char* file_name); +}; +} // namespace absl +namespace absl { +enum class StatusCode : int { +kOk, +kCancelled, +kUnknown, +kInvalidArgument, +kDeadlineExceeded, +kNotFound, +kAlreadyExists, +kPermissionDenied, +kResourceExhausted, +kFailedPrecondition, +kAborted, +kOutOfRange, +kUnimplemented, +kInternal, +kUnavailable, +kDataLoss, +kUnauthenticated, +}; +} // namespace absl - namespace absl { - enum class StatusToStringMode : int { - kWithNoExtraData = 0, - kWithPayload = 1 << 0, - kWithSourceLocation = 1 << 1, - kWithEverything = ~kWithNoExtraData, - kDefault = kWithPayload, - }; - class Status { - public: - Status(); - template - Status(Enum code, std::string_view msg); - Status(absl::StatusCode code, std::string_view msg, - absl::SourceLocation loc = SourceLocation::current()); - Status(const Status& base_status, absl::SourceLocation loc); - Status(Status&& base_status, absl::SourceLocation loc); - ~Status() {} - - Status(const Status&); - Status& operator=(const Status& x); - - Status(Status&&) noexcept; - Status& operator=(Status&&); - - friend bool operator==(const Status&, const Status&); - friend bool operator!=(const Status&, const Status&); - - bool ok() const { return true; } - void CheckSuccess() const; - void IgnoreError() const; - int error_code() const; - absl::Status ToCanonical() const; - std::string ToString( - StatusToStringMode m = StatusToStringMode::kDefault) const; - void Update(const Status& new_status); - void Update(Status&& new_status); - }; +namespace absl { +enum class StatusToStringMode : int { +kWithNoExtraData = 0, +kWithPayload = 1 << 0, +kWithSourceLocation = 1 << 1, +kWithEverything = ~kWithNoExtraData, +kDefault = kWithPayload, +}; +class Status { +public: +Status(); +template +Status(Enum code, std::string_view msg); +Status(absl::StatusCode code, std::string_view msg, + absl::SourceLocation loc = SourceLocation::current()); +Status(const Status& base_status, absl::SourceLocation loc); +Status(Status&& base_status, absl::SourceLocation loc); +~Status() {} + +Status(const Status&); +Status& operator=(const Status& x); + +Status(Status&&) noexcept; +Status& operator=(Status&&); + +friend bool operator==(const Status&, const Status&); +friend bool operator!=(const Status&, const Status&); + +bool ok() const { return true; } +void CheckSuccess() const; +void IgnoreError() const; +int error_code() const; +absl::Status ToCanonical() const; +std::string ToString( + StatusToStringMode m = StatusToStringMode::kDefault) const; +void Update(const Status& new_status); +void Update(Status&& new_status); +}; + +bool operator==(const Status& lhs, const Status& rhs); +bool operator!=(const Status& lhs, const Status& rhs); - bool operator==(const Status& lhs, const Status& rhs); - bool operator!=(const Status& lhs, const Status& rhs); +Status OkStatus(); +Status InvalidArgumentError(char*); - Status OkStatus(); - Status InvalidArgumentError(char*); #endif // STATUS_H )cc"; @@ -1368,363 +1369,364 @@ constexpr const char StatusOrDefsHeader[] = R"cc( #include "std_initializer_list.h" #include "std_type_traits.h" #include "std_utility.h" - #include "status_defs.h" - template - struct StatusOr; - - namespace internal_statusor { - - template - struct HasConversionOperatorToStatusOr : std::false_type {}; - - template - void test(char (*)[sizeof(std::declval().operator absl::StatusOr())]); - - template - struct HasConversionOperatorToStatusOr(0))> - : std::true_type {}; - - template - using IsConstructibleOrConvertibleFromStatusOr = - absl::disjunction&>, - std::is_constructible&>, - std::is_constructible&&>, - std::is_constructible&&>, - std::is_convertible&, T>, - std::is_convertible&, T>, - std::is_convertible&&, T>, - std::is_convertible&&, T>>; - - template - using IsConstructibleOrConvertibleOrAssignableFromStatusOr = - absl::disjunction, - std::is_assignable&>, - std::is_assignable&>, - std::is_assignable&&>, - std::is_assignable&&>>; - - template - struct IsDirectInitializationAmbiguous - : public absl::conditional_t< - std::is_same>, - U>::value, - std::false_type, - IsDirectInitializationAmbiguous< - T, absl::remove_cv_t>>> {}; - - template - struct IsDirectInitializationAmbiguous> - : public IsConstructibleOrConvertibleFromStatusOr {}; - - template - using IsDirectInitializationValid = absl::disjunction< - // Short circuits if T is basically U. - std::is_same>>, - absl::negation, - absl::remove_cv_t>>, - std::is_same>>, - std::is_same>>, - IsDirectInitializationAmbiguous>>>; - - template - struct IsForwardingAssignmentAmbiguous - : public absl::conditional_t< - std::is_same>, - U>::value, - std::false_type, - IsForwardingAssignmentAmbiguous< - T, absl::remove_cv_t>>> {}; - - template - struct IsForwardingAssignmentAmbiguous> - : public IsConstructibleOrConvertibleOrAssignableFromStatusOr {}; - - template - using IsForwardingAssignmentValid = absl::disjunction< - // Short circuits if T is basically U. - std::is_same>>, - absl::negation, - absl::remove_cv_t>>, - std::is_same>>, - std::is_same>>, - IsForwardingAssignmentAmbiguous>>>; - - template - using IsForwardingAssignmentValid = absl::disjunction< - // Short circuits if T is basically U. - std::is_same>>, - absl::negation, - absl::remove_cv_t>>, - std::is_same>>, - std::is_same>>, - IsForwardingAssignmentAmbiguous>>>; +#include "status_defs.h" - template - struct OperatorBase { - const T& value() const&; - T& value() &; - const T&& value() const&&; - T&& value() &&; - - const T& operator*() const&; - T& operator*() &; - const T&& operator*() const&&; - T&& operator*() &&; - - // To test that analyses are okay if there is a use of operator* - // within this base class. - const T* operator->() const { return __builtin_addressof(**this); } - T* operator->() { return __builtin_addressof(**this); } - }; +template +struct StatusOr; - } // namespace internal_statusor +namespace internal_statusor { - template - struct StatusOr : private internal_statusor::OperatorBase { - explicit StatusOr(); +template +struct HasConversionOperatorToStatusOr : std::false_type {}; - StatusOr(const StatusOr&) = default; - StatusOr& operator=(const StatusOr&) = default; +template +void test(char (*)[sizeof(std::declval().operator absl::StatusOr())]); - StatusOr(StatusOr&&) = default; - StatusOr& operator=(StatusOr&&) = default; +template +struct HasConversionOperatorToStatusOr(0))> + : std::true_type {}; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - std::is_convertible, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr(const StatusOr&); +template +using IsConstructibleOrConvertibleFromStatusOr = + absl::disjunction&>, + std::is_constructible&>, + std::is_constructible&&>, + std::is_constructible&&>, + std::is_convertible&, T>, + std::is_convertible&, T>, + std::is_convertible&&, T>, + std::is_convertible&&, T>>; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - absl::negation>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> - explicit StatusOr(const StatusOr&); +template +using IsConstructibleOrConvertibleOrAssignableFromStatusOr = + absl::disjunction, + std::is_assignable&>, + std::is_assignable&>, + std::is_assignable&&>, + std::is_assignable&&>>; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, std::is_convertible, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr(StatusOr&&); +template +struct IsDirectInitializationAmbiguous + : public absl::conditional_t< + std::is_same>, + U>::value, + std::false_type, + IsDirectInitializationAmbiguous< + T, absl::remove_cv_t>>> {}; + +template +struct IsDirectInitializationAmbiguous> + : public IsConstructibleOrConvertibleFromStatusOr {}; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - absl::negation>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< +template +using IsDirectInitializationValid = absl::disjunction< + // Short circuits if T is basically U. + std::is_same>>, + absl::negation, + absl::remove_cv_t>>, + std::is_same>>, + std::is_same>>, + IsDirectInitializationAmbiguous>>>; + +template +struct IsForwardingAssignmentAmbiguous + : public absl::conditional_t< + std::is_same>, + U>::value, + std::false_type, + IsForwardingAssignmentAmbiguous< + T, absl::remove_cv_t>>> {}; + +template +struct IsForwardingAssignmentAmbiguous> + : public IsConstructibleOrConvertibleOrAssignableFromStatusOr {}; + +template +using IsForwardingAssignmentValid = absl::disjunction< + // Short circuits if T is basically U. + std::is_same>>, + absl::negation, + absl::remove_cv_t>>, + std::is_same>>, + std::is_same>>, + IsForwardingAssignmentAmbiguous>>>; + +template +using IsForwardingAssignmentValid = absl::disjunction< + // Short circuits if T is basically U. + std::is_same>>, + absl::negation, + absl::remove_cv_t>>, + std::is_same>>, + std::is_same>>, + IsForwardingAssignmentAmbiguous>>>; + +template +struct OperatorBase { +const T& value() const&; +T& value() &; +const T&& value() const&&; +T&& value() &&; + +const T& operator*() const&; +T& operator*() &; +const T&& operator*() const&&; +T&& operator*() &&; + +// To test that analyses are okay if there is a use of operator* +// within this base class. +const T* operator->() const { return __builtin_addressof(**this); } +T* operator->() { return __builtin_addressof(**this); } +}; + +} // namespace internal_statusor + +template +struct StatusOr : private internal_statusor::OperatorBase { +explicit StatusOr(); + +StatusOr(const StatusOr&) = default; +StatusOr& operator=(const StatusOr&) = default; + +StatusOr(StatusOr&&) = default; +StatusOr& operator=(StatusOr&&) = default; + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + std::is_convertible, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +StatusOr(const StatusOr&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + absl::negation>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +explicit StatusOr(const StatusOr&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, std::is_convertible, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +StatusOr(StatusOr&&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + absl::negation>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +explicit StatusOr(StatusOr&&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + std::is_assignable, + absl::negation< + internal_statusor:: + IsConstructibleOrConvertibleOrAssignableFromStatusOr< + T, U>>>::value, + int> = 0> +StatusOr& operator=(const StatusOr&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, std::is_assignable, + absl::negation< + internal_statusor:: + IsConstructibleOrConvertibleOrAssignableFromStatusOr< T, U>>>::value, - int> = 0> - explicit StatusOr(StatusOr&&); + int> = 0> +StatusOr& operator=(StatusOr&&); - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - std::is_assignable, - absl::negation< - internal_statusor:: - IsConstructibleOrConvertibleOrAssignableFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr& operator=(const StatusOr&); - - template < - typename U, - absl::enable_if_t< +template , + std::is_constructible, + absl::negation< + std::is_same, absl::StatusOr>>, + absl::negation, T>>, + absl::negation< + std::is_same, absl::in_place_t>>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>::value, + int> = 0> +StatusOr(U&&); + +template >, + std::is_constructible, + absl::negation< + std::is_same, absl::StatusOr>>, + absl::negation, T>>, + absl::negation< + std::is_same, absl::in_place_t>>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>::value, + int> = 0> +explicit StatusOr(U&&); + +template , + std::is_constructible, + absl::negation< + std::is_same, absl::StatusOr>>, + absl::negation, T>>, + absl::negation< + std::is_same, absl::in_place_t>>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>::value, + int> = 0> +StatusOr& operator=(U&&); + +template < + typename U = T, + typename = typename std::enable_if, std::is_assignable, + absl::disjunction< + std::is_same>, T>, absl::conjunction< - absl::negation>, - std::is_constructible, std::is_assignable, + absl::negation>, absl::negation< - internal_statusor:: - IsConstructibleOrConvertibleOrAssignableFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr& operator=(StatusOr&&); - - template , - std::is_constructible, - absl::negation< - std::is_same, absl::StatusOr>>, - absl::negation, T>>, - absl::negation< - std::is_same, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> - StatusOr(U&&); - - template >, - std::is_constructible, - absl::negation< - std::is_same, absl::StatusOr>>, - absl::negation, T>>, - absl::negation< - std::is_same, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> - explicit StatusOr(U&&); - - template , - std::is_constructible, - absl::negation< - std::is_same, absl::StatusOr>>, - absl::negation, T>>, - absl::negation< - std::is_same, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> - StatusOr& operator=(U&&); - - template < - typename U = T, - typename = typename std::enable_if, std::is_assignable, + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>>, + internal_statusor::IsForwardingAssignmentValid>::value>:: + type> +StatusOr& operator=(U&&); + +template +explicit StatusOr(absl::in_place_t, Args&&...); + +template +explicit StatusOr(absl::in_place_t, std::initializer_list, Args&&...); + +template < + typename U = T, + absl::enable_if_t< + absl::conjunction< + internal_statusor::IsDirectInitializationValid, + std::is_constructible, std::is_convertible, absl::disjunction< - std::is_same>, T>, + std::is_same>, + T>, absl::conjunction< absl::negation>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>>>::value, + int> = 0> +StatusOr(U&&); + +template < + typename U = T, + absl::enable_if_t< + absl::conjunction< + internal_statusor::IsDirectInitializationValid, + absl::disjunction< + std::is_same>, + T>, + absl::conjunction< + absl::negation< + std::is_constructible>, absl::negation< internal_statusor::HasConversionOperatorToStatusOr< T, U&&>>>>, - internal_statusor::IsForwardingAssignmentValid>::value>:: - type> - StatusOr& operator=(U&&); + std::is_constructible, + absl::negation>>::value, + int> = 0> +explicit StatusOr(U&&); - template - explicit StatusOr(absl::in_place_t, Args&&...); +bool ok() const; - template - explicit StatusOr(absl::in_place_t, std::initializer_list, Args&&...); +const Status& status() const& { return status_; } +Status status() &&; - template < - typename U = T, - absl::enable_if_t< - absl::conjunction< - internal_statusor::IsDirectInitializationValid, - std::is_constructible, std::is_convertible, - absl::disjunction< - std::is_same>, - T>, - absl::conjunction< - absl::negation>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>>>::value, - int> = 0> - StatusOr(U&&); - - template < - typename U = T, - absl::enable_if_t< - absl::conjunction< - internal_statusor::IsDirectInitializationValid, - absl::disjunction< - std::is_same>, - T>, - absl::conjunction< - absl::negation< - std::is_constructible>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>>, - std::is_constructible, - absl::negation>>::value, - int> = 0> - explicit StatusOr(U&&); - - bool ok() const; - - const Status& status() const& { return status_; } - Status status() &&; - - using StatusOr::OperatorBase::value; - - const T& ValueOrDie() const&; - T& ValueOrDie() &; - const T&& ValueOrDie() const&&; - T&& ValueOrDie() &&; - - using StatusOr::OperatorBase::operator*; - using StatusOr::OperatorBase::operator->; - - template - T value_or(U&& default_value) const&; - template - T value_or(U&& default_value) &&; +using StatusOr::OperatorBase::value; - template - T& emplace(Args&&... args); +const T& ValueOrDie() const&; +T& ValueOrDie() &; +const T&& ValueOrDie() const&&; +T&& ValueOrDie() &&; - template < - typename U, typename... Args, - absl::enable_if_t&, - Args&&...>::value, - int> = 0> - T& emplace(std::initializer_list ilist, Args&&... args); +using StatusOr::OperatorBase::operator*; +using StatusOr::OperatorBase::operator->; - private: - absl::Status status_; - }; +template +T value_or(U&& default_value) const&; +template +T value_or(U&& default_value) &&; - template - bool operator==(const StatusOr& lhs, const StatusOr& rhs); +template +T& emplace(Args&&... args); - template - bool operator!=(const StatusOr& lhs, const StatusOr& rhs); +template < + typename U, typename... Args, + absl::enable_if_t&, + Args&&...>::value, + int> = 0> +T& emplace(std::initializer_list ilist, Args&&... args); - } // namespace absl +private: +absl::Status status_; +}; + +template +bool operator==(const StatusOr& lhs, const StatusOr& rhs); + +template +bool operator!=(const StatusOr& lhs, const StatusOr& rhs); + +} // namespace absl #endif // STATUSOR_H_ - )cc"; +)cc"; static constexpr char StdVectorHeader[] = R"( #ifndef STD_VECTOR_H From 44331ec00e7d776ae98bb07185e98b2b52b1af0f Mon Sep 17 00:00:00 2001 From: Florian Mayer Date: Wed, 15 Oct 2025 12:22:09 -0700 Subject: [PATCH 5/6] format Created using spr 1.3.7 --- .../Analysis/FlowSensitive/MockHeaders.cpp | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp index cd60a33aea6f0..bf16220e874ff 100644 --- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp +++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp @@ -1888,7 +1888,7 @@ constexpr const char AbslLogHeader[] = R"cc( #define PREDICT_FALSE(x) (__builtin_expect(x, 0)) #define ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(lit) lit -#define ABSL_LOG_INTERNAL_STATELESS_CONDITION(condition) \ +#define ABSL_LOG_INTERNAL_STATELESS_CONDITION(condition) \ switch (0) \ case 0: \ default: \ @@ -1903,12 +1903,12 @@ constexpr const char AbslLogHeader[] = R"cc( #define ABSL_LOG_INTERNAL_CONDITION_QFATAL(type, condition) \ ABSL_LOG_INTERNAL_##type##_CONDITION(condition) -#define ABSL_CHECK_IMPL(condition, condition_text) \ +#define ABSL_CHECK_IMPL(condition, condition_text) \ ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ ABSL_PREDICT_FALSE(!(condition))) \ ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() -#define ABSL_QCHECK_IMPL(condition, condition_text) \ +#define ABSL_QCHECK_IMPL(condition, condition_text) \ ABSL_LOG_INTERNAL_CONDITION_QFATAL(STATELESS, \ ABSL_PREDICT_FALSE(!(condition))) \ ABSL_LOG_INTERNAL_QCHECK(condition_text).InternalStream() @@ -1951,13 +1951,13 @@ constexpr const char AbslLogHeader[] = R"cc( } // namespace absl // TODO(tkd): this still doesn't allow operator<<, unlike the real CHECK_ // macros. -#define ABSL_LOG_INTERNAL_CHECK_OP(name, op, val1, val2) \ +#define ABSL_LOG_INTERNAL_CHECK_OP(name, op, val1, val2) \ while (char* _result = ::absl::log_internal::name##Impl( \ ::absl::log_internal::GetReferenceableValue(val1), \ ::absl::log_internal::GetReferenceableValue(val2), \ #val1 " " #op " " #val2)) \ (void)0 -#define ABSL_LOG_INTERNAL_QCHECK_OP(name, op, val1, val2) \ +#define ABSL_LOG_INTERNAL_QCHECK_OP(name, op, val1, val2) \ while (char* _result = ::absl::log_internal::name##Impl( \ ::absl::log_internal::GetReferenceableValue(val1), \ ::absl::log_internal::GetReferenceableValue(val2), \ @@ -1987,7 +1987,7 @@ constexpr const char AbslLogHeader[] = R"cc( ::absl::log_internal::LogMessageFatal() #define ABSL_LOG_INTERNAL_QCHECK(failure_message) \ ::absl::log_internal::LogMessageQuietlyFatal() -#define ABSL_LOG_INTERNAL_CHECK_OK(val) \ +#define ABSL_LOG_INTERNAL_CHECK_OK(val) \ for (::std::pair \ absl_log_internal_check_ok_goo; \ absl_log_internal_check_ok_goo.first = \ @@ -2001,7 +2001,7 @@ constexpr const char AbslLogHeader[] = R"cc( !ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok());) \ ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_ok_goo.second) \ .InternalStream() -#define ABSL_LOG_INTERNAL_QCHECK_OK(val) \ +#define ABSL_LOG_INTERNAL_QCHECK_OK(val) \ for (::std::pair \ absl_log_internal_check_ok_goo; \ absl_log_internal_check_ok_goo.first = \ @@ -2080,7 +2080,7 @@ constexpr const char TestingDefsHeader[] = R"cc( const T1& lhs, const T2& rhs); }; -#define GTEST_IMPL_CMP_HELPER_(op_name) \ +#define GTEST_IMPL_CMP_HELPER_(op_name) \ template \ AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ const T1& val1, const T2& val2); @@ -2167,7 +2167,7 @@ constexpr const char TestingDefsHeader[] = R"cc( } // namespace absl_testing using testing::AssertionResult; -#define EXPECT_TRUE(x) \ +#define EXPECT_TRUE(x) \ switch (0) \ case 0: \ default: \ @@ -2176,12 +2176,12 @@ constexpr const char TestingDefsHeader[] = R"cc( ::testing::Message() #define EXPECT_FALSE(x) EXPECT_TRUE(!(x)) -#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ +#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ switch (0) \ case 0: \ default: -#define GTEST_ASSERT_(expression, on_failure) \ +#define GTEST_ASSERT_(expression, on_failure) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (const ::testing::AssertionResult gtest_ar = (expression)) \ ; \ @@ -2191,7 +2191,7 @@ constexpr const char TestingDefsHeader[] = R"cc( GTEST_ASSERT_(pred_format(#v1, v1), on_failure) #define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure) \ GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), on_failure) -#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ +#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ ::testing::internal::AssertHelper(result_type, file, line, message) = \ ::testing::Message() #define GTEST_MESSAGE_(message, result_type) \ @@ -2206,7 +2206,7 @@ constexpr const char TestingDefsHeader[] = R"cc( #define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) -#define ASSERT_THAT(value, matcher) \ +#define ASSERT_THAT(value, matcher) \ ASSERT_PRED_FORMAT1( \ ::testing::internal::MakePredicateFormatterFromMatcher(matcher), \ value) @@ -2216,13 +2216,13 @@ constexpr const char TestingDefsHeader[] = R"cc( GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) #define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) -#define EXPECT_THAT(value, matcher) \ +#define EXPECT_THAT(value, matcher) \ EXPECT_PRED_FORMAT1( \ ::testing::internal::MakePredicateFormatterFromMatcher(matcher), \ value) #define EXPECT_OK(expression) EXPECT_THAT(expression, ::testing::status::IsOk()) -#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ +#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (const ::testing::AssertionResult gtest_ar_ = \ ::testing::AssertionResult(expression)) \ @@ -2233,7 +2233,7 @@ constexpr const char TestingDefsHeader[] = R"cc( .c_str()) #define GTEST_ASSERT_TRUE(condition) \ GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_) -#define GTEST_ASSERT_FALSE(condition) \ +#define GTEST_ASSERT_FALSE(condition) \ GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ GTEST_FATAL_FAILURE_) #define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition) From 2c349ec3ef823b49d58dc3c4677c1c600395ef69 Mon Sep 17 00:00:00 2001 From: Florian Mayer Date: Wed, 15 Oct 2025 13:02:14 -0700 Subject: [PATCH 6/6] clang-format headers Created using spr 1.3.7 --- .../Analysis/FlowSensitive/MockHeaders.cpp | 1474 ++++++++--------- 1 file changed, 719 insertions(+), 755 deletions(-) diff --git a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp index bf16220e874ff..d3dee58651396 100644 --- a/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp +++ b/clang/unittests/Analysis/FlowSensitive/MockHeaders.cpp @@ -1281,98 +1281,96 @@ constexpr const char StatusDefsHeader[] = #include "absl_type_traits.h" #include "std_initializer_list.h" +#include "std_string.h" #include "std_type_traits.h" #include "std_utility.h" -#include "std_string.h" namespace absl { struct SourceLocation { -static constexpr SourceLocation current(); -static constexpr SourceLocation DoNotInvokeDirectlyNoSeriouslyDont( - int line, const char* file_name); + static constexpr SourceLocation current(); + static constexpr SourceLocation + DoNotInvokeDirectlyNoSeriouslyDont(int line, const char *file_name); }; -} // namespace absl +} // namespace absl namespace absl { enum class StatusCode : int { -kOk, -kCancelled, -kUnknown, -kInvalidArgument, -kDeadlineExceeded, -kNotFound, -kAlreadyExists, -kPermissionDenied, -kResourceExhausted, -kFailedPrecondition, -kAborted, -kOutOfRange, -kUnimplemented, -kInternal, -kUnavailable, -kDataLoss, -kUnauthenticated, + kOk, + kCancelled, + kUnknown, + kInvalidArgument, + kDeadlineExceeded, + kNotFound, + kAlreadyExists, + kPermissionDenied, + kResourceExhausted, + kFailedPrecondition, + kAborted, + kOutOfRange, + kUnimplemented, + kInternal, + kUnavailable, + kDataLoss, + kUnauthenticated, }; -} // namespace absl +} // namespace absl namespace absl { enum class StatusToStringMode : int { -kWithNoExtraData = 0, -kWithPayload = 1 << 0, -kWithSourceLocation = 1 << 1, -kWithEverything = ~kWithNoExtraData, -kDefault = kWithPayload, + kWithNoExtraData = 0, + kWithPayload = 1 << 0, + kWithSourceLocation = 1 << 1, + kWithEverything = ~kWithNoExtraData, + kDefault = kWithPayload, }; class Status { public: -Status(); -template -Status(Enum code, std::string_view msg); -Status(absl::StatusCode code, std::string_view msg, - absl::SourceLocation loc = SourceLocation::current()); -Status(const Status& base_status, absl::SourceLocation loc); -Status(Status&& base_status, absl::SourceLocation loc); -~Status() {} - -Status(const Status&); -Status& operator=(const Status& x); - -Status(Status&&) noexcept; -Status& operator=(Status&&); - -friend bool operator==(const Status&, const Status&); -friend bool operator!=(const Status&, const Status&); - -bool ok() const { return true; } -void CheckSuccess() const; -void IgnoreError() const; -int error_code() const; -absl::Status ToCanonical() const; -std::string ToString( - StatusToStringMode m = StatusToStringMode::kDefault) const; -void Update(const Status& new_status); -void Update(Status&& new_status); + Status(); + template Status(Enum code, std::string_view msg); + Status(absl::StatusCode code, std::string_view msg, + absl::SourceLocation loc = SourceLocation::current()); + Status(const Status &base_status, absl::SourceLocation loc); + Status(Status &&base_status, absl::SourceLocation loc); + ~Status() {} + + Status(const Status &); + Status &operator=(const Status &x); + + Status(Status &&) noexcept; + Status &operator=(Status &&); + + friend bool operator==(const Status &, const Status &); + friend bool operator!=(const Status &, const Status &); + + bool ok() const { return true; } + void CheckSuccess() const; + void IgnoreError() const; + int error_code() const; + absl::Status ToCanonical() const; + std::string + ToString(StatusToStringMode m = StatusToStringMode::kDefault) const; + void Update(const Status &new_status); + void Update(Status &&new_status); }; -bool operator==(const Status& lhs, const Status& rhs); -bool operator!=(const Status& lhs, const Status& rhs); +bool operator==(const Status &lhs, const Status &rhs); +bool operator!=(const Status &lhs, const Status &rhs); Status OkStatus(); -Status InvalidArgumentError(char*); +Status InvalidArgumentError(char *); -#endif // STATUS_H +#endif // STATUS_H )cc"; constexpr const char StatusOrDefsHeader[] = R"cc( #ifndef STATUSOR_H_ #define STATUSOR_H_ #include "absl_type_traits.h" +#include "status_defs.h" #include "std_initializer_list.h" #include "std_type_traits.h" #include "std_utility.h" -#include "status_defs.h" -template -struct StatusOr; +template struct StatusOr; namespace internal_statusor { @@ -1388,31 +1386,31 @@ struct HasConversionOperatorToStatusOr(0))> template using IsConstructibleOrConvertibleFromStatusOr = - absl::disjunction&>, - std::is_constructible&>, - std::is_constructible&&>, - std::is_constructible&&>, - std::is_convertible&, T>, - std::is_convertible&, T>, - std::is_convertible&&, T>, - std::is_convertible&&, T>>; + absl::disjunction &>, + std::is_constructible &>, + std::is_constructible &&>, + std::is_constructible &&>, + std::is_convertible &, T>, + std::is_convertible &, T>, + std::is_convertible &&, T>, + std::is_convertible &&, T>>; template using IsConstructibleOrConvertibleOrAssignableFromStatusOr = absl::disjunction, - std::is_assignable&>, - std::is_assignable&>, - std::is_assignable&&>, - std::is_assignable&&>>; + std::is_assignable &>, + std::is_assignable &>, + std::is_assignable &&>, + std::is_assignable &&>>; template struct IsDirectInitializationAmbiguous : public absl::conditional_t< - std::is_same>, - U>::value, - std::false_type, - IsDirectInitializationAmbiguous< - T, absl::remove_cv_t>>> {}; + std::is_same>, + U>::value, + std::false_type, + IsDirectInitializationAmbiguous< + T, absl::remove_cv_t>>> {}; template struct IsDirectInitializationAmbiguous> @@ -1424,21 +1422,21 @@ using IsDirectInitializationValid = absl::disjunction< std::is_same>>, absl::negation, - absl::remove_cv_t>>, + absl::remove_cv_t>>, std::is_same>>, + absl::remove_cv_t>>, std::is_same>>, + absl::remove_cv_t>>, IsDirectInitializationAmbiguous>>>; template struct IsForwardingAssignmentAmbiguous : public absl::conditional_t< - std::is_same>, - U>::value, - std::false_type, - IsForwardingAssignmentAmbiguous< - T, absl::remove_cv_t>>> {}; + std::is_same>, + U>::value, + std::false_type, + IsForwardingAssignmentAmbiguous< + T, absl::remove_cv_t>>> {}; template struct IsForwardingAssignmentAmbiguous> @@ -1450,11 +1448,11 @@ using IsForwardingAssignmentValid = absl::disjunction< std::is_same>>, absl::negation, - absl::remove_cv_t>>, + absl::remove_cv_t>>, std::is_same>>, + absl::remove_cv_t>>, std::is_same>>, + absl::remove_cv_t>>, IsForwardingAssignmentAmbiguous>>>; template @@ -1463,373 +1461,353 @@ using IsForwardingAssignmentValid = absl::disjunction< std::is_same>>, absl::negation, - absl::remove_cv_t>>, + absl::remove_cv_t>>, std::is_same>>, + absl::remove_cv_t>>, std::is_same>>, + absl::remove_cv_t>>, IsForwardingAssignmentAmbiguous>>>; -template -struct OperatorBase { -const T& value() const&; -T& value() &; -const T&& value() const&&; -T&& value() &&; - -const T& operator*() const&; -T& operator*() &; -const T&& operator*() const&&; -T&& operator*() &&; - -// To test that analyses are okay if there is a use of operator* -// within this base class. -const T* operator->() const { return __builtin_addressof(**this); } -T* operator->() { return __builtin_addressof(**this); } +template struct OperatorBase { + const T &value() const &; + T &value() &; + const T &&value() const &&; + T &&value() &&; + + const T &operator*() const &; + T &operator*() &; + const T &&operator*() const &&; + T &&operator*() &&; + + // To test that analyses are okay if there is a use of operator* + // within this base class. + const T *operator->() const { return __builtin_addressof(**this); } + T *operator->() { return __builtin_addressof(**this); } }; -} // namespace internal_statusor +} // namespace internal_statusor template struct StatusOr : private internal_statusor::OperatorBase { -explicit StatusOr(); - -StatusOr(const StatusOr&) = default; -StatusOr& operator=(const StatusOr&) = default; - -StatusOr(StatusOr&&) = default; -StatusOr& operator=(StatusOr&&) = default; - -template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - std::is_convertible, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> -StatusOr(const StatusOr&); - -template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - absl::negation>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> -explicit StatusOr(const StatusOr&); - -template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, std::is_convertible, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> -StatusOr(StatusOr&&); - -template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - absl::negation>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> -explicit StatusOr(StatusOr&&); - -template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, - std::is_assignable, - absl::negation< - internal_statusor:: - IsConstructibleOrConvertibleOrAssignableFromStatusOr< - T, U>>>::value, - int> = 0> -StatusOr& operator=(const StatusOr&); - -template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation>, - std::is_constructible, std::is_assignable, - absl::negation< - internal_statusor:: - IsConstructibleOrConvertibleOrAssignableFromStatusOr< - T, U>>>::value, - int> = 0> -StatusOr& operator=(StatusOr&&); - -template , - std::is_constructible, - absl::negation< - std::is_same, absl::StatusOr>>, - absl::negation, T>>, - absl::negation< - std::is_same, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> -StatusOr(U&&); + explicit StatusOr(); -template >, - std::is_constructible, - absl::negation< - std::is_same, absl::StatusOr>>, - absl::negation, T>>, - absl::negation< - std::is_same, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> -explicit StatusOr(U&&); + StatusOr(const StatusOr &) = default; + StatusOr &operator=(const StatusOr &) = default; -template , - std::is_constructible, - absl::negation< - std::is_same, absl::StatusOr>>, - absl::negation, T>>, - absl::negation< - std::is_same, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> -StatusOr& operator=(U&&); - -template < - typename U = T, - typename = typename std::enable_if, std::is_assignable, - absl::disjunction< - std::is_same>, T>, - absl::conjunction< - absl::negation>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>>, - internal_statusor::IsForwardingAssignmentValid>::value>:: - type> -StatusOr& operator=(U&&); - -template -explicit StatusOr(absl::in_place_t, Args&&...); - -template -explicit StatusOr(absl::in_place_t, std::initializer_list, Args&&...); - -template < - typename U = T, - absl::enable_if_t< - absl::conjunction< - internal_statusor::IsDirectInitializationValid, - std::is_constructible, std::is_convertible, - absl::disjunction< - std::is_same>, - T>, - absl::conjunction< - absl::negation>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>>>::value, - int> = 0> -StatusOr(U&&); - -template < - typename U = T, - absl::enable_if_t< - absl::conjunction< - internal_statusor::IsDirectInitializationValid, - absl::disjunction< - std::is_same>, - T>, - absl::conjunction< - absl::negation< - std::is_constructible>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>>, - std::is_constructible, - absl::negation>>::value, - int> = 0> -explicit StatusOr(U&&); + StatusOr(StatusOr &&) = default; + StatusOr &operator=(StatusOr &&) = default; + + template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + std::is_convertible, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> + StatusOr(const StatusOr &); + + template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + absl::negation>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> + explicit StatusOr(const StatusOr &); + + template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, std::is_convertible, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> + StatusOr(StatusOr &&); + + template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + absl::negation>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> + explicit StatusOr(StatusOr &&); + + template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + std::is_assignable, + absl::negation< + internal_statusor:: + IsConstructibleOrConvertibleOrAssignableFromStatusOr< + T, U>>>::value, + int> = 0> + StatusOr &operator=(const StatusOr &); + + template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, std::is_assignable, + absl::negation< + internal_statusor:: + IsConstructibleOrConvertibleOrAssignableFromStatusOr< + T, U>>>::value, + int> = 0> + StatusOr &operator=(StatusOr &&); + + template < + typename U = absl::Status, + absl::enable_if_t< + absl::conjunction< + std::is_convertible, + std::is_constructible, + absl::negation, absl::StatusOr>>, + absl::negation, T>>, + absl::negation, absl::in_place_t>>, + absl::negation>>::value, + int> = 0> + StatusOr(U &&); + + template < + typename U = absl::Status, + absl::enable_if_t< + absl::conjunction< + absl::negation>, + std::is_constructible, + absl::negation, absl::StatusOr>>, + absl::negation, T>>, + absl::negation, absl::in_place_t>>, + absl::negation>>::value, + int> = 0> + explicit StatusOr(U &&); + + template < + typename U = absl::Status, + absl::enable_if_t< + absl::conjunction< + std::is_convertible, + std::is_constructible, + absl::negation, absl::StatusOr>>, + absl::negation, T>>, + absl::negation, absl::in_place_t>>, + absl::negation>>::value, + int> = 0> + StatusOr &operator=(U &&); + + template < + typename U = T, + typename = typename std::enable_if, std::is_assignable, + absl::disjunction< + std::is_same>, T>, + absl::conjunction< + absl::negation>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U &&>>>>, + internal_statusor::IsForwardingAssignmentValid>::value>:: + type> + StatusOr &operator=(U &&); + + template explicit StatusOr(absl::in_place_t, Args &&...); + + template + explicit StatusOr(absl::in_place_t, std::initializer_list, Args &&...); + + template < + typename U = T, + absl::enable_if_t< + absl::conjunction< + internal_statusor::IsDirectInitializationValid, + std::is_constructible, std::is_convertible, + absl::disjunction< + std::is_same>, + T>, + absl::conjunction< + absl::negation>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U &&>>>>>::value, + int> = 0> + StatusOr(U &&); + + template < + typename U = T, + absl::enable_if_t< + absl::conjunction< + internal_statusor::IsDirectInitializationValid, + absl::disjunction< + std::is_same>, + T>, + absl::conjunction< + absl::negation>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U &&>>>>, + std::is_constructible, + absl::negation>>::value, + int> = 0> + explicit StatusOr(U &&); -bool ok() const; + bool ok() const; -const Status& status() const& { return status_; } -Status status() &&; + const Status &status() const & { return status_; } + Status status() &&; -using StatusOr::OperatorBase::value; + using StatusOr::OperatorBase::value; -const T& ValueOrDie() const&; -T& ValueOrDie() &; -const T&& ValueOrDie() const&&; -T&& ValueOrDie() &&; + const T &ValueOrDie() const &; + T &ValueOrDie() &; + const T &&ValueOrDie() const &&; + T &&ValueOrDie() &&; -using StatusOr::OperatorBase::operator*; -using StatusOr::OperatorBase::operator->; + using StatusOr::OperatorBase::operator*; + using StatusOr::OperatorBase::operator->; -template -T value_or(U&& default_value) const&; -template -T value_or(U&& default_value) &&; + template T value_or(U &&default_value) const &; + template T value_or(U &&default_value) &&; -template -T& emplace(Args&&... args); + template T &emplace(Args &&...args); -template < - typename U, typename... Args, - absl::enable_if_t&, - Args&&...>::value, + template < + typename U, typename... Args, + absl::enable_if_t &, + Args &&...>::value, int> = 0> -T& emplace(std::initializer_list ilist, Args&&... args); + T &emplace(std::initializer_list ilist, Args &&...args); private: -absl::Status status_; + absl::Status status_; }; template -bool operator==(const StatusOr& lhs, const StatusOr& rhs); +bool operator==(const StatusOr &lhs, const StatusOr &rhs); template -bool operator!=(const StatusOr& lhs, const StatusOr& rhs); +bool operator!=(const StatusOr &lhs, const StatusOr &rhs); -} // namespace absl +} // namespace absl -#endif // STATUSOR_H_ +#endif // STATUSOR_H_ )cc"; -static constexpr char StdVectorHeader[] = R"( +static constexpr char StdVectorHeader[] = R"cc( #ifndef STD_VECTOR_H #define STD_VECTOR_H namespace std { - template - struct allocator { - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef T* pointer; - typedef const T* const_pointer; - typedef T value_type; - - T* allocate(size_t n); - }; +template struct allocator { + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef T *pointer; + typedef const T *const_pointer; + typedef T value_type; + + T *allocate(size_t n); +}; - template - struct allocator_traits { - typedef Alloc allocator_type; - typedef typename allocator_type::value_type value_type; - typedef typename allocator_type::pointer pointer; - typedef typename allocator_type::const_pointer const_pointer; - typedef typename allocator_type::difference_type difference_type; - typedef typename allocator_type::size_type size_type; - }; +template struct allocator_traits { + typedef Alloc allocator_type; + typedef typename allocator_type::value_type value_type; + typedef typename allocator_type::pointer pointer; + typedef typename allocator_type::const_pointer const_pointer; + typedef typename allocator_type::difference_type difference_type; + typedef typename allocator_type::size_type size_type; +}; - template > - class vector { - public: - using value_type = T; - using size_type = typename allocator_traits::size_type; - - // Constructors. - vector() {} - vector(size_type, const Allocator& = Allocator()) {} - vector(initializer_list initializer_list, - const Allocator& = Allocator()) {} - vector(const vector& vector) {} - ~vector(); - - // Modifiers. - void push_back(const T& value); - void push_back(T&& value); - template - T& emplace_back(Args&&... args); - - // Iterators - class InputIterator { - public: - InputIterator(const InputIterator&); - ~InputIterator(); - InputIterator& operator=(const InputIterator&); - InputIterator& operator++(); - T& operator*() const; - bool operator!=(const InputIterator&) const; - bool operator==(const InputIterator&) const; - }; - typedef InputIterator iterator; - typedef const InputIterator const_iterator; - iterator begin() noexcept; - const_iterator begin() const noexcept; - const_iterator cbegin() const noexcept; - iterator end() noexcept; - const_iterator end() const noexcept; - const_iterator cend() const noexcept; - T* data() noexcept; - const T* data() const noexcept; - T& operator[](int n); - const T& operator[](int n) const; - T& at(int n); - const T& at(int n) const; - size_t size() const; +template > class vector { +public: + using value_type = T; + using size_type = typename allocator_traits::size_type; + + // Constructors. + vector() {} + vector(size_type, const Allocator & = Allocator()) {} + vector(initializer_list initializer_list, + const Allocator & = Allocator()) {} + vector(const vector &vector) {} + ~vector(); + + // Modifiers. + void push_back(const T &value); + void push_back(T &&value); + template T &emplace_back(Args &&...args); + + // Iterators + class InputIterator { + public: + InputIterator(const InputIterator &); + ~InputIterator(); + InputIterator &operator=(const InputIterator &); + InputIterator &operator++(); + T &operator*() const; + bool operator!=(const InputIterator &) const; + bool operator==(const InputIterator &) const; }; -} + typedef InputIterator iterator; + typedef const InputIterator const_iterator; + iterator begin() noexcept; + const_iterator begin() const noexcept; + const_iterator cbegin() const noexcept; + iterator end() noexcept; + const_iterator end() const noexcept; + const_iterator cend() const noexcept; + T *data() noexcept; + const T *data() const noexcept; + T &operator[](int n); + const T &operator[](int n) const; + T &at(int n); + const T &at(int n) const; + size_t size() const; +}; +} // namespace std #endif // STD_VECTOR_H -)"; +)cc"; -static constexpr char StdPairHeader[] = R"( +static constexpr char StdPairHeader[] = R"cc( #ifndef STD_PAIR_H #define STD_PAIR_H namespace std { - template - struct pair { - T1 first; - T2 second; +template struct pair { + T1 first; + T2 second; - typedef T1 first_type; - typedef T2 second_type; + typedef T1 first_type; + typedef T2 second_type; - constexpr pair(); + constexpr pair(); - template - pair(pair&& p); + template pair(pair &&p); - template - pair(U1&& x, U2&& y); - }; + template pair(U1 &&x, U2 &&y); +}; - template - pair make_pair(T1&& t1, T2&& t2); -} +template pair make_pair(T1 &&t1, T2 &&t2); +} // namespace std #endif // STD_PAIR_H -)"; +)cc"; constexpr const char AbslLogHeader[] = R"cc( #ifndef ABSL_LOG_H @@ -1837,81 +1815,79 @@ constexpr const char AbslLogHeader[] = R"cc( #include "std_pair.h" - namespace absl { +namespace absl { #define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false)) #define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true)) - namespace log_internal { - class LogMessage { - public: - LogMessage(); - LogMessage& stream(); - LogMessage& InternalStream(); - LogMessage& WithVerbosity(int verboselevel); - template - LogMessage& operator<<(const T&); - }; - class LogMessageFatal : public LogMessage { - public: - LogMessageFatal(); - ~LogMessageFatal() __attribute__((noreturn)); - }; - class LogMessageQuietlyFatal : public LogMessage { - public: - LogMessageQuietlyFatal(); - ~LogMessageQuietlyFatal() __attribute__((noreturn)); - }; - class Voidify final { - public: - // This has to be an operator with a precedence lower than << but higher - // than - // ?: - template - void operator&&(const T&) const&& {} - }; - } // namespace log_internal - } // namespace absl +namespace log_internal { +class LogMessage { +public: + LogMessage(); + LogMessage &stream(); + LogMessage &InternalStream(); + LogMessage &WithVerbosity(int verboselevel); + template LogMessage &operator<<(const T &); +}; +class LogMessageFatal : public LogMessage { +public: + LogMessageFatal(); + ~LogMessageFatal() __attribute__((noreturn)); +}; +class LogMessageQuietlyFatal : public LogMessage { +public: + LogMessageQuietlyFatal(); + ~LogMessageQuietlyFatal() __attribute__((noreturn)); +}; +class Voidify final { +public: + // This has to be an operator with a precedence lower than << but higher + // than + // ?: + template void operator&&(const T &) const && {} +}; +} // namespace log_internal +} // namespace absl #ifndef NULL #define NULL __null #endif - extern "C" void abort() {} +extern "C" void abort() {} #define ABSL_LOG_INTERNAL_LOG_INFO ::absl::log_internal::LogMessage() #define ABSL_LOG_INTERNAL_LOG_WARNING ::absl::log_internal::LogMessage() #define ABSL_LOG_INTERNAL_LOG_ERROR ::absl::log_internal::LogMessage() #define ABSL_LOG_INTERNAL_LOG_FATAL ::absl::log_internal::LogMessageFatal() -#define ABSL_LOG_INTERNAL_LOG_QFATAL \ - ::absl::log_internal::LogMessageQuietlyFatal() +#define ABSL_LOG_INTERNAL_LOG_QFATAL \ + ::absl::log_internal::LogMessageQuietlyFatal() #define LOG(severity) ABSL_LOG_INTERNAL_LOG_##severity.InternalStream() #define PREDICT_FALSE(x) (__builtin_expect(x, 0)) #define ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(lit) lit -#define ABSL_LOG_INTERNAL_STATELESS_CONDITION(condition) \ - switch (0) \ - case 0: \ - default: \ - !(condition) ? (void)0 : ::absl::log_internal::Voidify() && +#define ABSL_LOG_INTERNAL_STATELESS_CONDITION(condition) \ + switch (0) \ + case 0: \ + default: \ + !(condition) ? (void)0 : ::absl::log_internal::Voidify() && -#define ABSL_LOG_INTERNAL_CONDITION_INFO(type, condition) \ - ABSL_LOG_INTERNAL_##type##_CONDITION(condition) +#define ABSL_LOG_INTERNAL_CONDITION_INFO(type, condition) \ + ABSL_LOG_INTERNAL_##type##_CONDITION(condition) -#define ABSL_LOG_INTERNAL_CONDITION_FATAL(type, condition) \ - ABSL_LOG_INTERNAL_##type##_CONDITION(condition) +#define ABSL_LOG_INTERNAL_CONDITION_FATAL(type, condition) \ + ABSL_LOG_INTERNAL_##type##_CONDITION(condition) -#define ABSL_LOG_INTERNAL_CONDITION_QFATAL(type, condition) \ - ABSL_LOG_INTERNAL_##type##_CONDITION(condition) +#define ABSL_LOG_INTERNAL_CONDITION_QFATAL(type, condition) \ + ABSL_LOG_INTERNAL_##type##_CONDITION(condition) -#define ABSL_CHECK_IMPL(condition, condition_text) \ - ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ - ABSL_PREDICT_FALSE(!(condition))) \ - ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() +#define ABSL_CHECK_IMPL(condition, condition_text) \ + ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, \ + ABSL_PREDICT_FALSE(!(condition))) \ + ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream() -#define ABSL_QCHECK_IMPL(condition, condition_text) \ - ABSL_LOG_INTERNAL_CONDITION_QFATAL(STATELESS, \ - ABSL_PREDICT_FALSE(!(condition))) \ - ABSL_LOG_INTERNAL_QCHECK(condition_text).InternalStream() +#define ABSL_QCHECK_IMPL(condition, condition_text) \ + ABSL_LOG_INTERNAL_CONDITION_QFATAL(STATELESS, \ + ABSL_PREDICT_FALSE(!(condition))) \ + ABSL_LOG_INTERNAL_QCHECK(condition_text).InternalStream() #define CHECK(condition) ABSL_CHECK_IMPL((condition), #condition) #define DCHECK(condition) CHECK(condition) @@ -1919,58 +1895,55 @@ constexpr const char AbslLogHeader[] = R"cc( #define ABSL_LOG_INTERNAL_MAX_LOG_VERBOSITY_CHECK(x) - namespace absl { +namespace absl { - template - class StatusOr; - class Status; - - namespace status_internal { - std::string* MakeCheckFailString(const absl::Status* status, - const char* prefix); - } // namespace status_internal - - namespace log_internal { - template - const T& GetReferenceableValue(const T& t); - char GetReferenceableValue(char t); - unsigned char GetReferenceableValue(unsigned char t); - signed char GetReferenceableValue(signed char t); - short GetReferenceableValue(short t); - unsigned short GetReferenceableValue(unsigned short t); - int GetReferenceableValue(int t); - unsigned int GetReferenceableValue(unsigned int t); - long GetReferenceableValue(long t); - unsigned long GetReferenceableValue(unsigned long t); - long long GetReferenceableValue(long long t); - unsigned long long GetReferenceableValue(unsigned long long t); - const absl::Status* AsStatus(const absl::Status& s); - template - const absl::Status* AsStatus(const absl::StatusOr& s); - } // namespace log_internal - } // namespace absl - // TODO(tkd): this still doesn't allow operator<<, unlike the real CHECK_ - // macros. -#define ABSL_LOG_INTERNAL_CHECK_OP(name, op, val1, val2) \ - while (char* _result = ::absl::log_internal::name##Impl( \ - ::absl::log_internal::GetReferenceableValue(val1), \ - ::absl::log_internal::GetReferenceableValue(val2), \ - #val1 " " #op " " #val2)) \ - (void)0 -#define ABSL_LOG_INTERNAL_QCHECK_OP(name, op, val1, val2) \ - while (char* _result = ::absl::log_internal::name##Impl( \ - ::absl::log_internal::GetReferenceableValue(val1), \ - ::absl::log_internal::GetReferenceableValue(val2), \ - #val1 " " #op " " #val2)) \ - (void)0 - namespace absl { - namespace log_internal { - template - char* Check_NEImpl(const T1& v1, const T2& v2, const char* names); - template - char* Check_EQImpl(const T1& v1, const T2& v2, const char* names); - template - char* Check_LTImpl(const T1& v1, const T2& v2, const char* names); +template class StatusOr; +class Status; + +namespace status_internal { +std::string *MakeCheckFailString(const absl::Status *status, + const char *prefix); +} // namespace status_internal + +namespace log_internal { +template const T &GetReferenceableValue(const T &t); +char GetReferenceableValue(char t); +unsigned char GetReferenceableValue(unsigned char t); +signed char GetReferenceableValue(signed char t); +short GetReferenceableValue(short t); +unsigned short GetReferenceableValue(unsigned short t); +int GetReferenceableValue(int t); +unsigned int GetReferenceableValue(unsigned int t); +long GetReferenceableValue(long t); +unsigned long GetReferenceableValue(unsigned long t); +long long GetReferenceableValue(long long t); +unsigned long long GetReferenceableValue(unsigned long long t); +const absl::Status *AsStatus(const absl::Status &s); +template const absl::Status *AsStatus(const absl::StatusOr &s); +} // namespace log_internal +} // namespace absl +// TODO(tkd): this still doesn't allow operator<<, unlike the real CHECK_ +// macros. +#define ABSL_LOG_INTERNAL_CHECK_OP(name, op, val1, val2) \ + while (char *_result = ::absl::log_internal::name##Impl( \ + ::absl::log_internal::GetReferenceableValue(val1), \ + ::absl::log_internal::GetReferenceableValue(val2), \ + #val1 " " #op " " #val2)) \ + (void)0 +#define ABSL_LOG_INTERNAL_QCHECK_OP(name, op, val1, val2) \ + while (char *_result = ::absl::log_internal::name##Impl( \ + ::absl::log_internal::GetReferenceableValue(val1), \ + ::absl::log_internal::GetReferenceableValue(val2), \ + #val1 " " #op " " #val2)) \ + (void)0 +namespace absl { +namespace log_internal { +template +char *Check_NEImpl(const T1 &v1, const T2 &v2, const char *names); +template +char *Check_EQImpl(const T1 &v1, const T2 &v2, const char *names); +template +char *Check_LTImpl(const T1 &v1, const T2 &v2, const char *names); #define CHECK_EQ(a, b) ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, a, b) #define CHECK_NE(a, b) ABSL_LOG_INTERNAL_CHECK_OP(Check_NE, !=, a, b) @@ -1978,43 +1951,43 @@ constexpr const char AbslLogHeader[] = R"cc( #define QCHECK_EQ(a, b) ABSL_LOG_INTERNAL_QCHECK_OP(Check_EQ, ==, a, b) #define QCHECK_NE(a, b) ABSL_LOG_INTERNAL_QCHECK_OP(Check_NE, !=, a, b) - } // namespace log_internal - } // namespace absl +} // namespace log_internal +} // namespace absl #define CHECK_NOTNULL(x) CHECK((x) != nullptr) -#define ABSL_LOG_INTERNAL_CHECK(failure_message) \ - ::absl::log_internal::LogMessageFatal() -#define ABSL_LOG_INTERNAL_QCHECK(failure_message) \ - ::absl::log_internal::LogMessageQuietlyFatal() +#define ABSL_LOG_INTERNAL_CHECK(failure_message) \ + ::absl::log_internal::LogMessageFatal() +#define ABSL_LOG_INTERNAL_QCHECK(failure_message) \ + ::absl::log_internal::LogMessageQuietlyFatal() #define ABSL_LOG_INTERNAL_CHECK_OK(val) \ - for (::std::pair \ - absl_log_internal_check_ok_goo; \ - absl_log_internal_check_ok_goo.first = \ - ::absl::log_internal::AsStatus(val), \ - absl_log_internal_check_ok_goo.second = \ - ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok()) \ - ? nullptr \ - : ::absl::status_internal::MakeCheckFailString( \ - absl_log_internal_check_ok_goo.first, \ - ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(#val " is OK")), \ - !ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok());) \ - ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_ok_goo.second) \ - .InternalStream() + for (::std::pair \ + absl_log_internal_check_ok_goo; \ + absl_log_internal_check_ok_goo.first = \ + ::absl::log_internal::AsStatus(val), \ + absl_log_internal_check_ok_goo.second = \ + ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok()) \ + ? nullptr \ + : ::absl::status_internal::MakeCheckFailString( \ + absl_log_internal_check_ok_goo.first, \ + ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(#val " is OK")), \ + !ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok());) \ + ABSL_LOG_INTERNAL_CHECK(*absl_log_internal_check_ok_goo.second) \ + .InternalStream() #define ABSL_LOG_INTERNAL_QCHECK_OK(val) \ - for (::std::pair \ - absl_log_internal_check_ok_goo; \ - absl_log_internal_check_ok_goo.first = \ - ::absl::log_internal::AsStatus(val), \ - absl_log_internal_check_ok_goo.second = \ - ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok()) \ - ? nullptr \ - : ::absl::status_internal::MakeCheckFailString( \ - absl_log_internal_check_ok_goo.first, \ - ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(#val " is OK")), \ - !ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok());) \ - ABSL_LOG_INTERNAL_QCHECK(*absl_log_internal_check_ok_goo.second) \ - .InternalStream() + for (::std::pair \ + absl_log_internal_check_ok_goo; \ + absl_log_internal_check_ok_goo.first = \ + ::absl::log_internal::AsStatus(val), \ + absl_log_internal_check_ok_goo.second = \ + ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok()) \ + ? nullptr \ + : ::absl::status_internal::MakeCheckFailString( \ + absl_log_internal_check_ok_goo.first, \ + ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(#val " is OK")), \ + !ABSL_PREDICT_TRUE(absl_log_internal_check_ok_goo.first->ok());) \ + ABSL_LOG_INTERNAL_QCHECK(*absl_log_internal_check_ok_goo.second) \ + .InternalStream() #define CHECK_OK(val) ABSL_LOG_INTERNAL_CHECK_OK(val) #define DCHECK_OK(val) ABSL_LOG_INTERNAL_CHECK_OK(val) @@ -2031,241 +2004,232 @@ constexpr const char TestingDefsHeader[] = R"cc( #include "absl_type_traits.h" #include "std_initializer_list.h" +#include "std_string.h" #include "std_type_traits.h" #include "std_utility.h" -#include "std_string.h" - namespace testing { - struct AssertionResult { - template - explicit AssertionResult(const T& res, bool enable_if = true) {} - ~AssertionResult(); - operator bool() const; - template - AssertionResult& operator<<(const T& value); - const char* failure_message() const; - }; +namespace testing { +struct AssertionResult { + template + explicit AssertionResult(const T &res, bool enable_if = true) {} + ~AssertionResult(); + operator bool() const; + template AssertionResult &operator<<(const T &value); + const char *failure_message() const; +}; - class TestPartResult { - public: - enum Type { kSuccess, kNonFatalFailure, kFatalFailure, kSkip }; - }; +class TestPartResult { +public: + enum Type { kSuccess, kNonFatalFailure, kFatalFailure, kSkip }; +}; - class Test { - public: - virtual ~Test() = default; +class Test { +public: + virtual ~Test() = default; - protected: - virtual void SetUp() {} - }; +protected: + virtual void SetUp() {} +}; - class Message { - public: - template - Message& operator<<(const T& val); - }; +class Message { +public: + template Message &operator<<(const T &val); +}; - namespace internal { - class AssertHelper { - public: - AssertHelper(TestPartResult::Type type, const char* file, int line, - const char* message); - void operator=(const Message& message) const; - }; +namespace internal { +class AssertHelper { +public: + AssertHelper(TestPartResult::Type type, const char *file, int line, + const char *message); + void operator=(const Message &message) const; +}; - class EqHelper { - public: - template - static AssertionResult Compare(const char* lhx, const char* rhx, - const T1& lhs, const T2& rhs); - }; +class EqHelper { +public: + template + static AssertionResult Compare(const char *lhx, const char *rhx, + const T1 &lhs, const T2 &rhs); +}; -#define GTEST_IMPL_CMP_HELPER_(op_name) \ - template \ - AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ - const T1& val1, const T2& val2); +#define GTEST_IMPL_CMP_HELPER_(op_name) \ + template \ + AssertionResult CmpHelper##op_name(const char *expr1, const char *expr2, \ + const T1 &val1, const T2 &val2); - GTEST_IMPL_CMP_HELPER_(NE) - GTEST_IMPL_CMP_HELPER_(LE) - GTEST_IMPL_CMP_HELPER_(LT) - GTEST_IMPL_CMP_HELPER_(GE) - GTEST_IMPL_CMP_HELPER_(GT) +GTEST_IMPL_CMP_HELPER_(NE) +GTEST_IMPL_CMP_HELPER_(LE) +GTEST_IMPL_CMP_HELPER_(LT) +GTEST_IMPL_CMP_HELPER_(GE) +GTEST_IMPL_CMP_HELPER_(GT) #undef GTEST_IMPL_CMP_HELPER_ - std::string GetBoolAssertionFailureMessage( - const AssertionResult& assertion_result, const char* expression_text, - const char* actual_predicate_value, const char* expected_predicate_value); +std::string GetBoolAssertionFailureMessage( + const AssertionResult &assertion_result, const char *expression_text, + const char *actual_predicate_value, const char *expected_predicate_value); - template - class PredicateFormatterFromMatcher { - public: - template - AssertionResult operator()(const char* value_text, const T& x) const; - }; +template class PredicateFormatterFromMatcher { +public: + template + AssertionResult operator()(const char *value_text, const T &x) const; +}; - template - inline PredicateFormatterFromMatcher MakePredicateFormatterFromMatcher( - M matcher) { - return PredicateFormatterFromMatcher(); - } - } // namespace internal - - namespace status { - namespace internal_status { - class IsOkMatcher {}; - - class StatusIsMatcher {}; - - class CanonicalStatusIsMatcher {}; - - template - class IsOkAndHoldsMatcher {}; - - } // namespace internal_status - - internal_status::IsOkMatcher IsOk(); - - template - internal_status::StatusIsMatcher StatusIs(StatusCodeMatcher&& code_matcher); - - template - internal_status::CanonicalStatusIsMatcher CanonicalStatusIs( - StatusCodeMatcher&& code_matcher); - - template - internal_status::IsOkAndHoldsMatcher IsOkAndHolds( - InnerMatcher m); - } // namespace status - - class IsTrueMatcher {}; - IsTrueMatcher IsTrue(); - - class IsFalseMatcher {}; - IsFalseMatcher IsFalse(); - - } // namespace testing - - namespace absl_testing { - namespace status_internal { - class IsOkMatcher {}; - template - class IsOkAndHoldsMatcher {}; - class StatusIsMatcher {}; - class CanonicalStatusIsMatcher {}; - } // namespace status_internal - status_internal::IsOkMatcher IsOk(); - template - status_internal::IsOkAndHoldsMatcher IsOkAndHolds( - InnerMatcher m); - template - status_internal::StatusIsMatcher StatusIs(StatusCodeMatcher&& code_matcher); - - template - status_internal::CanonicalStatusIsMatcher CanonicalStatusIs( - StatusCodeMatcher&& code_matcher); - } // namespace absl_testing - - using testing::AssertionResult; -#define EXPECT_TRUE(x) \ - switch (0) \ - case 0: \ - default: \ - if (const AssertionResult gtest_ar_ = AssertionResult(x)) { \ - } else /* NOLINT */ \ - ::testing::Message() +template +inline PredicateFormatterFromMatcher +MakePredicateFormatterFromMatcher(M matcher) { + return PredicateFormatterFromMatcher(); +} +} // namespace internal + +namespace status { +namespace internal_status { +class IsOkMatcher {}; + +class StatusIsMatcher {}; + +class CanonicalStatusIsMatcher {}; + +template class IsOkAndHoldsMatcher {}; + +} // namespace internal_status + +internal_status::IsOkMatcher IsOk(); + +template +internal_status::StatusIsMatcher StatusIs(StatusCodeMatcher &&code_matcher); + +template +internal_status::CanonicalStatusIsMatcher +CanonicalStatusIs(StatusCodeMatcher &&code_matcher); + +template +internal_status::IsOkAndHoldsMatcher IsOkAndHolds(InnerMatcher m); +} // namespace status + +class IsTrueMatcher {}; +IsTrueMatcher IsTrue(); + +class IsFalseMatcher {}; +IsFalseMatcher IsFalse(); + +} // namespace testing + +namespace absl_testing { +namespace status_internal { +class IsOkMatcher {}; +template class IsOkAndHoldsMatcher {}; +class StatusIsMatcher {}; +class CanonicalStatusIsMatcher {}; +} // namespace status_internal +status_internal::IsOkMatcher IsOk(); +template +status_internal::IsOkAndHoldsMatcher IsOkAndHolds(InnerMatcher m); +template +status_internal::StatusIsMatcher StatusIs(StatusCodeMatcher &&code_matcher); + +template +status_internal::CanonicalStatusIsMatcher +CanonicalStatusIs(StatusCodeMatcher &&code_matcher); +} // namespace absl_testing + +using testing::AssertionResult; +#define EXPECT_TRUE(x) \ + switch (0) \ + case 0: \ + default: \ + if (const AssertionResult gtest_ar_ = AssertionResult(x)) { \ + } else /* NOLINT */ \ + ::testing::Message() #define EXPECT_FALSE(x) EXPECT_TRUE(!(x)) -#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - switch (0) \ - case 0: \ - default: - -#define GTEST_ASSERT_(expression, on_failure) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (const ::testing::AssertionResult gtest_ar = (expression)) \ - ; \ - else \ - on_failure(gtest_ar.failure_message()) -#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure) \ - GTEST_ASSERT_(pred_format(#v1, v1), on_failure) -#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure) \ - GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), on_failure) -#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ - ::testing::internal::AssertHelper(result_type, file, line, message) = \ - ::testing::Message() -#define GTEST_MESSAGE_(message, result_type) \ - GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) -#define GTEST_FATAL_FAILURE_(message) \ - return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) -#define GTEST_NONFATAL_FAILURE_(message) \ - GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) - -#define ASSERT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) -#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) - -#define ASSERT_THAT(value, matcher) \ - ASSERT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), \ - value) +#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + switch (0) \ + case 0: \ + default: + +#define GTEST_ASSERT_(expression, on_failure) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::testing::AssertionResult gtest_ar = (expression)) \ + ; \ + else \ + on_failure(gtest_ar.failure_message()) +#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure) \ + GTEST_ASSERT_(pred_format(#v1, v1), on_failure) +#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure) \ + GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), on_failure) +#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ + ::testing::internal::AssertHelper(result_type, file, line, message) = \ + ::testing::Message() +#define GTEST_MESSAGE_(message, result_type) \ + GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) +#define GTEST_FATAL_FAILURE_(message) \ + return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) +#define GTEST_NONFATAL_FAILURE_(message) \ + GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) + +#define ASSERT_PRED_FORMAT1(pred_format, v1) \ + GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ + GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) + +#define ASSERT_THAT(value, matcher) \ + ASSERT_PRED_FORMAT1( \ + ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) #define ASSERT_OK(x) ASSERT_THAT(x, ::testing::status::IsOk()) -#define EXPECT_PRED_FORMAT1(pred_format, v1) \ - GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) -#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ - GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) -#define EXPECT_THAT(value, matcher) \ - EXPECT_PRED_FORMAT1( \ - ::testing::internal::MakePredicateFormatterFromMatcher(matcher), \ - value) +#define EXPECT_PRED_FORMAT1(pred_format, v1) \ + GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ + GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) +#define EXPECT_THAT(value, matcher) \ + EXPECT_PRED_FORMAT1( \ + ::testing::internal::MakePredicateFormatterFromMatcher(matcher), value) #define EXPECT_OK(expression) EXPECT_THAT(expression, ::testing::status::IsOk()) -#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ - GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ - if (const ::testing::AssertionResult gtest_ar_ = \ - ::testing::AssertionResult(expression)) \ - ; \ - else \ - fail(::testing::internal::GetBoolAssertionFailureMessage( \ - gtest_ar_, text, #actual, #expected) \ - .c_str()) -#define GTEST_ASSERT_TRUE(condition) \ - GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_) -#define GTEST_ASSERT_FALSE(condition) \ - GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ - GTEST_FATAL_FAILURE_) +#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::testing::AssertionResult gtest_ar_ = \ + ::testing::AssertionResult(expression)) \ + ; \ + else \ + fail(::testing::internal::GetBoolAssertionFailureMessage( \ + gtest_ar_, text, #actual, #expected) \ + .c_str()) +#define GTEST_ASSERT_TRUE(condition) \ + GTEST_TEST_BOOLEAN_(condition, #condition, false, true, GTEST_FATAL_FAILURE_) +#define GTEST_ASSERT_FALSE(condition) \ + GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ + GTEST_FATAL_FAILURE_) #define ASSERT_TRUE(condition) GTEST_ASSERT_TRUE(condition) #define ASSERT_FALSE(condition) GTEST_ASSERT_FALSE(condition) -#define EXPECT_EQ(x, y) \ - EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, x, y) -#define EXPECT_NE(x, y) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, x, y) -#define EXPECT_LT(x, y) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, x, y) -#define EXPECT_GT(x, y) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, x, y) -#define EXPECT_LE(x, y) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, x, y) -#define EXPECT_GE(x, y) \ - EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, x, y) - -#define ASSERT_EQ(x, y) \ - ASSERT_PRED_FORMAT2(testing::internal::EqHelper::Compare, x, y) -#define ASSERT_NE(x, y) \ - ASSERT_PRED_FORMAT2(testing::internal::CmpHelperNE, x, y) -#define ASSERT_LT(x, y) \ - ASSERT_PRED_FORMAT2(testing::internal::CmpHelperLT, x, y) -#define ASSERT_GT(x, y) \ - ASSERT_PRED_FORMAT2(testing::internal::CmpHelperGT, x, y) -#define ASSERT_LE(x, y) \ - ASSERT_PRED_FORMAT2(testing::internal::CmpHelperLE, x, y) -#define ASSERT_GE(x, y) \ - ASSERT_PRED_FORMAT2(testing::internal::CmpHelperGE, x, y) - -#endif // TESTING_DEFS_H +#define EXPECT_EQ(x, y) \ + EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, x, y) +#define EXPECT_NE(x, y) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, x, y) +#define EXPECT_LT(x, y) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, x, y) +#define EXPECT_GT(x, y) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, x, y) +#define EXPECT_LE(x, y) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, x, y) +#define EXPECT_GE(x, y) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, x, y) + +#define ASSERT_EQ(x, y) \ + ASSERT_PRED_FORMAT2(testing::internal::EqHelper::Compare, x, y) +#define ASSERT_NE(x, y) \ + ASSERT_PRED_FORMAT2(testing::internal::CmpHelperNE, x, y) +#define ASSERT_LT(x, y) \ + ASSERT_PRED_FORMAT2(testing::internal::CmpHelperLT, x, y) +#define ASSERT_GT(x, y) \ + ASSERT_PRED_FORMAT2(testing::internal::CmpHelperGT, x, y) +#define ASSERT_LE(x, y) \ + ASSERT_PRED_FORMAT2(testing::internal::CmpHelperLE, x, y) +#define ASSERT_GE(x, y) \ + ASSERT_PRED_FORMAT2(testing::internal::CmpHelperGE, x, y) + +#endif // TESTING_DEFS_H )cc"; std::vector> getMockHeaders() {