re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/base/nullability.h

@@ -16,21 +16,21 @@
 // File: nullability.h
 // -----------------------------------------------------------------------------
 //
-// This header file defines a set of "templated annotations" for designating the
-// expected nullability of pointers. These annotations allow you to designate
-// pointers in one of three classification states:
+// This header file defines a set of annotations for designating the expected
+// nullability of pointers. These annotations allow you to designate pointers in
+// one of three classification states:
 //
-//  * "Non-null" (for pointers annotated `Nonnull<T>`), indicating that it is
+//  * "Non-null" (for pointers annotated `absl_nonnull`), indicating that it is
 //    invalid for the given pointer to ever be null.
-//  * "Nullable" (for pointers annotated `Nullable<T>`), indicating that it is
+//  * "Nullable" (for pointers annotated `absl_nullable`), indicating that it is
 //    valid for the given pointer to be null.
-//  * "Unknown" (for pointers annotated `NullabilityUnknown<T>`), indicating
-//    that the given pointer has not been yet classified as either nullable or
+//  * "Unknown" (for pointers annotated `absl_nullability_unknown`), indicating
+//    that the given pointer has not yet been classified as either nullable or
 //    non-null. This is the default state of unannotated pointers.
 //
-// NOTE: unannotated pointers implicitly bear the annotation
-// `NullabilityUnknown<T>`; you should rarely, if ever, see this annotation used
-// in the codebase explicitly.
+// NOTE: Unannotated pointers implicitly bear the annotation
+// `absl_nullability_unknown`; you should rarely, if ever, see this annotation
+// used in the codebase explicitly.
 //
 // -----------------------------------------------------------------------------
 // Nullability and Contracts
@@ -64,16 +64,49 @@
 // formalize those contracts within the codebase.
 //
 // -----------------------------------------------------------------------------
+// Annotation Syntax
+// -----------------------------------------------------------------------------
+//
+// The annotations should be positioned as a qualifier for the pointer type. For
+// example, the position of `const` when declaring a const pointer (not a
+// pointer to a const type) is the position you should also use for these
+// annotations.
+//
+// Example:
+//
+// // A const non-null pointer to an `Employee`.
+// Employee* absl_nonnull const e;
+//
+// // A non-null pointer to a const `Employee`.
+// const Employee* absl_nonnull e;
+//
+// // A non-null pointer to a const nullable pointer to an `Employee`.
+// Employee* absl_nullable const* absl_nonnull e = nullptr;
+//
+// // A non-null function pointer.
+// void (*absl_nonnull func)(int, double);
+//
+// // A non-null array of `Employee`s as a parameter.
+// void func(Employee employees[absl_nonnull]);
+//
+// // A non-null std::unique_ptr to an `Employee`.
+// // As with `const`, it is possible to place the annotation on either side of
+// // a named type not ending in `*`, but placing it before the type it
+// // describes is preferred, unless inconsistent with surrounding code.
+// absl_nonnull std::unique_ptr<Employee> employee;
+//
+// // Invalid annotation usage – this attempts to declare a pointer to a
+// // nullable `Employee`, which is meaningless.
+// absl_nullable Employee* e;
+//
+// -----------------------------------------------------------------------------
 // Using Nullability Annotations
 // -----------------------------------------------------------------------------
 //
-// It is important to note that these annotations are not distinct strong
-// *types*. They are alias templates defined to be equal to the underlying
-// pointer type. A pointer annotated `Nonnull<T*>`, for example, is simply a
-// pointer of type `T*`. Each annotation acts as a form of documentation about
-// the contract for the given pointer. Each annotation requires providers or
-// consumers of these pointers across API boundaries to take appropriate steps
-// when setting or using these pointers:
+// Each annotation acts as a form of documentation about the contract for the
+// given pointer. Each annotation requires providers or consumers of these
+// pointers across API boundaries to take appropriate steps when setting or
+// using these pointers:
 //
 // * "Non-null" pointers should never be null. It is the responsibility of the
 //   provider of this pointer to ensure that the pointer may never be set to
