re2 1.23.0 → 1.23.2

package/vendor/abseil-cpp/absl/log/check_test_impl.inc

@@ -255,6 +255,60 @@ TEST(CHECKTest, TestBinaryChecksWithStringComparison) {
   ABSL_TEST_CHECK_LT(a, "b");
 }
 
+TEST(CHECKDeathTest, CheckWithCharStarAndStringPrintsTheCharStar) {
+  std::string str = "B";
+
+  // When the comparison happens as strings, then we print the CharT* as a
+  // string.
+  EXPECT_DEATH(ABSL_TEST_CHECK_EQ("A", str),
+               R"re(Check failed: \"A\" == str \(A vs. B\))re");
+}
+
+#if defined(GTEST_USES_SIMPLE_RE) && GTEST_USES_SIMPLE_RE
+#define POINTER_VALUE_RE R"re(\w*)re"
+#else
+#define POINTER_VALUE_RE R"re((0x)*[0-9a-fA-F]*)re"
+#endif
+
+#define POINTER_VS_POINTER_RE(lhs, rhs) "\\(" lhs " vs. " rhs "\\)"
+
+template <typename CharT>
+void TestCharStarComparison() {
+  // When the comparison happens as pointers, we only print the pointer and not
+  // interpret it as a C-String because it might not be.
+  // Leave the CharTs uninitialized to trigger ASan/MSan failures if we actually
+  // read the pointers.
+  CharT* p1 = new CharT;
+  CharT* p2 = new CharT;
+  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(p1, p2),
+               R"re(Check failed: p1 == p2 )re" POINTER_VS_POINTER_RE(
+                   POINTER_VALUE_RE, POINTER_VALUE_RE));
+  CharT as_array[10];
+  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(p1, as_array),
+               R"re(Check failed: p1 == as_array )re" POINTER_VS_POINTER_RE(
+                   POINTER_VALUE_RE, POINTER_VALUE_RE));
+
+  const void* as_void = as_array;
+  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(as_void, p2),
+               R"re(Check failed: as_void == p2 )re" POINTER_VS_POINTER_RE(
+                   POINTER_VALUE_RE, POINTER_VALUE_RE));
+
+  delete p1;
+  delete p2;
+}
+
+TEST(CHECKDeathTest, CheckWithCharStarStringification) {
+  TestCharStarComparison<char>();
+  TestCharStarComparison<signed char>();
+  TestCharStarComparison<unsigned char>();
+  TestCharStarComparison<wchar_t>();
+#if defined(__cpp_char8_t)
+  TestCharStarComparison<char8_t>();
+#endif
+  TestCharStarComparison<char16_t>();
+  TestCharStarComparison<char32_t>();
+}
+
 // For testing using CHECK*() on anonymous enums.
 enum { CASE_A, CASE_B };
 
@@ -292,8 +346,7 @@ TEST(CHECKDeathTest, TestBinaryChecksWithUnprintable) {
   ExampleTypeThatHasNoStreamOperator a{true};
   ExampleTypeThatHasNoStreamOperator b{false};
   ABSL_TEST_CHECK_EQ(a, a);
-  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-               "Check failed: a == b \\(UNPRINTABLE vs. UNPRINTABLE\\)");
+  EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b), "Check failed: a == b");
   ABSL_TEST_CHECK_EQ(a, true);
   EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, false),
                "Check failed: a == false \\(UNPRINTABLE vs. 0\\)");
