https://github.com/fmayer updated https://github.com/llvm/llvm-project/pull/163261
>From 18bd65cd2f69f58b31e3789d1bffe2cf0a8c6d0c Mon Sep 17 00:00:00 2001 From: Florian Mayer <[email protected]> Date: Mon, 13 Oct 2025 13:23:12 -0700 Subject: [PATCH 1/5] =?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 <[email protected]> Date: Mon, 13 Oct 2025 13:30:58 -0700 Subject: [PATCH 2/5] 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 <[email protected]> Date: Mon, 13 Oct 2025 14:05:13 -0700 Subject: [PATCH 3/5] 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 <typename T> class optional; >From 7e71109b219185b90b85d21c4661915b9dd576c3 Mon Sep 17 00:00:00 2001 From: Florian Mayer <[email protected]> Date: Wed, 15 Oct 2025 11:26:49 -0700 Subject: [PATCH 4/5] 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 <typename Enum> - 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 <typename Enum> +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 <typename T> - struct StatusOr; - - namespace internal_statusor { - - template <typename T, typename U, typename = void> - struct HasConversionOperatorToStatusOr : std::false_type {}; - - template <typename T, typename U> - void test(char (*)[sizeof(std::declval<U>().operator absl::StatusOr<T>())]); - - template <typename T, typename U> - struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))> - : std::true_type {}; - - template <typename T, typename U> - using IsConstructibleOrConvertibleFromStatusOr = - absl::disjunction<std::is_constructible<T, StatusOr<U>&>, - std::is_constructible<T, const StatusOr<U>&>, - std::is_constructible<T, StatusOr<U>&&>, - std::is_constructible<T, const StatusOr<U>&&>, - std::is_convertible<StatusOr<U>&, T>, - std::is_convertible<const StatusOr<U>&, T>, - std::is_convertible<StatusOr<U>&&, T>, - std::is_convertible<const StatusOr<U>&&, T>>; - - template <typename T, typename U> - using IsConstructibleOrConvertibleOrAssignableFromStatusOr = - absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>, - std::is_assignable<T&, StatusOr<U>&>, - std::is_assignable<T&, const StatusOr<U>&>, - std::is_assignable<T&, StatusOr<U>&&>, - std::is_assignable<T&, const StatusOr<U>&&>>; - - template <typename T, typename U> - struct IsDirectInitializationAmbiguous - : public absl::conditional_t< - std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, - U>::value, - std::false_type, - IsDirectInitializationAmbiguous< - T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {}; - - template <typename T, typename V> - struct IsDirectInitializationAmbiguous<T, absl::StatusOr<V>> - : public IsConstructibleOrConvertibleFromStatusOr<T, V> {}; - - template <typename T, typename U> - using IsDirectInitializationValid = absl::disjunction< - // Short circuits if T is basically U. - std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>, - absl::negation<absl::disjunction< - std::is_same<absl::StatusOr<T>, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - std::is_same<absl::Status, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - std::is_same<absl::in_place_t, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - IsDirectInitializationAmbiguous<T, U>>>>; - - template <typename T, typename U> - struct IsForwardingAssignmentAmbiguous - : public absl::conditional_t< - std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, - U>::value, - std::false_type, - IsForwardingAssignmentAmbiguous< - T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {}; - - template <typename T, typename U> - struct IsForwardingAssignmentAmbiguous<T, absl::StatusOr<U>> - : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {}; - - template <typename T, typename U> - using IsForwardingAssignmentValid = absl::disjunction< - // Short circuits if T is basically U. - std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>, - absl::negation<absl::disjunction< - std::is_same<absl::StatusOr<T>, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - std::is_same<absl::Status, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - std::is_same<absl::in_place_t, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - IsForwardingAssignmentAmbiguous<T, U>>>>; - - template <typename T, typename U> - using IsForwardingAssignmentValid = absl::disjunction< - // Short circuits if T is basically U. - std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>, - absl::negation<absl::disjunction< - std::is_same<absl::StatusOr<T>, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - std::is_same<absl::Status, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - std::is_same<absl::in_place_t, - absl::remove_cv_t<absl::remove_reference_t<U>>>, - IsForwardingAssignmentAmbiguous<T, U>>>>; +#include "status_defs.h" - template <typename T> - 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 <typename T> +struct StatusOr; - } // namespace internal_statusor +namespace internal_statusor { - template <typename T> - struct StatusOr : private internal_statusor::OperatorBase<T> { - explicit StatusOr(); +template <typename T, typename U, typename = void> +struct HasConversionOperatorToStatusOr : std::false_type {}; - StatusOr(const StatusOr&) = default; - StatusOr& operator=(const StatusOr&) = default; +template <typename T, typename U> +void test(char (*)[sizeof(std::declval<U>().operator absl::StatusOr<T>())]); - StatusOr(StatusOr&&) = default; - StatusOr& operator=(StatusOr&&) = default; +template <typename T, typename U> +struct HasConversionOperatorToStatusOr<T, U, decltype(test<T, U>(0))> + : std::true_type {}; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation<std::is_same<T, U>>, - std::is_constructible<T, const U&>, - std::is_convertible<const U&, T>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr(const StatusOr<U>&); +template <typename T, typename U> +using IsConstructibleOrConvertibleFromStatusOr = + absl::disjunction<std::is_constructible<T, StatusOr<U>&>, + std::is_constructible<T, const StatusOr<U>&>, + std::is_constructible<T, StatusOr<U>&&>, + std::is_constructible<T, const StatusOr<U>&&>, + std::is_convertible<StatusOr<U>&, T>, + std::is_convertible<const StatusOr<U>&, T>, + std::is_convertible<StatusOr<U>&&, T>, + std::is_convertible<const StatusOr<U>&&, T>>; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation<std::is_same<T, U>>, - std::is_constructible<T, const U&>, - absl::negation<std::is_convertible<const U&, T>>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> - explicit StatusOr(const StatusOr<U>&); +template <typename T, typename U> +using IsConstructibleOrConvertibleOrAssignableFromStatusOr = + absl::disjunction<IsConstructibleOrConvertibleFromStatusOr<T, U>, + std::is_assignable<T&, StatusOr<U>&>, + std::is_assignable<T&, const StatusOr<U>&>, + std::is_assignable<T&, StatusOr<U>&&>, + std::is_assignable<T&, const StatusOr<U>&&>>; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation<std::is_same<T, U>>, - std::is_constructible<T, U&&>, std::is_convertible<U&&, T>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr(StatusOr<U>&&); +template <typename T, typename U> +struct IsDirectInitializationAmbiguous + : public absl::conditional_t< + std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, + U>::value, + std::false_type, + IsDirectInitializationAmbiguous< + T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {}; + +template <typename T, typename V> +struct IsDirectInitializationAmbiguous<T, absl::StatusOr<V>> + : public IsConstructibleOrConvertibleFromStatusOr<T, V> {}; - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation<std::is_same<T, U>>, - std::is_constructible<T, U&&>, - absl::negation<std::is_convertible<U&&, T>>, - absl::negation< - internal_statusor::IsConstructibleOrConvertibleFromStatusOr< +template <typename T, typename U> +using IsDirectInitializationValid = absl::disjunction< + // Short circuits if T is basically U. + std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>, + absl::negation<absl::disjunction< + std::is_same<absl::StatusOr<T>, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + std::is_same<absl::Status, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + std::is_same<absl::in_place_t, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + IsDirectInitializationAmbiguous<T, U>>>>; + +template <typename T, typename U> +struct IsForwardingAssignmentAmbiguous + : public absl::conditional_t< + std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, + U>::value, + std::false_type, + IsForwardingAssignmentAmbiguous< + T, absl::remove_cv_t<absl::remove_reference_t<U>>>> {}; + +template <typename T, typename U> +struct IsForwardingAssignmentAmbiguous<T, absl::StatusOr<U>> + : public IsConstructibleOrConvertibleOrAssignableFromStatusOr<T, U> {}; + +template <typename T, typename U> +using IsForwardingAssignmentValid = absl::disjunction< + // Short circuits if T is basically U. + std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>, + absl::negation<absl::disjunction< + std::is_same<absl::StatusOr<T>, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + std::is_same<absl::Status, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + std::is_same<absl::in_place_t, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + IsForwardingAssignmentAmbiguous<T, U>>>>; + +template <typename T, typename U> +using IsForwardingAssignmentValid = absl::disjunction< + // Short circuits if T is basically U. + std::is_same<T, absl::remove_cv_t<absl::remove_reference_t<U>>>, + absl::negation<absl::disjunction< + std::is_same<absl::StatusOr<T>, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + std::is_same<absl::Status, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + std::is_same<absl::in_place_t, + absl::remove_cv_t<absl::remove_reference_t<U>>>, + IsForwardingAssignmentAmbiguous<T, U>>>>; + +template <typename T> +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 <typename T> +struct StatusOr : private internal_statusor::OperatorBase<T> { +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_same<T, U>>, + std::is_constructible<T, const U&>, + std::is_convertible<const U&, T>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +StatusOr(const StatusOr<U>&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation<std::is_same<T, U>>, + std::is_constructible<T, const U&>, + absl::negation<std::is_convertible<const U&, T>>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +explicit StatusOr(const StatusOr<U>&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation<std::is_same<T, U>>, + std::is_constructible<T, U&&>, std::is_convertible<U&&, T>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +StatusOr(StatusOr<U>&&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation<std::is_same<T, U>>, + std::is_constructible<T, U&&>, + absl::negation<std::is_convertible<U&&, T>>, + absl::negation< + internal_statusor::IsConstructibleOrConvertibleFromStatusOr< + T, U>>>::value, + int> = 0> +explicit StatusOr(StatusOr<U>&&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation<std::is_same<T, U>>, + std::is_constructible<T, const U&>, + std::is_assignable<T, const U&>, + absl::negation< + internal_statusor:: + IsConstructibleOrConvertibleOrAssignableFromStatusOr< + T, U>>>::value, + int> = 0> +StatusOr& operator=(const StatusOr<U>&); + +template < + typename U, + absl::enable_if_t< + absl::conjunction< + absl::negation<std::is_same<T, U>>, + std::is_constructible<T, U&&>, std::is_assignable<T, U&&>, + absl::negation< + internal_statusor:: + IsConstructibleOrConvertibleOrAssignableFromStatusOr< T, U>>>::value, - int> = 0> - explicit StatusOr(StatusOr<U>&&); + int> = 0> +StatusOr& operator=(StatusOr<U>&&); - template < - typename U, - absl::enable_if_t< - absl::conjunction< - absl::negation<std::is_same<T, U>>, - std::is_constructible<T, const U&>, - std::is_assignable<T, const U&>, - absl::negation< - internal_statusor:: - IsConstructibleOrConvertibleOrAssignableFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr& operator=(const StatusOr<U>&); - - template < - typename U, - absl::enable_if_t< +template <typename U = absl::Status, + absl::enable_if_t< + absl::conjunction< + std::is_convertible<U&&, absl::Status>, + std::is_constructible<absl::Status, U&&>, + absl::negation< + std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>, + absl::negation<std::is_same<absl::decay_t<U>, T>>, + absl::negation< + std::is_same<absl::decay_t<U>, absl::in_place_t>>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>::value, + int> = 0> +StatusOr(U&&); + +template <typename U = absl::Status, + absl::enable_if_t< + absl::conjunction< + absl::negation<std::is_convertible<U&&, absl::Status>>, + std::is_constructible<absl::Status, U&&>, + absl::negation< + std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>, + absl::negation<std::is_same<absl::decay_t<U>, T>>, + absl::negation< + std::is_same<absl::decay_t<U>, absl::in_place_t>>, + absl::negation< + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>::value, + int> = 0> +explicit StatusOr(U&&); + +template <typename U = absl::Status, + absl::enable_if_t< + absl::conjunction< + std::is_convertible<U&&, absl::Status>, + std::is_constructible<absl::Status, U&&>, + absl::negation< + std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>, + absl::negation<std::is_same<absl::decay_t<U>, T>>, + absl::negation< + std::is_same<absl::decay_t<U>, 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<absl::conjunction< + std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>, + absl::disjunction< + std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, T>, absl::conjunction< - absl::negation<std::is_same<T, U>>, - std::is_constructible<T, U&&>, std::is_assignable<T, U&&>, + absl::negation<std::is_convertible<U&&, absl::Status>>, absl::negation< - internal_statusor:: - IsConstructibleOrConvertibleOrAssignableFromStatusOr< - T, U>>>::value, - int> = 0> - StatusOr& operator=(StatusOr<U>&&); - - template <typename U = absl::Status, - absl::enable_if_t< - absl::conjunction< - std::is_convertible<U&&, absl::Status>, - std::is_constructible<absl::Status, U&&>, - absl::negation< - std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>, - absl::negation<std::is_same<absl::decay_t<U>, T>>, - absl::negation< - std::is_same<absl::decay_t<U>, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> - StatusOr(U&&); - - template <typename U = absl::Status, - absl::enable_if_t< - absl::conjunction< - absl::negation<std::is_convertible<U&&, absl::Status>>, - std::is_constructible<absl::Status, U&&>, - absl::negation< - std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>, - absl::negation<std::is_same<absl::decay_t<U>, T>>, - absl::negation< - std::is_same<absl::decay_t<U>, absl::in_place_t>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>::value, - int> = 0> - explicit StatusOr(U&&); - - template <typename U = absl::Status, - absl::enable_if_t< - absl::conjunction< - std::is_convertible<U&&, absl::Status>, - std::is_constructible<absl::Status, U&&>, - absl::negation< - std::is_same<absl::decay_t<U>, absl::StatusOr<T>>>, - absl::negation<std::is_same<absl::decay_t<U>, T>>, - absl::negation< - std::is_same<absl::decay_t<U>, 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<absl::conjunction< - std::is_constructible<T, U&&>, std::is_assignable<T&, U&&>, + internal_statusor::HasConversionOperatorToStatusOr< + T, U&&>>>>, + internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>:: + type> +StatusOr& operator=(U&&); + +template <typename... Args> +explicit StatusOr(absl::in_place_t, Args&&...); + +template <typename U, typename... Args> +explicit StatusOr(absl::in_place_t, std::initializer_list<U>, Args&&...); + +template < + typename U = T, + absl::enable_if_t< + absl::conjunction< + internal_statusor::IsDirectInitializationValid<T, U&&>, + std::is_constructible<T, U&&>, std::is_convertible<U&&, T>, absl::disjunction< - std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, T>, + std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, + T>, absl::conjunction< absl::negation<std::is_convertible<U&&, absl::Status>>, + 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<T, U&&>, + absl::disjunction< + std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, + T>, + absl::conjunction< + absl::negation< + std::is_constructible<absl::Status, U&&>>, absl::negation< internal_statusor::HasConversionOperatorToStatusOr< T, U&&>>>>, - internal_statusor::IsForwardingAssignmentValid<T, U&&>>::value>:: - type> - StatusOr& operator=(U&&); + std::is_constructible<T, U&&>, + absl::negation<std::is_convertible<U&&, T>>>::value, + int> = 0> +explicit StatusOr(U&&); - template <typename... Args> - explicit StatusOr(absl::in_place_t, Args&&...); +bool ok() const; - template <typename U, typename... Args> - explicit StatusOr(absl::in_place_t, std::initializer_list<U>, Args&&...); +const Status& status() const& { return status_; } +Status status() &&; - template < - typename U = T, - absl::enable_if_t< - absl::conjunction< - internal_statusor::IsDirectInitializationValid<T, U&&>, - std::is_constructible<T, U&&>, std::is_convertible<U&&, T>, - absl::disjunction< - std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, - T>, - absl::conjunction< - absl::negation<std::is_convertible<U&&, absl::Status>>, - 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<T, U&&>, - absl::disjunction< - std::is_same<absl::remove_cv_t<absl::remove_reference_t<U>>, - T>, - absl::conjunction< - absl::negation< - std::is_constructible<absl::Status, U&&>>, - absl::negation< - internal_statusor::HasConversionOperatorToStatusOr< - T, U&&>>>>, - std::is_constructible<T, U&&>, - absl::negation<std::is_convertible<U&&, T>>>::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 <typename U> - T value_or(U&& default_value) const&; - template <typename U> - T value_or(U&& default_value) &&; +using StatusOr::OperatorBase::value; - template <typename... Args> - 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<std::is_constructible<T, std::initializer_list<U>&, - Args&&...>::value, - int> = 0> - T& emplace(std::initializer_list<U> ilist, Args&&... args); +using StatusOr::OperatorBase::operator*; +using StatusOr::OperatorBase::operator->; - private: - absl::Status status_; - }; +template <typename U> +T value_or(U&& default_value) const&; +template <typename U> +T value_or(U&& default_value) &&; - template <typename T> - bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs); +template <typename... Args> +T& emplace(Args&&... args); - template <typename T> - bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs); +template < + typename U, typename... Args, + absl::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, + Args&&...>::value, + int> = 0> +T& emplace(std::initializer_list<U> ilist, Args&&... args); - } // namespace absl +private: +absl::Status status_; +}; + +template <typename T> +bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs); + +template <typename T> +bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& 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 <[email protected]> Date: Wed, 15 Oct 2025 12:22:09 -0700 Subject: [PATCH 5/5] 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<const ::absl::Status*, ::std::string*> \ 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<const ::absl::Status*, ::std::string*> \ 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 <typename T1, typename T2> \ 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) _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