@@ -91,20 +124,20 @@
 // Example:
 //
 // // PaySalary() requires the passed pointer to an `Employee` to be non-null.
-// void PaySalary(absl::Nonnull<Employee *> e) {
+// void PaySalary(Employee* absl_nonnull e) {
 //   pay(e->salary);  // OK to dereference
 // }
 //
 // // CompleteTransaction() guarantees the returned pointer to an `Account` to
 // // be non-null.
-// absl::Nonnull<Account *> balance CompleteTransaction(double fee) {
+// Account* absl_nonnull balance CompleteTransaction(double fee) {
 // ...
 // }
 //
 // // Note that specifying a nullability annotation does not prevent someone
 // // from violating the contract:
 //
-// Nullable<Employee *> find(Map& employees, std::string_view name);
+// Employee* absl_nullable find(Map& employees, std::string_view name);
 //
 // void g(Map& employees) {
 //   Employee *e = find(employees, "Pat");
@@ -144,14 +177,13 @@
 // These nullability annotations are primarily a human readable signal about the
 // intended contract of the pointer. They are not *types* and do not currently
 // provide any correctness guarantees. For example, a pointer annotated as
-// `Nonnull<T*>` is *not guaranteed* to be non-null, and the compiler won't
-// alert or prevent assignment of a `Nullable<T*>` to a `Nonnull<T*>`.
+// `absl_nonnull` is *not guaranteed* to be non-null, and the compiler won't
+// alert or prevent assignment of a `T* absl_nullable` to a `T* absl_nonnull`.
 // ===========================================================================
 #ifndef ABSL_BASE_NULLABILITY_H_
 #define ABSL_BASE_NULLABILITY_H_
 
 #include "absl/base/config.h"
-#include "absl/base/internal/nullability_impl.h"
 
 // ABSL_POINTERS_DEFAULT_NONNULL
 //
@@ -168,14 +200,14 @@
 //     ABSL_POINTERS_DEFAULT_NONNULL
 //
 //     void FillMessage(Message *m);                  // implicitly non-null
-//     absl::Nullable<T*> GetNullablePtr();           // explicitly nullable
-//     absl::NullabilityUnknown<T*> GetUnknownPtr();  // explicitly unknown
+//     T* absl_nullable GetNullablePtr();           // explicitly nullable
+//     T* absl_nullability_unknown GetUnknownPtr();  // explicitly unknown
 //
-// The macro can be safely used in header files -- it will not affect any files
+// The macro can be safely used in header files – it will not affect any files
 // that include it.
 //
-// In files with the macro, plain `T*` syntax means `absl::Nonnull<T*>`, and the
-// exceptions (`Nullable` and `NullabilityUnknown`) must be marked
+// In files with the macro, plain `T*` syntax means `T* absl_nonnull`, and the
+// exceptions (`absl_nullable` and `absl_nullability_unknown`) must be marked
 // explicitly. The same holds, correspondingly, for smart pointer types.
 //
 // For comparison, without the macro, all unannotated pointers would default to
@@ -183,17 +215,16 @@
 //
 //     #include "absl/base/nullability.h"
 //
-//     void FillMessage(absl::Nonnull<Message*> m);  // explicitly non-null
-//     absl::Nullable<T*> GetNullablePtr();          // explicitly nullable
+//     void FillMessage(Message* absl_nonnull m);  // explicitly non-null
+//     T* absl_nullable GetNullablePtr();          // explicitly nullable
 //     T* GetUnknownPtr();                           // implicitly unknown
 //
 // No-op except for being a human readable signal.
 #define ABSL_POINTERS_DEFAULT_NONNULL
 
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::Nonnull (default with `ABSL_POINTERS_DEFAULT_NONNULL`)
+#if defined(__clang__) && !defined(__OBJC__) && \
+    ABSL_HAVE_FEATURE(nullability_on_classes)
+// absl_nonnull (default with `ABSL_POINTERS_DEFAULT_NONNULL`)
 //
 // The indicated pointer is never null. It is the responsibility of the provider
 // of this pointer across an API boundary to ensure that the pointer is never