@@ -340,9 +393,11 @@ TEST(CHECKDeathTest, TestNullValuesAreReportedCleanly) {
 
   a = "xx";
   EXPECT_DEATH(ABSL_TEST_CHECK_EQ(a, b),
-               "Check failed: a == b \\(xx vs. \\(null\\)\\)");
+               R"re(Check failed: a == b )re" POINTER_VS_POINTER_RE(
+                   POINTER_VALUE_RE, "\\(null\\)"));
   EXPECT_DEATH(ABSL_TEST_CHECK_EQ(b, a),
-               "Check failed: b == a \\(\\(null\\) vs. xx\\)");
+               R"re(Check failed: b == a )re" POINTER_VS_POINTER_RE(
+                   "\\(null\\)", POINTER_VALUE_RE));
 
   std::nullptr_t n{};
   EXPECT_DEATH(ABSL_TEST_CHECK_NE(n, nullptr),

package/vendor/abseil-cpp/absl/log/die_if_null.cc

@@ -15,6 +15,7 @@
 #include "absl/log/die_if_null.h"
 
 #include "absl/base/config.h"
+#include "absl/base/nullability.h"
 #include "absl/log/log.h"
 #include "absl/strings/str_cat.h"
 
@@ -22,7 +23,8 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace log_internal {
 
-void DieBecauseNull(const char* file, int line, const char* exprtext) {
+void DieBecauseNull(const char* absl_nonnull file, int line,
+                    const char* absl_nonnull exprtext) {
   LOG(FATAL).AtLocation(file, line)
       << absl::StrCat("Check failed: '", exprtext, "' Must be non-null");
 }

package/vendor/abseil-cpp/absl/log/die_if_null.h

@@ -23,10 +23,13 @@
 
 #include <stdint.h>
 
+#include <type_traits>
 #include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/internal/nullability_traits.h"
+#include "absl/base/nullability.h"
 #include "absl/base/optimization.h"
 
 // ABSL_DIE_IF_NULL()
@@ -56,12 +59,30 @@ namespace log_internal {
 // generates less code than its implementation would if inlined, for a slight
 // code size reduction each time `ABSL_DIE_IF_NULL` is called.
 [[noreturn]] ABSL_ATTRIBUTE_NOINLINE void DieBecauseNull(
-    const char* file, int line, const char* exprtext);
+    const char* absl_nonnull file, int line, const char* absl_nonnull exprtext);
 
 // Helper for `ABSL_DIE_IF_NULL`.
+
+// Since we use `remove_reference_t` before `AddNonnullIfCompatible`, we need
+// to explicitly have overloads for both lvalue reference and rvalue reference
+// arguments and returns.
+template <typename T>
+[[nodiscard]] typename absl::base_internal::AddNonnullIfCompatible<
+    std::remove_reference_t<T>>::type&
+DieIfNull(const char* absl_nonnull file, int line,
+          const char* absl_nonnull exprtext, T& t) {
+  if (ABSL_PREDICT_FALSE(t == nullptr)) {
+    // Call a non-inline helper function for a small code size improvement.
+    DieBecauseNull(file, line, exprtext);
+  }
+  return t;
+}
+
 template <typename T>
-[[nodiscard]] T DieIfNull(const char* file, int line, const char* exprtext,
-                          T&& t) {
+[[nodiscard]] typename absl::base_internal::AddNonnullIfCompatible<
+    std::remove_reference_t<T>>::type&&
+DieIfNull(const char* absl_nonnull file, int line,
+          const char* absl_nonnull exprtext, T&& t) {
   if (ABSL_PREDICT_FALSE(t == nullptr)) {
     // Call a non-inline helper function for a small code size improvement.
     DieBecauseNull(file, line, exprtext);

package/vendor/abseil-cpp/absl/log/internal/BUILD.bazel

@@ -59,7 +59,6 @@ cc_library(
     deps = [
         ":check_op",
         ":conditions",
-        ":log_message",
         ":strip",
         "//absl/base:core_headers",
     ],
@@ -549,3 +548,34 @@ cc_test(
         "@google_benchmark//:benchmark_main",
     ],
 )
+
+cc_library(
+    name = "container",
+    hdrs = ["container.h"],
+    copts = ABSL_DEFAULT_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    visibility = [
+        "//absl:__subpackages__",
+    ],
+    deps = [
+        "//absl/base:config",
+        "//absl/meta:requires",
+        "//absl/strings",
+    ],
+)
+
+cc_test(
+    name = "container_test",
+    srcs = ["container_test.cc"],
+    copts = ABSL_TEST_COPTS,
+    linkopts = ABSL_DEFAULT_LINKOPTS,
+    deps = [
+        ":container",
+        "//absl/base:config",
+        "//absl/strings",
+        "//absl/strings:str_format",
+        "//absl/types:span",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
+)

package/vendor/abseil-cpp/absl/log/internal/check_impl.h

@@ -12,13 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
+
 #ifndef ABSL_LOG_INTERNAL_CHECK_IMPL_H_
 #define ABSL_LOG_INTERNAL_CHECK_IMPL_H_
 
 #include "absl/base/optimization.h"
 #include "absl/log/internal/check_op.h"
 #include "absl/log/internal/conditions.h"
-#include "absl/log/internal/log_message.h"
 #include "absl/log/internal/strip.h"
 
 // CHECK

package/vendor/abseil-cpp/absl/log/internal/check_op.cc

@@ -101,7 +101,9 @@ void MakeCheckOpValueString(std::ostream& os, const void* p) {
   }
 }
 
-void MakeCheckOpUnprintableString(std::ostream& os) { os << "UNPRINTABLE"; }
+std::ostream& operator<<(std::ostream& os, UnprintableWrapper) {
+  return os << "UNPRINTABLE";
+}
 
 // Helper functions for string comparisons.
 #define DEFINE_CHECK_STROP_IMPL(name, func, expected)                          \

package/vendor/abseil-cpp/absl/log/internal/check_op.h

@@ -46,10 +46,10 @@
 // `ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL` wraps string literals that
 // should be stripped when `ABSL_MIN_LOG_LEVEL` exceeds `kFatal`.
 #ifdef ABSL_MIN_LOG_LEVEL
-#define ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(literal)         \
-  (::absl::LogSeverity::kFatal >=                               \
-           static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) \
-       ? (literal)                                              \
+#define ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(literal)                \
+  (::absl::LogSeverity::kFatal >=                                      \
+           static_cast<::absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL) \
+       ? (literal)                                                     \
        : "")
 #else
 #define ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(literal) (literal)
@@ -225,17 +225,12 @@ void MakeCheckOpValueString(std::ostream& os, signed char v);
 void MakeCheckOpValueString(std::ostream& os, unsigned char v);
 void MakeCheckOpValueString(std::ostream& os, const void* absl_nullable p);
 
-void MakeCheckOpUnprintableString(std::ostream& os);
-
 // A wrapper for types that have no operator<<.
 struct UnprintableWrapper {
   template <typename T>
   explicit UnprintableWrapper(const T&) {}
 
-  friend std::ostream& operator<<(std::ostream& os, const UnprintableWrapper&) {
-    MakeCheckOpUnprintableString(os);
-    return os;
-  }
+  friend std::ostream& operator<<(std::ostream& os, UnprintableWrapper);
 };
 
 namespace detect_specialization {
@@ -398,10 +393,35 @@ std::enable_if_t<
                        std::conditional_t<std::is_signed_v<UnderlyingTypeT<T>>,
                                           int64_t, uint64_t>>>
 Detect(...);
+
+template <typename T>
+using Detected = decltype(Detect<T>(0));
 }  // namespace detect_specialization
 
+// If the comparison will happen as pointers, decay `char*` arguments to `void*`
+// when printing them. There is no evidence that they are a NULL terminated
+// C-String so printing them as such could lead to UB, and more importantly we
+// compared pointers so showing the pointers is a better result.
 template <typename T>
-using CheckOpStreamType = decltype(detect_specialization::Detect<T>(0));
+constexpr bool IsCharStarOrVoidStar() {
+  if constexpr (std::is_reference_v<T>) {
+    return IsCharStarOrVoidStar<std::remove_reference_t<T>>();
+  } else if constexpr (std::is_array_v<T>) {
+    return IsCharStarOrVoidStar<std::decay_t<T>>();
+  } else {
+    using U = std::remove_const_t<std::remove_pointer_t<T>>;
+    return std::is_pointer_v<T> &&
+        (std::is_same_v<char, U> || std::is_same_v<unsigned char, U> ||
+         std::is_same_v<signed char, U> || std::is_void_v<U>);
+  }
+}
+
+template <typename T1, typename T2,
+          typename U1 = detect_specialization::Detected<T1>,
+          typename U2 = detect_specialization::Detected<T2>>
+using CheckOpStreamType =
+    std::conditional_t<IsCharStarOrVoidStar<U1>() && IsCharStarOrVoidStar<U2>(),
+                       const void*, U1>;
 
 // Build the error message string.  Specify no inlining for code size.
 template <typename T1, typename T2>
@@ -411,10 +431,16 @@ ABSL_ATTRIBUTE_RETURNS_NONNULL const char* absl_nonnull MakeCheckOpString(
 template <typename T1, typename T2>
 const char* absl_nonnull MakeCheckOpString(T1 v1, T2 v2,
                                            const char* absl_nonnull exprtext) {
-  CheckOpMessageBuilder comb(exprtext);
-  MakeCheckOpValueString(comb.ForVar1(), v1);
-  MakeCheckOpValueString(comb.ForVar2(), v2);
-  return comb.NewString();
+  if constexpr (std::is_same_v<CheckOpStreamType<T1, T2>, UnprintableWrapper> &&
+                std::is_same_v<CheckOpStreamType<T2, T1>, UnprintableWrapper>) {
+    // No sense printing " (UNPRINTABLE vs. UNPRINTABLE)"
+    return exprtext;
+  } else {
+    CheckOpMessageBuilder comb(exprtext);
+    MakeCheckOpValueString(comb.ForVar1(), v1);
+    MakeCheckOpValueString(comb.ForVar2(), v2);
+    return comb.NewString();
+  }
 }
 
 // Add a few commonly used instantiations as extern to reduce size of objects
@@ -445,7 +471,7 @@ ABSL_LOG_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING_EXTERN(const void* absl_nonnull);
 #ifdef ABSL_MIN_LOG_LEVEL
 #define ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, v1, v2, exprtext) \
   ((::absl::LogSeverity::kFatal >=                                       \
-    static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL))                \
+    static_cast<::absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL))         \
        ? MakeCheckOpString<U1, U2>(v1, v2, exprtext)                     \
        : "")
 #else
@@ -461,8 +487,8 @@ ABSL_LOG_INTERNAL_DEFINE_MAKE_CHECK_OP_STRING_EXTERN(const void* absl_nonnull);
   template <typename T1, typename T2>                                      \
   inline constexpr const char* absl_nullable name##Impl(                   \
       const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
-    using U1 = CheckOpStreamType<T1>;                                      \
-    using U2 = CheckOpStreamType<T2>;                                      \
+    using U1 = CheckOpStreamType<T1, T2>;                                  \
+    using U2 = CheckOpStreamType<T2, T1>;                                  \
     return ABSL_PREDICT_TRUE(v1 op v2)                                     \
                ? nullptr                                                   \
                : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \

package/vendor/abseil-cpp/absl/log/internal/conditions.h

@@ -108,46 +108,49 @@
 #ifdef ABSL_MIN_LOG_LEVEL
 #define ABSL_LOG_INTERNAL_CONDITION_INFO(type, condition) \
   ABSL_LOG_INTERNAL_##type##_CONDITION(                   \
-      (condition) && ::absl::LogSeverity::kInfo >=        \
-                         static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL))
+      (condition) &&                                      \
+      ::absl::LogSeverity::kInfo >=                       \
+          static_cast<::absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL))
 #define ABSL_LOG_INTERNAL_CONDITION_WARNING(type, condition) \
   ABSL_LOG_INTERNAL_##type##_CONDITION(                      \
