grpc 1.47.0-x86_64-linux → 1.49.0.pre1-x86_64-linux

data/src/core/tsi/transport_security_grpc.h

@@ -47,12 +47,14 @@ tsi_result tsi_zero_copy_grpc_protector_protect(
 /* Outputs unprotected bytes.
    - protected_slices is the bytes of protected frames.
    - unprotected_slices is the unprotected output data.
+   - if min_progress_size is not null, it returns the size of the last
+     incomplete frame which could not be fully unprotected.
    - This method returns TSI_OK in case of success. Success includes cases where
      there is not enough data to output in which case unprotected_slices has 0
      bytes.  */
 tsi_result tsi_zero_copy_grpc_protector_unprotect(
     tsi_zero_copy_grpc_protector* self, grpc_slice_buffer* protected_slices,
-    grpc_slice_buffer* unprotected_slices);
+    grpc_slice_buffer* unprotected_slices, int* min_progress_size);
 
 /* Destroys the tsi_zero_copy_grpc_protector object.  */
 void tsi_zero_copy_grpc_protector_destroy(tsi_zero_copy_grpc_protector* self);
@@ -68,7 +70,8 @@ struct tsi_zero_copy_grpc_protector_vtable {
                         grpc_slice_buffer* protected_slices);
   tsi_result (*unprotect)(tsi_zero_copy_grpc_protector* self,
                           grpc_slice_buffer* protected_slices,
-                          grpc_slice_buffer* unprotected_slices);
+                          grpc_slice_buffer* unprotected_slices,
+                          int* min_progress_size);
   void (*destroy)(tsi_zero_copy_grpc_protector* self);
   tsi_result (*max_frame_size)(tsi_zero_copy_grpc_protector* self,
                                size_t* max_frame_size);

data/src/core/tsi/transport_security_interface.h

@@ -24,6 +24,8 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#include <string>
+
 #include "src/core/lib/debug/trace.h"
 
 /* --- tsi result ---  */