@@ -203,13 +234,12 @@ ABSL_NAMESPACE_BEGIN
 // Example:
 //
 // // `employee` is designated as not null.
-// void PaySalary(absl::Nonnull<Employee *> employee) {
+// void PaySalary(Employee* absl_nonnull employee) {
 //   pay(*employee);  // OK to dereference
 // }
-template <typename T>
-using Nonnull = nullability_internal::NonnullImpl<T>;
+#define absl_nonnull _Nonnull
 
-// absl::Nullable
+// absl_nullable
 //
 // The indicated pointer may, by design, be either null or non-null. Consumers
 // of this pointer across an API boundary should perform a `nullptr` check
@@ -218,15 +248,14 @@ using Nonnull = nullability_internal::NonnullImpl<T>;
 // Example:
 //
 // // `employee` may  be null.
-// void PaySalary(absl::Nullable<Employee *> employee) {
+// void PaySalary(Employee* absl_nullable employee) {
 //   if (employee != nullptr) {
 //     Pay(*employee);  // OK to dereference
 //   }
 // }
-template <typename T>
-using Nullable = nullability_internal::NullableImpl<T>;
+#define absl_nullable _Nullable
 
-// absl::NullabilityUnknown (default without `ABSL_POINTERS_DEFAULT_NONNULL`)
+// absl_nullability_unknown  (default without `ABSL_POINTERS_DEFAULT_NONNULL`)
 //
 // The indicated pointer has not yet been determined to be definitively
 // "non-null" or "nullable." Providers of such pointers across API boundaries
@@ -234,8 +263,8 @@ using Nullable = nullability_internal::NullableImpl<T>;
 // Consumers of these pointers across an API boundary should treat such pointers
 // with the same caution they treat currently unannotated pointers. Most
 // existing code will have "unknown"  pointers, which should eventually be
-// migrated into one of the above two nullability states: `Nonnull<T>` or
-//  `Nullable<T>`.
+// migrated into one of the above two nullability states: `absl_nonnull` or
+//  `absl_nullable`.
 //
 // NOTE: For files that do not specify `ABSL_POINTERS_DEFAULT_NONNULL`,
 // because this annotation is the global default state, unannotated pointers are
@@ -245,7 +274,7 @@ using Nullable = nullability_internal::NullableImpl<T>;
 // Example:
 //
 // // `employee`s nullability state is unknown.
-// void PaySalary(absl::NullabilityUnknown<Employee *> employee) {
+// void PaySalary(Employee* absl_nullability_unknown employee) {
 //   Pay(*employee); // Potentially dangerous. API provider should investigate.
 // }
 //
@@ -256,11 +285,15 @@ using Nullable = nullability_internal::NullableImpl<T>;
 // void PaySalary(Employee* employee) {
 //   Pay(*employee); // Potentially dangerous. API provider should investigate.
 // }
-template <typename T>
-using NullabilityUnknown = nullability_internal::NullabilityUnknownImpl<T>;
-
-ABSL_NAMESPACE_END
-}  // namespace absl
+#define absl_nullability_unknown _Null_unspecified
+#else
+// No-op for non-Clang compilers or Objective-C.
+#define absl_nonnull
+// No-op for non-Clang compilers or Objective-C.
+#define absl_nullable
+// No-op for non-Clang compilers or Objective-C.
+#define absl_nullability_unknown
+#endif
 
 // ABSL_NULLABILITY_COMPATIBLE
 //
@@ -281,26 +314,4 @@ ABSL_NAMESPACE_END
 #define ABSL_NULLABILITY_COMPATIBLE
 #endif
 
-// ABSL_NONNULL
-// ABSL_NULLABLE
-// ABSL_NULLABILITY_UNKNOWN
-//
-// These macros are analogues of the alias template nullability annotations
-// above.
-//
-// Example:
-// int* ABSL_NULLABLE foo;
-// Is equivalent to:
-// absl::Nullable<int*> foo;
-#if defined(__clang__) && !defined(__OBJC__) && \
-    ABSL_HAVE_FEATURE(nullability_on_classes)
-#define ABSL_NONNULL _Nonnull
-#define ABSL_NULLABLE _Nullable
-#define ABSL_NULLABILITY_UNKNOWN _Null_unspecified
-#else
-#define ABSL_NONNULL
-#define ABSL_NULLABLE
-#define ABSL_NULLABILITY_UNKNOWN
-#endif
-
 #endif  // ABSL_BASE_NULLABILITY_H_