-      (condition) && ::absl::LogSeverity::kWarning >=        \
-                         static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL))
+      (condition) &&                                         \
+      ::absl::LogSeverity::kWarning >=                       \
+          static_cast<::absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL))
 #define ABSL_LOG_INTERNAL_CONDITION_ERROR(type, condition) \
   ABSL_LOG_INTERNAL_##type##_CONDITION(                    \
-      (condition) && ::absl::LogSeverity::kError >=        \
-                         static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL))
+      (condition) &&                                       \
+      ::absl::LogSeverity::kError >=                       \
+          static_cast<::absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL))
 #define ABSL_LOG_INTERNAL_CONDITION_DO_NOT_SUBMIT(type, condition) \
   ABSL_LOG_INTERNAL_CONDITION_ERROR(type, condition)
 // NOTE: Use ternary operators instead of short-circuiting to mitigate
 // https://bugs.llvm.org/show_bug.cgi?id=51928.
 #define ABSL_LOG_INTERNAL_CONDITION_FATAL(type, condition)                 \
   ABSL_LOG_INTERNAL_##type##_CONDITION(                                    \
-      ((condition)                                                         \
-           ? (::absl::LogSeverity::kFatal >=                               \
-                      static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) \
-                  ? true                                                   \
-                  : (::absl::log_internal::AbortQuietly(), false))         \
-           : false))
+      ((condition) ? (::absl::LogSeverity::kFatal >=                       \
+                              static_cast<::absl::LogSeverityAtLeast>(     \
+                                  ABSL_MIN_LOG_LEVEL)                      \
+                          ? true                                           \
+                          : (::absl::log_internal::AbortQuietly(), false)) \
+                   : false))
 // NOTE: Use ternary operators instead of short-circuiting to mitigate
 // https://bugs.llvm.org/show_bug.cgi?id=51928.
