re2 1.22.2 → 1.23.0

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

@@ -34,7 +34,7 @@ namespace absl {
 ABSL_NAMESPACE_BEGIN
 namespace log_internal {
 
-class ABSL_MUST_USE_RESULT AsLiteralImpl final {
+class [[nodiscard]] AsLiteralImpl final {
  public:
   explicit AsLiteralImpl(absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND)
       : str_(str) {}
@@ -66,7 +66,7 @@ enum class StructuredStringType {
 // Structured log data for a string and associated structured proto field,
 // both of which must outlive this object.
 template <StructuredStringType str_type>
-class ABSL_MUST_USE_RESULT AsStructuredStringTypeImpl final {
+class [[nodiscard]] AsStructuredStringTypeImpl final {
  public:
   constexpr AsStructuredStringTypeImpl(
       absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND,
@@ -105,7 +105,7 @@ using AsStructuredNotLiteralImpl =
 // Structured log data for a stringifyable type T and associated structured
 // proto field, both of which must outlive this object.
 template <typename T>
-class ABSL_MUST_USE_RESULT AsStructuredValueImpl final {
+class [[nodiscard]] AsStructuredValueImpl final {
  public:
   using ValueFormatter = absl::AnyInvocable<std::string(T) const>;
 
@@ -139,8 +139,6 @@ class ABSL_MUST_USE_RESULT AsStructuredValueImpl final {
   }
 };
 
-#ifdef ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-
 // Template deduction guide so `AsStructuredValueImpl(42, data)` works
 // without specifying the template type.
 template <typename T>
@@ -155,8 +153,6 @@ AsStructuredValueImpl(
     typename AsStructuredValueImpl<T>::ValueFormatter value_formatter)
     -> AsStructuredValueImpl<T>;
 
-#endif  // ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION
-
 }  // namespace log_internal
 ABSL_NAMESPACE_END
 }  // namespace absl

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

@@ -90,16 +90,16 @@ struct VModuleInfo final {
 // To avoid problems with the heap checker which calls into `VLOG`, `mutex` must
 // be a `SpinLock` that prevents fiber scheduling instead of a `Mutex`.
 ABSL_CONST_INIT absl::base_internal::SpinLock mutex(
-    absl::kConstInit, absl::base_internal::SCHEDULE_KERNEL_ONLY);
+    absl::base_internal::SCHEDULE_KERNEL_ONLY);
 
 // `GetUpdateSitesMutex()` serializes updates to all of the sites (i.e. those in
 // `site_list_head`) themselves.
-absl::Mutex* GetUpdateSitesMutex() {
+absl::Mutex& GetUpdateSitesMutex() {
   // Chromium requires no global destructors, so we can't use the
   // absl::kConstInit idiom since absl::Mutex as a non-trivial destructor.
   static absl::NoDestructor<absl::Mutex> update_sites_mutex ABSL_ACQUIRED_AFTER(
       mutex);
-  return update_sites_mutex.get();
+  return *update_sites_mutex;
 }
 
 ABSL_CONST_INIT int global_v ABSL_GUARDED_BY(mutex) = 0;
@@ -222,7 +222,7 @@ int PrependVModuleLocked(absl::string_view module_pattern, int log_level)
 }  // namespace
 
 int VLogLevel(absl::string_view file) ABSL_LOCKS_EXCLUDED(mutex) {
-  absl::base_internal::SpinLockHolder l(&mutex);
+  absl::base_internal::SpinLockHolder l(mutex);
   return VLogLevel(file, vmodule_info, global_v);
 }
 
@@ -267,7 +267,7 @@ void UpdateVLogSites() ABSL_UNLOCK_FUNCTION(mutex)
   // have to wait on all updates in order to acquire `mutex` and initialize
   // themselves.
   absl::MutexLock ul(GetUpdateSitesMutex());
-  mutex.Unlock();
+  mutex.unlock();
   VLogSite* n = site_list_head.load(std::memory_order_seq_cst);
   // Because sites are added to the list in the order they are executed, there
   // tend to be clusters of entries with the same file.
@@ -299,7 +299,7 @@ void UpdateVModule(absl::string_view vmodule)
     if (!absl::SimpleAtoi(glob_level.substr(eq + 1), &level)) continue;
     glob_levels.emplace_back(glob, level);
   }
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   get_vmodule_info().clear();
   for (const auto& it : glob_levels) {
     const absl::string_view glob = it.first;
@@ -311,10 +311,10 @@ void UpdateVModule(absl::string_view vmodule)
 
 int UpdateGlobalVLogLevel(int v)
     ABSL_LOCKS_EXCLUDED(mutex, GetUpdateSitesMutex()) {
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   const int old_global_v = global_v;
   if (v == global_v) {
-    mutex.Unlock();
+    mutex.unlock();
     return old_global_v;
   }
   global_v = v;
@@ -324,7 +324,7 @@ int UpdateGlobalVLogLevel(int v)
 
 int PrependVModule(absl::string_view module_pattern, int log_level)
     ABSL_LOCKS_EXCLUDED(mutex, GetUpdateSitesMutex()) {
-  mutex.Lock();  // Unlocked by UpdateVLogSites().
+  mutex.lock();  // unlocked by UpdateVLogSites().
   int old_v = PrependVModuleLocked(module_pattern, log_level);
   UpdateVLogSites();
   return old_v;

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

@@ -34,6 +34,7 @@
 
 #include "absl/base/attributes.h"
 #include "absl/base/config.h"
+#include "absl/base/nullability.h"
 #include "absl/base/optimization.h"
 #include "absl/base/thread_annotations.h"
 #include "absl/strings/string_view.h"
@@ -45,7 +46,7 @@ namespace log_internal {
 class SyntheticBinary;
 class VLogSite;
 
-int RegisterAndInitialize(VLogSite* v);
+int RegisterAndInitialize(VLogSite* absl_nonnull v);
 void UpdateVLogSites();
 constexpr int kUseFlag = (std::numeric_limits<int16_t>::min)();
 
@@ -60,7 +61,7 @@ constexpr int kUseFlag = (std::numeric_limits<int16_t>::min)();
 class VLogSite final {
  public:
   // `f` must not be destroyed until the program exits.
-  explicit constexpr VLogSite(const char* f)
+  explicit constexpr VLogSite(const char* absl_nonnull f)
       : file_(f), v_(kUninitialized), next_(nullptr) {}
   VLogSite(const VLogSite&) = delete;
   VLogSite& operator=(const VLogSite&) = delete;
@@ -93,7 +94,7 @@ class VLogSite final {
   }
 
  private:
-  friend int log_internal::RegisterAndInitialize(VLogSite* v);
+  friend int log_internal::RegisterAndInitialize(VLogSite* absl_nonnull v);
   friend void log_internal::UpdateVLogSites();
   friend class log_internal::SyntheticBinary;
   static constexpr int kUninitialized = (std::numeric_limits<int>::max)();
@@ -116,7 +117,7 @@ class VLogSite final {
   ABSL_ATTRIBUTE_NOINLINE bool SlowIsEnabled5(int stale_v);
 
   // This object is too size-sensitive to use absl::string_view.
-  const char* const file_;
+  const char* absl_nonnull const file_;
   std::atomic<int> v_;
   std::atomic<VLogSite*> next_;
 };
@@ -130,7 +131,7 @@ int VLogLevel(absl::string_view file);
 // Registers a site `v` to get updated as `vmodule` and `v` change.  Also
 // initializes the site based on their current values, and returns that result.
 // Does not allocate memory.
-int RegisterAndInitialize(VLogSite* v);
+int RegisterAndInitialize(VLogSite* absl_nonnull v);
 
 // Allocates memory.
 void UpdateVLogSites();
@@ -154,7 +155,8 @@ int PrependVModule(absl::string_view module_pattern, int log_level);
 void OnVLogVerbosityUpdate(std::function<void()> cb);
 
 // Does not allocate memory.
-VLogSite* SetVModuleListHeadForTestOnly(VLogSite* v);
+VLogSite* absl_nullable SetVModuleListHeadForTestOnly(
+    VLogSite* absl_nullable v);
 
 }  // namespace log_internal
 ABSL_NAMESPACE_END

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

@@ -16,13 +16,15 @@
 // File: log/internal/voidify.h
 // -----------------------------------------------------------------------------
 //
-// This class is used to explicitly ignore values in the conditional logging
-// macros. This avoids compiler warnings like "value computed is not used" and
-// "statement has no effect".
+// This class does the dispatching of the completed `absl::LogEntry` to
+// applicable `absl::LogSink`s, and is used to explicitly ignore values in the
+// conditional logging macros. This avoids compiler warnings like "value
+// computed is not used" and "statement has no effect".
 
 #ifndef ABSL_LOG_INTERNAL_VOIDIFY_H_
 #define ABSL_LOG_INTERNAL_VOIDIFY_H_
 
+#include "absl/base/attributes.h"
 #include "absl/base/config.h"
 
 namespace absl {
@@ -34,7 +36,11 @@ class Voidify final {
   // This has to be an operator with a precedence lower than << but higher than
   // ?:
   template <typename T>
-  void operator&&(const T&) const&& {}
+  ABSL_ATTRIBUTE_COLD void operator&&(T&& message) const&& {
+    // The dispatching of the completed `absl::LogEntry` to applicable
+    // `absl::LogSink`s happens here.
+    message.Flush();
+  }
 };
 
 }  // namespace log_internal

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

@@ -34,6 +34,13 @@
 //   running registered error handlers.
 // * The `DFATAL` pseudo-severity level is defined as `FATAL` in debug mode and
 //   as `ERROR` otherwise.
+// * The `DO_NOT_SUBMIT` pseudo-severity level is an alias for `ERROR`, and is
+//   intended for debugging statements that won't be submitted.  The name is
+//   chosen to be easy to spot in review and with tools in order to ensure that
+//   such statements aren't inadvertently checked in.
+//   The contract is that **it may not be checked in**, meaning that no
+//   in-contract uses will be affected if we decide in the future to remove it
+//   or change what it does.
 // Some preprocessor shenanigans are used to ensure that e.g. `LOG(INFO)` has
 // the same meaning even if a local symbol or preprocessor macro named `INFO` is
 // defined.  To specify a severity level using an expression instead of a
@@ -194,6 +201,8 @@
 //   LOG(INFO) << std::hex << 0xdeadbeef;  // logs "0xdeadbeef"
 //   LOG(INFO) << 0xdeadbeef;              // logs "3735928559"
 
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
+
 #ifndef ABSL_LOG_LOG_H_
 #define ABSL_LOG_LOG_H_
 
@@ -260,44 +269,55 @@
   ABSL_LOG_INTERNAL_DLOG_IF_IMPL(_##severity, condition)
 
 // LOG_EVERY_N
+// LOG_FIRST_N
+// LOG_EVERY_POW_2
+// LOG_EVERY_N_SEC
 //
-// An instance of `LOG_EVERY_N` increments a hidden zero-initialized counter
-// every time execution passes through it and logs the specified message when
-// the counter's value is a multiple of `n`, doing nothing otherwise.  Each
-// instance has its own counter.  The counter's value can be logged by streaming
-// the symbol `COUNTER`.  `LOG_EVERY_N` is thread-safe.
-// Example:
+// These "stateful" macros log conditionally based on a hidden counter or timer.
+// When the condition is false and no logging is done, streamed operands aren't
+// evaluated either.  Each instance has its own state (i.e. counter, timer)
+// that's independent of other instances of the macros.  The macros in this
+// family are thread-safe in the sense that they are meant to be called
+// concurrently and will not invoke undefined behavior, however their
+// implementation prioritizes efficiency over exactness and may occasionally log
+// more or less often than specified.
+//
+//   * `LOG_EVERY_N` logs the first time and once every `n` times thereafter.
+//   * `LOG_FIRST_N` logs the first `n` times and then stops.
+//   * `LOG_EVERY_POW_2` logs the first, second, fourth, eighth, etc. times.
+//   * `LOG_EVERY_N_SEC` logs the first time and no more than once every `n`
+//     seconds thereafter.  `n` is passed as a floating point value.
+//
+// The `LOG_IF`... variations with an extra condition evaluate the specified
+// condition first and short-circuit if it is false.  For example, an evaluation
+// of `LOG_IF_FIRST_N` does not count against the first `n` if the specified
+// condition is false.  Stateful `VLOG`... variations likewise short-circuit
+// if `VLOG` is disabled.
+//
+// An approximate count of the number of times a particular instance's stateful
+// condition has been evaluated (i.e. excluding those where a specified `LOG_IF`
+// condition was false) can be included in the logged message by streaming the
+// symbol `COUNTER`.
+//
+// The `n` parameter need not be a constant.  Conditional logging following a
+// change to `n` isn't fully specified, but it should converge on the new value
+// within roughly `max(old_n, new_n)` evaluations or seconds.
+//
+// Examples:
 //
 //   LOG_EVERY_N(WARNING, 1000) << "Got a packet with a bad CRC (" << COUNTER
 //                              << " total)";
+//
+//   LOG_EVERY_N_SEC(INFO, 2.5) << "Got " << COUNTER << " cookies so far";
+//
+//   LOG_IF_EVERY_N(INFO, (size > 1024), 10) << "Got the " << COUNTER
+//                                           << "th big cookie";
 #define LOG_EVERY_N(severity, n) \
   ABSL_LOG_INTERNAL_LOG_EVERY_N_IMPL(_##severity, n)
-
-// LOG_FIRST_N
-//
-// `LOG_FIRST_N` behaves like `LOG_EVERY_N` except that the specified message is
-// logged when the counter's value is less than `n`.  `LOG_FIRST_N` is
-// thread-safe.
 #define LOG_FIRST_N(severity, n) \
   ABSL_LOG_INTERNAL_LOG_FIRST_N_IMPL(_##severity, n)
-
-// LOG_EVERY_POW_2
-//
-// `LOG_EVERY_POW_2` behaves like `LOG_EVERY_N` except that the specified
-// message is logged when the counter's value is a power of 2.
-// `LOG_EVERY_POW_2` is thread-safe.
 #define LOG_EVERY_POW_2(severity) \
   ABSL_LOG_INTERNAL_LOG_EVERY_POW_2_IMPL(_##severity)
-
-// LOG_EVERY_N_SEC
-//
-// An instance of `LOG_EVERY_N_SEC` uses a hidden state variable to log the
-// specified message at most once every `n_seconds`.  A hidden counter of
-// executions (whether a message is logged or not) is also maintained and can be
-// logged by streaming the symbol `COUNTER`.  `LOG_EVERY_N_SEC` is thread-safe.
-// Example:
-//
-//   LOG_EVERY_N_SEC(INFO, 2.5) << "Got " << COUNTER << " cookies so far";
 #define LOG_EVERY_N_SEC(severity, n_seconds) \
   ABSL_LOG_INTERNAL_LOG_EVERY_N_SEC_IMPL(_##severity, n_seconds)
 
@@ -328,13 +348,6 @@
 #define VLOG_EVERY_N_SEC(severity, n_seconds) \
   ABSL_LOG_INTERNAL_VLOG_EVERY_N_SEC_IMPL(severity, n_seconds)
 
-// `LOG_IF_EVERY_N` and friends behave as the corresponding `LOG_EVERY_N`
-// but neither increment a counter nor log a message if condition is false (as
-// `LOG_IF`).
-// Example:
-//
-//   LOG_IF_EVERY_N(INFO, (size > 1024), 10) << "Got the " << COUNTER
-//                                           << "th big cookie";
 #define LOG_IF_EVERY_N(severity, condition, n) \
   ABSL_LOG_INTERNAL_LOG_IF_EVERY_N_IMPL(_##severity, condition, n)
 #define LOG_IF_FIRST_N(severity, condition, n) \

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

@@ -13,6 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// SKIP_ABSL_INLINE_NAMESPACE_CHECK
+
 // The testcases in this file are expected to pass or be skipped with any value
 // of ABSL_MIN_LOG_LEVEL
 
@@ -92,6 +94,7 @@ TEST_P(BasicLogTest, Info) {
   absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
 
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int log_line = __LINE__ + 1;
   auto do_log = [] { ABSL_TEST_LOG(INFO) << "hello world"; };
@@ -123,6 +126,7 @@ TEST_P(BasicLogTest, Warning) {
   absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
 
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int log_line = __LINE__ + 1;
   auto do_log = [] { ABSL_TEST_LOG(WARNING) << "hello world"; };
@@ -154,6 +158,7 @@ TEST_P(BasicLogTest, Error) {
   absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
 
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int log_line = __LINE__ + 1;
   auto do_log = [] { ABSL_TEST_LOG(ERROR) << "hello world"; };
@@ -181,6 +186,38 @@ TEST_P(BasicLogTest, Error) {
   do_log();
 }
 
+TEST_P(BasicLogTest, DoNotSubmit) {
+  absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
+
+  absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
+
+  const int log_line = __LINE__ + 1;
+  auto do_log = [] { ABSL_TEST_LOG(DO_NOT_SUBMIT) << "hello world"; };
+
+  if (LoggingEnabledAt(absl::LogSeverity::kError)) {
+    EXPECT_CALL(
+        test_sink,
+        Send(AllOf(
+            SourceFilename(Eq(__FILE__)),
+            SourceBasename(Eq("log_basic_test_impl.inc")),
+            SourceLine(Eq(log_line)), Prefix(IsTrue()),
+            LogSeverity(Eq(absl::LogSeverity::kError)),
+            Timestamp(InMatchWindow()),
+            ThreadID(Eq(absl::base_internal::GetTID())),
+            TextMessage(Eq("hello world")),
+            Verbosity(Eq(absl::LogEntry::kNoVerbosityLevel)),
+            ENCODED_MESSAGE(MatchesEvent(
+                Eq(__FILE__), Eq(log_line), InMatchWindow(),
+                Eq(logging::proto::ERROR), Eq(absl::base_internal::GetTID()),
+                ElementsAre(ValueWithLiteral(Eq("hello world"))))),
+            Stacktrace(IsEmpty()))));
+  }
+
+  test_sink.StartCapturingLogs();
+  do_log();
+}
+
 #if GTEST_HAS_DEATH_TEST
 using BasicLogDeathTest = BasicLogTest;
 
@@ -200,6 +237,7 @@ TEST_P(BasicLogDeathTest, Fatal) {
       {
         absl::ScopedMockLog test_sink(
             absl::MockLogDefault::kDisallowUnexpected);
+        EXPECT_CALL(test_sink, Send).Times(0);
 
         EXPECT_CALL(test_sink, Send)
             .Times(AnyNumber())
@@ -266,6 +304,7 @@ TEST_P(BasicLogDeathTest, QFatal) {
       {
         absl::ScopedMockLog test_sink(
             absl::MockLogDefault::kDisallowUnexpected);
+        EXPECT_CALL(test_sink, Send).Times(0);
 
         EXPECT_CALL(test_sink, Send)
             .Times(AnyNumber())
@@ -303,6 +342,7 @@ TEST_P(BasicLogTest, DFatal) {
   absl::log_internal::ScopedMinLogLevel scoped_min_log_level(GetParam());
 
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   const int log_line = __LINE__ + 1;
   auto do_log = [] { ABSL_TEST_LOG(DFATAL) << "hello world"; };
@@ -342,6 +382,7 @@ TEST_P(BasicLogDeathTest, DFatal) {
       {
         absl::ScopedMockLog test_sink(
             absl::MockLogDefault::kDisallowUnexpected);
+        EXPECT_CALL(test_sink, Send).Times(0);
 
         EXPECT_CALL(test_sink, Send)
             .Times(AnyNumber())
@@ -423,6 +464,7 @@ TEST_P(BasicLogTest, Level) {
   for (auto severity : {absl::LogSeverity::kInfo, absl::LogSeverity::kWarning,
                         absl::LogSeverity::kError}) {
     absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+    EXPECT_CALL(test_sink, Send).Times(0);
 
     const int log_line = __LINE__ + 2;
     auto do_log = [severity] {
@@ -473,6 +515,7 @@ TEST_P(BasicLogDeathTest, Level) {
       {
         absl::ScopedMockLog test_sink(
             absl::MockLogDefault::kDisallowUnexpected);
+        EXPECT_CALL(test_sink, Send).Times(0);
 
         EXPECT_CALL(test_sink, Send)
             .Times(AnyNumber())
@@ -534,6 +577,7 @@ TEST_P(BasicLogTest, LevelClampsNegativeValues) {
   }
 
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   EXPECT_CALL(test_sink, Send(LogSeverity(Eq(absl::LogSeverity::kInfo))));
 
@@ -550,6 +594,7 @@ TEST_P(BasicLogTest, LevelClampsLargeValues) {
   }
 
   absl::ScopedMockLog test_sink(absl::MockLogDefault::kDisallowUnexpected);
+  EXPECT_CALL(test_sink, Send).Times(0);
 
   EXPECT_CALL(test_sink, Send(LogSeverity(Eq(absl::LogSeverity::kError))));