package/vendor/abseil-cpp/absl/base/nullability_test.cc

@@ -14,21 +14,16 @@
 
 #include "absl/base/nullability.h"
 
-#include <cassert>
 #include <memory>
+#include <type_traits>
 #include <utility>
 
 #include "gtest/gtest.h"
-#include "absl/base/attributes.h"
 
 namespace {
-using ::absl::Nonnull;
-using ::absl::NullabilityUnknown;
-using ::absl::Nullable;
-
-void funcWithNonnullArg(Nonnull<int*> /*arg*/) {}
+void funcWithNonnullArg(int* absl_nonnull /*arg*/) {}
 template <typename T>
-void funcWithDeducedNonnullArg(Nonnull<T*> /*arg*/) {}
+void funcWithDeducedNonnullArg(T* absl_nonnull /*arg*/) {}
 
 TEST(NonnullTest, NonnullArgument) {
   int var = 0;
@@ -36,7 +31,7 @@ TEST(NonnullTest, NonnullArgument) {
   funcWithDeducedNonnullArg(&var);
 }
 
-Nonnull<int*> funcWithNonnullReturn() {
+int* absl_nonnull funcWithNonnullReturn() {
   static int var = 0;
   return &var;
 }
@@ -47,83 +42,49 @@ TEST(NonnullTest, NonnullReturn) {
 }
 
 TEST(PassThroughTest, PassesThroughRawPointerToInt) {
-  EXPECT_TRUE((std::is_same<Nonnull<int*>, int*>::value));
-  EXPECT_TRUE((std::is_same<Nullable<int*>, int*>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<int*>, int*>::value));
+  EXPECT_TRUE((std::is_same<int* absl_nonnull, int*>::value));
+  EXPECT_TRUE((std::is_same<int* absl_nullable, int*>::value));
+  EXPECT_TRUE((std::is_same<int* absl_nullability_unknown, int*>::value));
 }
 
 TEST(PassThroughTest, PassesThroughRawPointerToVoid) {
-  EXPECT_TRUE((std::is_same<Nonnull<void*>, void*>::value));
-  EXPECT_TRUE((std::is_same<Nullable<void*>, void*>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<void*>, void*>::value));
+  EXPECT_TRUE((std::is_same<void* absl_nonnull, void*>::value));
+  EXPECT_TRUE((std::is_same<void* absl_nullable, void*>::value));
+  EXPECT_TRUE((std::is_same<void* absl_nullability_unknown, void*>::value));
 }
 
 TEST(PassThroughTest, PassesThroughUniquePointerToInt) {
   using T = std::unique_ptr<int>;
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nonnull T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullable T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullability_unknown T, T>::value));
 }
 
 TEST(PassThroughTest, PassesThroughSharedPointerToInt) {
   using T = std::shared_ptr<int>;
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nonnull T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullable T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullability_unknown T, T>::value));
 }
 
 TEST(PassThroughTest, PassesThroughSharedPointerToVoid) {
   using T = std::shared_ptr<void>;
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nonnull T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullable T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullability_unknown T, T>::value));
 }
 
 TEST(PassThroughTest, PassesThroughPointerToMemberObject) {
   using T = decltype(&std::pair<int, int>::first);
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nonnull T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullable T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullability_unknown T, T>::value));
 }
 
 TEST(PassThroughTest, PassesThroughPointerToMemberFunction) {
   using T = decltype(&std::unique_ptr<int>::reset);
-  EXPECT_TRUE((std::is_same<Nonnull<T>, T>::value));
-  EXPECT_TRUE((std::is_same<Nullable<T>, T>::value));
-  EXPECT_TRUE((std::is_same<NullabilityUnknown<T>, T>::value));
-}
-
-}  // namespace
-
-// Nullable ADL lookup test
-namespace util {
-// Helper for NullableAdlTest.  Returns true, denoting that argument-dependent
-// lookup found this implementation of DidAdlWin.  Must be in namespace
-// util itself, not a nested anonymous namespace.
-template <typename T>
-bool DidAdlWin(T*) {
-  return true;
-}
-
-// Because this type is defined in namespace util, an unqualified call to
-// DidAdlWin with a pointer to MakeAdlWin will find the above implementation.
-struct MakeAdlWin {};
-}  // namespace util
-
-namespace {
-// Returns false, denoting that ADL did not inspect namespace util.  If it
-// had, the better match (T*) above would have won out over the (...) here.
-bool DidAdlWin(...) { return false; }
-
-TEST(NullableAdlTest, NullableAddsNothingToArgumentDependentLookup) {
-  // Treatment: util::Nullable<int*> contributes nothing to ADL because
-  // int* itself doesn't.
-  EXPECT_FALSE(DidAdlWin((int*)nullptr));
-  EXPECT_FALSE(DidAdlWin((Nullable<int*>)nullptr));
-
-  // Control: Argument-dependent lookup does find the implementation in
-  // namespace util when the underlying pointee type resides there.
-  EXPECT_TRUE(DidAdlWin((util::MakeAdlWin*)nullptr));
-  EXPECT_TRUE(DidAdlWin((Nullable<util::MakeAdlWin*>)nullptr));
+  EXPECT_TRUE((std::is_same<absl_nonnull T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullable T, T>::value));
+  EXPECT_TRUE((std::is_same<absl_nullability_unknown T, T>::value));
 }
 }  // namespace