-#define ABSL_LOG_INTERNAL_CONDITION_QFATAL(type, condition)                \
-  ABSL_LOG_INTERNAL_##type##_CONDITION(                                    \
-      ((condition)                                                         \
-           ? (::absl::LogSeverity::kFatal >=                               \
-                      static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) \
-                  ? true                                                   \
-                  : (::absl::log_internal::ExitQuietly(), false))          \
-           : false))
-#define ABSL_LOG_INTERNAL_CONDITION_DFATAL(type, condition)             \
-  ABSL_LOG_INTERNAL_##type##_CONDITION(                                 \
-      (ABSL_ASSUME(absl::kLogDebugFatal == absl::LogSeverity::kError || \
-                   absl::kLogDebugFatal == absl::LogSeverity::kFatal),  \
-       (condition) &&                                                   \
-           (::absl::kLogDebugFatal >=                                   \
-                static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) || \
-            (::absl::kLogDebugFatal == ::absl::LogSeverity::kFatal &&   \
+#define ABSL_LOG_INTERNAL_CONDITION_QFATAL(type, condition)               \
+  ABSL_LOG_INTERNAL_##type##_CONDITION(                                   \
+      ((condition) ? (::absl::LogSeverity::kFatal >=                      \
+                              static_cast<::absl::LogSeverityAtLeast>(    \
+                                  ABSL_MIN_LOG_LEVEL)                     \
+                          ? true                                          \
+                          : (::absl::log_internal::ExitQuietly(), false)) \
+                   : false))
+#define ABSL_LOG_INTERNAL_CONDITION_DFATAL(type, condition)                    \
+  ABSL_LOG_INTERNAL_##type##_CONDITION(                                        \
+      (ABSL_ASSUME(absl::kLogDebugFatal == absl::LogSeverity::kError ||        \
+                   absl::kLogDebugFatal == absl::LogSeverity::kFatal),         \
+       (condition) &&                                                          \
+           (::absl::kLogDebugFatal >=                                          \
+                static_cast<::absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL) || \
+            (::absl::kLogDebugFatal == ::absl::LogSeverity::kFatal &&          \
              (::absl::log_internal::AbortQuietly(), false)))))
 
 #define ABSL_LOG_INTERNAL_CONDITION_LEVEL(severity)                            \
