[clang] [llvm] [FlowSensitive] [StatusOr] [1/N] Add mock headers (PR #163261)
Florian Mayer via cfe-commits
cfe-commits at lists.llvm.org
Wed Oct 15 12:22:23 PDT 2025
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 <fmayer at google.com>
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 <fmayer at google.com>
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 <fmayer at google.com>
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 <fmayer at google.com>
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 <fmayer at google.com>
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)
More information about the cfe-commits
mailing list