package/vendor/abseil-cpp/absl/base/options.h

@@ -64,65 +64,14 @@
 // proper Abseil implementation at compile-time, which will not be sufficient
 // to guarantee ABI stability to package managers.
 
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
+
 #ifndef ABSL_BASE_OPTIONS_H_
 #define ABSL_BASE_OPTIONS_H_
 
 // -----------------------------------------------------------------------------
 // Type Compatibility Options
 // -----------------------------------------------------------------------------
-//
-// ABSL_OPTION_USE_STD_ANY
-//
-// This option controls whether absl::any is implemented as an alias to
-// std::any, or as an independent implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use an alias to std::any.  This requires that all code
-// using Abseil is built in C++17 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::any is available.  This option is
-// useful when you are building your entire program, including all of its
-// dependencies, from source.  It should not be used otherwise -- for example,
-// if you are distributing Abseil in a binary package manager -- since in
-// mode 2, absl::any will name a different type, with a different mangled name
-// and binary layout, depending on the compiler flags passed by the end user.
-// For more info, see https://abseil.io/about/design/dropin-types.
-//
-// User code should not inspect this macro.  To check in the preprocessor if
-// absl::any is a typedef of std::any, use the feature macro ABSL_USES_STD_ANY.
-
-#define ABSL_OPTION_USE_STD_ANY 2
-
-
-// ABSL_OPTION_USE_STD_OPTIONAL
-//
-// This option controls whether absl::optional is implemented as an alias to
-// std::optional, or as an independent implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use an alias to std::optional.  This requires that all
-// code using Abseil is built in C++17 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::optional is available.  This option
-// is useful when you are building your program from source.  It should not be
-// used otherwise -- for example, if you are distributing Abseil in a binary
-// package manager -- since in mode 2, absl::optional will name a different
-// type, with a different mangled name and binary layout, depending on the
-// compiler flags passed by the end user.  For more info, see
-// https://abseil.io/about/design/dropin-types.
-
-// User code should not inspect this macro.  To check in the preprocessor if
-// absl::optional is a typedef of std::optional, use the feature macro
-// ABSL_USES_STD_OPTIONAL.
-
-#define ABSL_OPTION_USE_STD_OPTIONAL 2
-
 
 // ABSL_OPTION_USE_STD_STRING_VIEW
 //
@@ -150,32 +99,6 @@
 
 #define ABSL_OPTION_USE_STD_STRING_VIEW 2
 