@@ -157,13 +160,13 @@
              ::absl::NormalizeLogSeverity(severity);                           \
          absl_log_internal_severity_loop; absl_log_internal_severity_loop = 0) \
   ABSL_LOG_INTERNAL_CONDITION_LEVEL_IMPL
-#define ABSL_LOG_INTERNAL_CONDITION_LEVEL_IMPL(type, condition)          \
-  ABSL_LOG_INTERNAL_##type##_CONDITION((                                  \
-      (condition) &&                                                     \
-          (absl_log_internal_severity >=                                 \
-               static_cast<::absl::LogSeverity>(ABSL_MIN_LOG_LEVEL) ||   \
-           (absl_log_internal_severity == ::absl::LogSeverity::kFatal && \
-            (::absl::log_internal::AbortQuietly(), false)))))
+#define ABSL_LOG_INTERNAL_CONDITION_LEVEL_IMPL(type, condition)            \
+  ABSL_LOG_INTERNAL_##type##_CONDITION(                                    \
+      ((condition) &&                                                      \
+       (absl_log_internal_severity >=                                      \
+            static_cast<::absl::LogSeverityAtLeast>(ABSL_MIN_LOG_LEVEL) || \
+        (absl_log_internal_severity == ::absl::LogSeverity::kFatal &&      \
+         (::absl::log_internal::AbortQuietly(), false)))))
 #else  // ndef ABSL_MIN_LOG_LEVEL
 #define ABSL_LOG_INTERNAL_CONDITION_INFO(type, condition) \
   ABSL_LOG_INTERNAL_##type##_CONDITION(condition)