@@ -472,6 +474,13 @@ typedef void (*tsi_handshaker_on_next_done_cb)(
    - cb is the callback function defined above. It can be NULL for synchronous
      TSI handshaker implementation.
    - user_data is the argument to callback function passed from the caller.
+   - error, if non-null, will be populated with a human-readable error
+     message whenever the result value is something other than TSI_OK,
+     TSI_ASYNC, or TSI_INCOMPLETE_DATA.  The object pointed to by this
+     argument is owned by the caller and must continue to exist until after the
+     handshake is finished.  Some TSI implementations cache this value,
+     so callers must pass the same value to all calls to tsi_handshaker_next()
+     for a given handshake.
    This method returns TSI_ASYNC if the TSI handshaker implementation is
    asynchronous, and in this case, the callback is guaranteed to run in another
    thread owned by TSI. It returns TSI_OK if the handshake completes or if
@@ -482,11 +491,14 @@ typedef void (*tsi_handshaker_on_next_done_cb)(
    The caller is responsible for destroying the handshaker_result. However,
    the caller should not free bytes_to_send, as the buffer is owned by the
    tsi_handshaker object.  */
-tsi_result tsi_handshaker_next(
-    tsi_handshaker* self, const unsigned char* received_bytes,
-    size_t received_bytes_size, const unsigned char** bytes_to_send,
-    size_t* bytes_to_send_size, tsi_handshaker_result** handshaker_result,
-    tsi_handshaker_on_next_done_cb cb, void* user_data);
+tsi_result tsi_handshaker_next(tsi_handshaker* self,
+                               const unsigned char* received_bytes,
+                               size_t received_bytes_size,
+                               const unsigned char** bytes_to_send,
+                               size_t* bytes_to_send_size,
+                               tsi_handshaker_result** handshaker_result,
+                               tsi_handshaker_on_next_done_cb cb,
+                               void* user_data, std::string* error = nullptr);
 
 /* This method shuts down a TSI handshake that is in progress.
  *

data/src/ruby/ext/grpc/ext-export-truffleruby.clang

@@ -0,0 +1,2 @@
+_Init_grpc_c
+_rb_tr_abi_version

data/src/ruby/ext/grpc/ext-export-truffleruby.gcc

@@ -0,0 +1,7 @@
+grpc_1.0 { 
+  global: 
+    Init_grpc_c;
+    rb_tr_abi_version;
+  local: 
+    *;
+};

data/src/ruby/ext/grpc/ext-export.clang

@@ -1 +1,2 @@
 _Init_grpc_c
+_ruby_abi_version

data/src/ruby/ext/grpc/ext-export.gcc

@@ -1,6 +1,7 @@
 grpc_1.0 { 
   global: 
     Init_grpc_c;
+    ruby_abi_version;
   local: 
     *;
 };

data/src/ruby/ext/grpc/extconf.rb

@@ -16,10 +16,13 @@ require 'etc'
 require 'mkmf'
 
 windows = RUBY_PLATFORM =~ /mingw|mswin/
+windows_ucrt = RUBY_PLATFORM =~ /(mingw|mswin).*ucrt/
 bsd = RUBY_PLATFORM =~ /bsd/
 darwin = RUBY_PLATFORM =~ /darwin/
 linux = RUBY_PLATFORM =~ /linux/
 cross_compiling = ENV['RCD_HOST_RUBY_VERSION'] # set by rake-compiler-dock in build containers
+# TruffleRuby uses the Sulong LLVM runtime, which is different from Apple's.
+apple_toolchain = darwin && RUBY_ENGINE != 'truffleruby'
 
 grpc_root = File.expand_path(File.join(File.dirname(__FILE__), '../../../..'))
 
@@ -27,30 +30,53 @@ grpc_config = ENV['GRPC_CONFIG'] || 'opt'
 
 ENV['MACOSX_DEPLOYMENT_TARGET'] = '10.10'
 
-if ENV['AR'].nil? || ENV['AR'].size == 0
-    ENV['AR'] = RbConfig::CONFIG['AR']
+def env_unset?(name)
+  ENV[name].nil? || ENV[name].size == 0
 end
-if ENV['CC'].nil? || ENV['CC'].size == 0
-    ENV['CC'] = RbConfig::CONFIG['CC']
+
+def rbconfig_set?(name)
+  RbConfig::CONFIG[name] && RbConfig::CONFIG[name].size > 0
 end
-if ENV['CXX'].nil? || ENV['CXX'].size == 0
-    ENV['CXX'] = RbConfig::CONFIG['CXX']
+
+def inherit_rbconfig(name)
+  ENV[name] = RbConfig::CONFIG[name] if env_unset?(name) && rbconfig_set?(name)
 end
-if ENV['LD'].nil? || ENV['LD'].size == 0
-    ENV['LD'] = ENV['CC']
+
+def env_append(name, string)
+  ENV[name] ||= ''
+  ENV[name] += ' ' + string
+end
+
+inherit_rbconfig 'AR'
+inherit_rbconfig 'CC'
+inherit_rbconfig 'CXX'
+inherit_rbconfig 'RANLIB'
+inherit_rbconfig 'STRIP'
+inherit_rbconfig 'CPPFLAGS'
+inherit_rbconfig 'LDFLAGS'
+
+ENV['LD'] = ENV['CC'] if env_unset?('LD')
+ENV['LDXX'] = ENV['CXX'] if env_unset?('LDXX')
+
+if RUBY_ENGINE == 'truffleruby'
+  # ensure we can find the system's OpenSSL
+  env_append 'CPPFLAGS', RbConfig::CONFIG['cppflags']
 end
 
-if darwin && !cross_compiling
+if apple_toolchain && !cross_compiling
   ENV['AR'] = 'libtool'
   ENV['ARFLAGS'] = '-o'
 end
 
-ENV['EMBED_OPENSSL'] = 'true'
-ENV['EMBED_ZLIB'] = 'true'
+# Don't embed on TruffleRuby (constant-time crypto is unsafe with Sulong, slow build times)
+ENV['EMBED_OPENSSL'] = (RUBY_ENGINE != 'truffleruby').to_s
+# Don't embed on TruffleRuby (the system zlib is already linked for the zlib C extension, slow build times)
+ENV['EMBED_ZLIB'] = (RUBY_ENGINE != 'truffleruby').to_s
+
 ENV['EMBED_CARES'] = 'true'
 
 ENV['ARCH_FLAGS'] = RbConfig::CONFIG['ARCH_FLAG']
-if darwin && !cross_compiling
+if apple_toolchain && !cross_compiling
   if RUBY_PLATFORM =~ /arm64/
     ENV['ARCH_FLAGS'] = '-arch arm64'
   else
@@ -58,9 +84,12 @@ if darwin && !cross_compiling
   end
 end
 
-ENV['CPPFLAGS'] = '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
-ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\"" '
-ENV['CPPFLAGS'] += ' -DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"1.47.0\"" '
+env_append 'CPPFLAGS', '-DGPR_BACKWARDS_COMPATIBILITY_MODE'
+env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_NAME_SUFFIX="\"RUBY\""'
+env_append 'CPPFLAGS', '-DGRPC_RUBY_WINDOWS_UCRT' if windows_ucrt
+
+require_relative '../../lib/grpc/version'
+env_append 'CPPFLAGS', '-DGRPC_XDS_USER_AGENT_VERSION_SUFFIX="\"' + GRPC::VERSION + '\""'
 
 output_dir = File.expand_path(RbConfig::CONFIG['topdir'])
 grpc_lib_dir = File.join(output_dir, 'libs', grpc_config)
@@ -85,8 +114,9 @@ end
 $CFLAGS << ' -I' + File.join(grpc_root, 'include')
 
 ext_export_file = File.join(grpc_root, 'src', 'ruby', 'ext', 'grpc', 'ext-export')
+ext_export_file += '-truffleruby' if RUBY_ENGINE == 'truffleruby'
 $LDFLAGS << ' -Wl,--version-script="' + ext_export_file + '.gcc"' if linux
-$LDFLAGS << ' -Wl,-exported_symbols_list,"' + ext_export_file + '.clang"' if darwin
+$LDFLAGS << ' -Wl,-exported_symbols_list,"' + ext_export_file + '.clang"' if apple_toolchain
 
 $LDFLAGS << ' ' + File.join(grpc_lib_dir, 'libgrpc.a') unless windows
 if grpc_config == 'gcov'
@@ -99,7 +129,10 @@ if grpc_config == 'dbg'
 end
 
 $LDFLAGS << ' -Wl,-wrap,memcpy' if linux
-$LDFLAGS << ' -static-libgcc -static-libstdc++' if linux
+# Do not statically link standard libraries on TruffleRuby as this does not work when compiling to bitcode
+if linux && RUBY_ENGINE != 'truffleruby'
+  $LDFLAGS << ' -static-libgcc -static-libstdc++'
+end
 $LDFLAGS << ' -static' if windows
 
 $CFLAGS << ' -std=c11 '
@@ -112,7 +145,7 @@ puts 'Generating Makefile for ' + output
 create_makefile(output)
 
 strip_tool = RbConfig::CONFIG['STRIP']
-strip_tool += ' -x' if darwin
+strip_tool += ' -x' if apple_toolchain
 
 if grpc_config == 'opt'
   File.open('Makefile.new', 'w') do |o|

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -278,7 +278,7 @@ extern grpc_resource_quota_resize_type grpc_resource_quota_resize_import;
 typedef void(*grpc_resource_quota_set_max_threads_type)(grpc_resource_quota* resource_quota, int new_max_threads);
 extern grpc_resource_quota_set_max_threads_type grpc_resource_quota_set_max_threads_import;
 #define grpc_resource_quota_set_max_threads grpc_resource_quota_set_max_threads_import
-typedef grpc_slice(*grpc_dump_xds_configs_type)();
+typedef grpc_slice(*grpc_dump_xds_configs_type)(void);
 extern grpc_dump_xds_configs_type grpc_dump_xds_configs_import;
 #define grpc_dump_xds_configs grpc_dump_xds_configs_import
 typedef const grpc_arg_pointer_vtable*(*grpc_resource_quota_arg_vtable_type)(void);

data/src/ruby/ext/grpc/rb_loader.c

@@ -23,9 +23,13 @@
 
 int grpc_rb_load_core() {
 #if GPR_ARCH_64
-  TCHAR fname[] = _T("grpc_c.64.ruby");
+#if GRPC_RUBY_WINDOWS_UCRT
+  TCHAR fname[] = _T("grpc_c.64-ucrt.ruby");
 #else
-  TCHAR fname[] = _T("grpc_c.32.ruby");
+  TCHAR fname[] = _T("grpc_c.64-msvcrt.ruby");
+#endif
+#else
+  TCHAR fname[] = _T("grpc_c.32-msvcrt.ruby");
 #endif
   HMODULE module = GetModuleHandle(_T("grpc_c.so"));
   TCHAR path[2048 + 32] = _T("");

data/src/ruby/lib/grpc/errors.rb

@@ -43,7 +43,7 @@ module GRPC
                    debug_error_string = nil)
       exception_message = "#{code}:#{details}"
       if debug_error_string
-        exception_message += ". debug_error_string:#{debug_error_string}"
+        exception_message += ". debug_error_string:{#{debug_error_string}}"
       end
       super(exception_message)
       @code = code

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.47.0'
+  VERSION = '1.49.0.pre1'
 end

data/src/ruby/pb/src/proto/grpc/testing/messages_pb.rb

@@ -104,6 +104,9 @@ Google::Protobuf::DescriptorPool.generated_pool.build do
     end
     add_message "grpc.testing.ClientConfigureResponse" do
     end
+    add_message "grpc.testing.MemorySize" do
+      optional :rss, :int64, 1
+    end
     add_enum "grpc.testing.PayloadType" do
       value :COMPRESSABLE, 0
     end
@@ -139,6 +142,7 @@ module Grpc
     ClientConfigureRequest::Metadata = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureRequest.Metadata").msgclass
     ClientConfigureRequest::RpcType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureRequest.RpcType").enummodule
     ClientConfigureResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.ClientConfigureResponse").msgclass
+    MemorySize = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.MemorySize").msgclass
     PayloadType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.PayloadType").enummodule
     GrpclbRouteType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("grpc.testing.GrpclbRouteType").enummodule
   end

data/src/ruby/spec/generic/client_stub_spec.rb

@@ -498,31 +498,10 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
                            /Header values must be of type string or array/)
       end
 
-      def run_server_streamer_against_client_with_unmarshal_error(
-        expected_input, replys)
-        wakey_thread do |notifier|
-          c = expect_server_to_be_invoked(notifier)
-          expect(c.remote_read).to eq(expected_input)
-          begin
-            replys.each { |r| c.remote_send(r) }
-          rescue GRPC::Core::CallError
-            # An attempt to write to the client might fail. This is ok
-            # because the client call is expected to fail when
-            # unmarshalling the first response, and to cancel the call,
-            # and there is a race as for when the server-side call will
-            # start to fail.
-            p 'remote_send failed (allowed because call expected to cancel)'
-          ensure
-            c.send_status(OK, 'OK', true)
-            close_active_server_call(c)
-          end
-        end
-      end
-
       it 'the call terminates when there is an unmarshalling error' do
         server_port = create_test_server
         host = "localhost:#{server_port}"
-        th = run_server_streamer_against_client_with_unmarshal_error(
+        th = run_server_streamer_handle_client_cancellation(
           @sent_msg, @replys)
         stub = GRPC::ClientStub.new(host, :this_channel_is_insecure)
 
@@ -597,7 +576,8 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
       it 'raises GRPC::Cancelled after the call has been cancelled' do
         server_port = create_test_server
         host = "localhost:#{server_port}"
-        th = run_server_streamer(@sent_msg, @replys, @pass)
+        th = run_server_streamer_handle_client_cancellation(
+          @sent_msg, @replys)
         stub = GRPC::ClientStub.new(host, :this_channel_is_insecure)
         resp = get_responses(stub, run_start_call_first: false)
         expect(resp.next).to eq('reply_1')
@@ -1037,6 +1017,26 @@ describe 'ClientStub' do  # rubocop:disable Metrics/BlockLength
     end
   end
 
+  def run_server_streamer_handle_client_cancellation(
+    expected_input, replys)
+    wakey_thread do |notifier|
+      c = expect_server_to_be_invoked(notifier)
+      expect(c.remote_read).to eq(expected_input)
+      begin
+        replys.each { |r| c.remote_send(r) }
+      rescue GRPC::Core::CallError
+        # An attempt to write to the client might fail. This is ok
+        # because the client call is expected to cancel the call,
+        # and there is a race as for when the server-side call will
+        # start to fail.
+        p 'remote_send failed (allowed because call expected to cancel)'
+      ensure
+        c.send_status(OK, 'OK', true)
+        close_active_server_call(c)
+      end
+    end
+  end
+
   def run_request_response(expected_input, resp, status,
                            expected_metadata: {},
                            server_initial_md: {},

data/third_party/abseil-cpp/absl/algorithm/container.h

@@ -166,7 +166,7 @@ container_algorithm_internal::ContainerDifferenceType<const C> c_distance(
 // c_all_of()
 //
 // Container-based version of the <algorithm> `std::all_of()` function to
-// test a condition on all elements within a container.
+// test if all elements within a container satisfy a condition.
 template <typename C, typename Pred>
 bool c_all_of(const C& c, Pred&& pred) {
   return std::all_of(container_algorithm_internal::c_begin(c),

data/third_party/abseil-cpp/absl/base/attributes.h

@@ -136,9 +136,10 @@
 // for further information.
 // The MinGW compiler doesn't complain about the weak attribute until the link
 // step, presumably because Windows doesn't use ELF binaries.
-#if (ABSL_HAVE_ATTRIBUTE(weak) ||                   \
-     (defined(__GNUC__) && !defined(__clang__))) && \
-    (!defined(_WIN32) || __clang_major__ < 9) && !defined(__MINGW32__)
+#if (ABSL_HAVE_ATTRIBUTE(weak) ||                                         \
+     (defined(__GNUC__) && !defined(__clang__))) &&                       \
+    (!defined(_WIN32) || (defined(__clang__) && __clang_major__ >= 9)) && \
+    !defined(__MINGW32__)
 #undef ABSL_ATTRIBUTE_WEAK
 #define ABSL_ATTRIBUTE_WEAK __attribute__((weak))
 #define ABSL_HAVE_ATTRIBUTE_WEAK 1
@@ -212,6 +213,9 @@
 // https://gcc.gnu.org/gcc-4.8/changes.html
 #if ABSL_HAVE_ATTRIBUTE(no_sanitize_address)
 #define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
+#elif defined(_MSC_VER) && _MSC_VER >= 1928
+// https://docs.microsoft.com/en-us/cpp/cpp/no-sanitize-address
+#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __declspec(no_sanitize_address)
 #else
 #define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
 #endif
@@ -311,7 +315,6 @@
   __attribute__((section(#name))) __attribute__((noinline))
 #endif
 
-
 // ABSL_ATTRIBUTE_SECTION_VARIABLE
 //
 // Tells the compiler/linker to put a given variable into a section and define
@@ -338,8 +341,8 @@
 // a no-op on ELF but not on Mach-O.
 //
 #ifndef ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
-#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) \
-  extern char __start_##name[] ABSL_ATTRIBUTE_WEAK;    \
+#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)   \
+  extern char __start_##name[] ABSL_ATTRIBUTE_WEAK; \
   extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK
 #endif
 #ifndef ABSL_DEFINE_ATTRIBUTE_SECTION_VARS
@@ -400,6 +403,9 @@
 //
 // Tells the compiler to warn about unused results.
 //
+// For code or headers that are assured to only build with C++17 and up, prefer
+// just using the standard `[[nodiscard]]` directly over this macro.
+//
 // When annotating a function, it must appear as the first part of the
 // declaration or definition. The compiler will warn if the return value from
 // such a function is unused:
@@ -426,9 +432,10 @@
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425
 //
 // Note: past advice was to place the macro after the argument list.
-#if ABSL_HAVE_ATTRIBUTE(nodiscard)
-#define ABSL_MUST_USE_RESULT [[nodiscard]]
-#elif defined(__clang__) && ABSL_HAVE_ATTRIBUTE(warn_unused_result)
+//
+// TODO(b/176172494): Use ABSL_HAVE_CPP_ATTRIBUTE(nodiscard) when all code is
+// compliant with the stricter [[nodiscard]].
+#if defined(__clang__) && ABSL_HAVE_ATTRIBUTE(warn_unused_result)
 #define ABSL_MUST_USE_RESULT __attribute__((warn_unused_result))
 #else
 #define ABSL_MUST_USE_RESULT
@@ -498,7 +505,7 @@
 #define ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]
 #if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)
 #define ABSL_XRAY_LOG_ARGS(N) \
-    [[clang::xray_always_instrument, clang::xray_log_args(N)]]
+  [[clang::xray_always_instrument, clang::xray_log_args(N)]]
 #else
 #define ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]
 #endif
@@ -642,6 +649,9 @@
 // declarations. The macro argument is used as a custom diagnostic message (e.g.
 // suggestion of a better alternative).
 //
+// For code or headers that are assured to only build with C++14 and up, prefer
+// just using the standard `[[deprecated("message")]]` directly over this macro.
+//
 // Examples:
 //
 //   class ABSL_DEPRECATED("Use Bar instead") Foo {...};
@@ -652,14 +662,17 @@
 //   ABSL_DEPRECATED("Use DoThat() instead")
 //   void DoThis();
 //
+//   enum FooEnum {
+//     kBar ABSL_DEPRECATED("Use kBaz instead"),
+//   };
+//
 // Every usage of a deprecated entity will trigger a warning when compiled with
-// clang's `-Wdeprecated-declarations` option. This option is turned off by
-// default, but the warnings will be reported by clang-tidy.
-#if defined(__clang__) && defined(__cplusplus) && __cplusplus >= 201103L
+// GCC/Clang's `-Wdeprecated-declarations` option. Google's production toolchain
+// turns this warning off by default, instead relying on clang-tidy to report
+// new uses of deprecated code.
+#if ABSL_HAVE_ATTRIBUTE(deprecated)
 #define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
-#endif
-
-#ifndef ABSL_DEPRECATED
+#else
 #define ABSL_DEPRECATED(message)
 #endif
 
@@ -669,9 +682,18 @@
 // not compile (on supported platforms) unless the variable has a constant
 // initializer. This is useful for variables with static and thread storage
 // duration, because it guarantees that they will not suffer from the so-called
-// "static init order fiasco".  Prefer to put this attribute on the most visible
-// declaration of the variable, if there's more than one, because code that
-// accesses the variable can then use the attribute for optimization.
+// "static init order fiasco".
+//
+// This attribute must be placed on the initializing declaration of the
+// variable. Some compilers will give a -Wmissing-constinit warning when this
+// attribute is placed on some other declaration but missing from the
+// initializing declaration.
+//
+// In some cases (notably with thread_local variables), `ABSL_CONST_INIT` can
+// also be used in a non-initializing declaration to tell the compiler that a
+// variable is already initialized, reducing overhead that would otherwise be
+// incurred by a hidden guard variable. Thus annotating all declarations with
+// this attribute is recommended to potentially enhance optimization.
 //
 // Example:
 //
@@ -680,14 +702,19 @@
 //     ABSL_CONST_INIT static MyType my_var;
 //   };
 //
-//   MyType MyClass::my_var = MakeMyType(...);
+//   ABSL_CONST_INIT MyType MyClass::my_var = MakeMyType(...);
+//
+// For code or headers that are assured to only build with C++20 and up, prefer
+// just using the standard `constinit` keyword directly over this macro.
 //
 // Note that this attribute is redundant if the variable is declared constexpr.
-#if ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
+#if defined(__cpp_constinit) && __cpp_constinit >= 201907L
+#define ABSL_CONST_INIT constinit
+#elif ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
 #define ABSL_CONST_INIT [[clang::require_constant_initialization]]
 #else
 #define ABSL_CONST_INIT
-#endif  // ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
+#endif
 
 // ABSL_ATTRIBUTE_PURE_FUNCTION
 //