-// ABSL_OPTION_USE_STD_VARIANT
-//
-// This option controls whether absl::variant is implemented as an alias to
-// std::variant, or as an independent implementation.
-//
-// A value of 0 means to use Abseil's implementation.  This requires only C++11
-// support, and is expected to work on every toolchain we support.
-//
-// A value of 1 means to use an alias to std::variant.  This requires that all
-// code using Abseil is built in C++17 mode or later.
-//
-// A value of 2 means to detect the C++ version being used to compile Abseil,
-// and use an alias only if a working std::variant is available.  This option
-// is useful when you are building your program from source.  It should not be
-// used otherwise -- for example, if you are distributing Abseil in a binary
-// package manager -- since in mode 2, absl::variant will name a different
-// type, with a different mangled name and binary layout, depending on the
-// compiler flags passed by the end user.  For more info, see
-// https://abseil.io/about/design/dropin-types.
-//
-// User code should not inspect this macro.  To check in the preprocessor if
-// absl::variant is a typedef of std::variant, use the feature macro
-// ABSL_USES_STD_VARIANT.
-
-#define ABSL_OPTION_USE_STD_VARIANT 2
-
 // ABSL_OPTION_USE_STD_ORDERING
 //
 // This option controls whether absl::{partial,weak,strong}_ordering are
@@ -226,7 +149,7 @@
 // allowed.
 
 #define ABSL_OPTION_USE_INLINE_NAMESPACE 1
-#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20250127
+#define ABSL_OPTION_INLINE_NAMESPACE_NAME lts_20250814
 
 // ABSL_OPTION_HARDENED
 //

package/vendor/abseil-cpp/absl/base/policy_checks.h

@@ -71,15 +71,15 @@
 // C++ Version Check
 // -----------------------------------------------------------------------------
 
-// Enforce C++14 as the minimum.
+// Enforce C++17 as the minimum.
 #if defined(_MSVC_LANG)
-#if _MSVC_LANG < 201402L
-#error "C++ versions less than C++14 are not supported."
-#endif  // _MSVC_LANG < 201402L
+#if _MSVC_LANG < 201703L
+#error "C++ versions less than C++17 are not supported."
+#endif  // _MSVC_LANG < 201703L
 #elif defined(__cplusplus)
-#if __cplusplus < 201402L
-#error "C++ versions less than C++14 are not supported."
-#endif  // __cplusplus < 201402L
+#if __cplusplus < 201703L
+#error "C++ versions less than C++17 are not supported."
+#endif  // __cplusplus < 201703L
 #endif
 
 // -----------------------------------------------------------------------------

package/vendor/abseil-cpp/absl/base/raw_logging_test.cc

@@ -43,12 +43,27 @@ TEST(RawLoggingCompilationTest, PassingCheck) {
   ABSL_RAW_CHECK(true, "RAW CHECK");
 }
 
+TEST(RawLoggingCompilationTest, DebugLog) {
+  ABSL_RAW_DLOG(INFO, "RAW DLOG: %d", 1);
+}
+
+TEST(RawLoggingCompilationTest, PassingDebugCheck) {
+  ABSL_RAW_DCHECK(true, "failure message");
+}
+
 // Not all platforms support output from raw log, so we don't verify any
 // particular output for RAW check failures (expecting the empty string
 // accomplishes this).  This test is primarily a compilation test, but we
 // are verifying process death when EXPECT_DEATH works for a platform.
 const char kExpectedDeathOutput[] = "";
 
+#if !defined(NDEBUG)  // if debug build
+TEST(RawLoggingDeathTest, FailingDebugCheck) {
+  EXPECT_DEATH_IF_SUPPORTED(ABSL_RAW_DCHECK(1 == 0, "explanation"),
+                            kExpectedDeathOutput);
+}
+#endif  // if debug build
+
 TEST(RawLoggingDeathTest, FailingCheck) {
   EXPECT_DEATH_IF_SUPPORTED(ABSL_RAW_CHECK(1 == 0, "explanation"),
                             kExpectedDeathOutput);