grpc 1.51.0 → 1.52.0

data/src/core/lib/iomgr/wakeup_fd_posix.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -70,4 +70,4 @@ void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info) {
   wakeup_fd_vtable->destroy(fd_info);
 }
 
-#endif /* GRPC_POSIX_WAKEUP_FD */
+#endif  // GRPC_POSIX_WAKEUP_FD

data/src/core/lib/iomgr/wakeup_fd_posix.h

@@ -1,49 +1,49 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
-/*
- * wakeup_fd abstracts the concept of a file descriptor for the purpose of
- * waking up a thread in select()/poll()/epoll_wait()/etc.
+//
+// wakeup_fd abstracts the concept of a file descriptor for the purpose of
+// waking up a thread in select()/poll()/epoll_wait()/etc.
 
- * The poll() family of system calls provide a way for a thread to block until
- * there is activity on one (or more) of a set of file descriptors. An
- * application may wish to wake up this thread to do non file related work. The
- * typical way to do this is to add a pipe to the set of file descriptors, then
- * write to the pipe to wake up the thread in poll().
- *
- * Linux has a lighter weight eventfd specifically designed for this purpose.
- * wakeup_fd abstracts the difference between the two.
- *
- * Setup:
- * 1. Before calling anything, call global_init() at least once.
- * 1. Call grpc_wakeup_fd_init() to set up a wakeup_fd.
- * 2. Add the result of GRPC_WAKEUP_FD_FD to the set of monitored file
- *    descriptors for the poll() style API you are using. Monitor the file
- *    descriptor for readability.
- * 3. To tear down, call grpc_wakeup_fd_destroy(). This closes the underlying
- *    file descriptor.
- *
- * Usage:
- * 1. To wake up a polling thread, call grpc_wakeup_fd_wakeup() on a wakeup_fd
- *    it is monitoring.
- * 2. If the polling thread was awakened by a wakeup_fd event, call
- *    grpc_wakeup_fd_consume_wakeup() on it.
- */
+// The poll() family of system calls provide a way for a thread to block until
+// there is activity on one (or more) of a set of file descriptors. An
+// application may wish to wake up this thread to do non file related work. The
+// typical way to do this is to add a pipe to the set of file descriptors, then
+// write to the pipe to wake up the thread in poll().
+//
+// Linux has a lighter weight eventfd specifically designed for this purpose.
+// wakeup_fd abstracts the difference between the two.
+//
+// Setup:
+// 1. Before calling anything, call global_init() at least once.
+// 1. Call grpc_wakeup_fd_init() to set up a wakeup_fd.
+// 2. Add the result of GRPC_WAKEUP_FD_FD to the set of monitored file
+//    descriptors for the poll() style API you are using. Monitor the file
+//    descriptor for readability.
+// 3. To tear down, call grpc_wakeup_fd_destroy(). This closes the underlying
+//    file descriptor.
+//
+// Usage:
+// 1. To wake up a polling thread, call grpc_wakeup_fd_wakeup() on a wakeup_fd
+//    it is monitoring.
+// 2. If the polling thread was awakened by a wakeup_fd event, call
+//    grpc_wakeup_fd_consume_wakeup() on it.
+//
 #ifndef GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H
 #define GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H
 
@@ -54,8 +54,8 @@
 void grpc_wakeup_fd_global_init(void);
 void grpc_wakeup_fd_global_destroy(void);
 
-/* Force using the fallback implementation. This is intended for testing
- * purposes only.*/
+// Force using the fallback implementation. This is intended for testing
+// purposes only.
 void grpc_wakeup_fd_global_init_force_fallback(void);
 
 int grpc_has_wakeup_fd(void);
@@ -67,7 +67,7 @@ typedef struct grpc_wakeup_fd_vtable {
   grpc_error_handle (*consume)(grpc_wakeup_fd* fd_info);
   grpc_error_handle (*wakeup)(grpc_wakeup_fd* fd_info);
   void (*destroy)(grpc_wakeup_fd* fd_info);
-  /* Must be called before calling any other functions */
+  // Must be called before calling any other functions
   int (*check_availability)(void);
 } grpc_wakeup_fd_vtable;
 
@@ -89,8 +89,8 @@ grpc_error_handle grpc_wakeup_fd_wakeup(grpc_wakeup_fd* fd_info)
     GRPC_MUST_USE_RESULT;
 void grpc_wakeup_fd_destroy(grpc_wakeup_fd* fd_info);
 
-/* Defined in some specialized implementation's .c file, or by
- * wakeup_fd_nospecial.c if no such implementation exists. */
+// Defined in some specialized implementation's .c file, or by
+// wakeup_fd_nospecial.c if no such implementation exists.
 extern const grpc_wakeup_fd_vtable grpc_specialized_wakeup_fd_vtable;
 
-#endif /* GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H */
+#endif  // GRPC_CORE_LIB_IOMGR_WAKEUP_FD_POSIX_H

data/src/core/lib/json/json_object_loader.cc

@@ -110,6 +110,16 @@ void LoadUnprocessedJsonObject::LoadInto(const Json& json, const JsonArgs&,
   *static_cast<Json::Object*>(dst) = json.object_value();
 }
 
+void LoadUnprocessedJsonArray::LoadInto(const Json& json, const JsonArgs&,
+                                        void* dst,
+                                        ValidationErrors* errors) const {
+  if (json.type() != Json::Type::ARRAY) {
+    errors->AddError("is not an array");
+    return;
+  }
+  *static_cast<Json::Array*>(dst) = json.array_value();
+}
+
 void LoadVector::LoadInto(const Json& json, const JsonArgs& args, void* dst,
                           ValidationErrors* errors) const {
   if (json.type() != Json::Type::ARRAY) {

data/src/core/lib/json/json_object_loader.h

@@ -214,6 +214,16 @@ class LoadUnprocessedJsonObject : public LoaderInterface {
   ~LoadUnprocessedJsonObject() = default;
 };
 
+// Loads an unprocessed JSON array value.
+class LoadUnprocessedJsonArray : public LoaderInterface {
+ public:
+  void LoadInto(const Json& json, const JsonArgs& /*args*/, void* dst,
+                ValidationErrors* errors) const override;
+
+ protected:
+  ~LoadUnprocessedJsonArray() = default;
+};
+
 // Load a vector of some type.
 class LoadVector : public LoaderInterface {
  public:
@@ -328,6 +338,11 @@ class AutoLoader<Json::Object> final : public LoadUnprocessedJsonObject {
  private:
   ~AutoLoader() = default;
 };
+template <>
+class AutoLoader<Json::Array> final : public LoadUnprocessedJsonArray {
+ private:
+  ~AutoLoader() = default;
+};
 
 // Specializations of AutoLoader for vectors.
 template <typename T>
@@ -371,7 +386,6 @@ class AutoLoader<std::map<std::string, T>> final : public LoadMap {
     return LoaderForType<T>();
   }
 
- private:
   ~AutoLoader() = default;
 };
 

data/src/core/lib/json/json_reader.cc

@@ -50,9 +50,9 @@ class JsonReader {
 
  private:
   enum class Status {
-    GRPC_JSON_DONE,          /* The parser finished successfully. */
-    GRPC_JSON_PARSE_ERROR,   /* The parser found an error in the json stream. */
-    GRPC_JSON_INTERNAL_ERROR /* The parser got an internal error. */
+    GRPC_JSON_DONE,           // The parser finished successfully.
+    GRPC_JSON_PARSE_ERROR,    // The parser found an error in the json stream.
+    GRPC_JSON_INTERNAL_ERROR  // The parser got an internal error.
   };
 
   enum class State {
@@ -86,10 +86,10 @@ class JsonReader {
     GRPC_JSON_STATE_END
   };
 
-  /* The first non-unicode value is 0x110000. But let's pick
-   * a value high enough to start our error codes from. These
-   * values are safe to return from the read_char function.
-   */
+  // The first non-unicode value is 0x110000. But let's pick
+  // a value high enough to start our error codes from. These
+  // values are safe to return from the read_char function.
+  //
   static constexpr uint32_t GRPC_JSON_READ_CHAR_EOF = 0x7ffffff0;
 
   explicit JsonReader(absl::string_view input)
@@ -316,21 +316,21 @@ bool JsonReader::IsComplete() {
                              state_ == State::GRPC_JSON_STATE_VALUE_END));
 }
 
-/* Call this function to start parsing the input. It will return the following:
- *    . GRPC_JSON_DONE if the input got eof, and the parsing finished
- *      successfully.
- *    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
- *    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
- *      internal state.
- */
+// Call this function to start parsing the input. It will return the following:
+//    . GRPC_JSON_DONE if the input got eof, and the parsing finished
+//      successfully.
+//    . GRPC_JSON_PARSE_ERROR if the input was somehow invalid.
+//    . GRPC_JSON_INTERNAL_ERROR if the parser somehow ended into an invalid
+//      internal state.
+//
 JsonReader::Status JsonReader::Run() {
   uint32_t c;
 
-  /* This state-machine is a strict implementation of ECMA-404 */
+  // This state-machine is a strict implementation of ECMA-404
   while (true) {
     c = ReadChar();
     switch (c) {
-      /* Let's process the error case first. */
+      // Let's process the error case first.
       case GRPC_JSON_READ_CHAR_EOF:
         switch (state_) {
           case State::GRPC_JSON_STATE_VALUE_NUMBER:
@@ -349,7 +349,7 @@ JsonReader::Status JsonReader::Run() {
         }
         return Status::GRPC_JSON_PARSE_ERROR;
 
-      /* Processing whitespaces. */
+      // Processing whitespaces.
       case ' ':
       case '\t':
       case '\n':
@@ -384,7 +384,7 @@ JsonReader::Status JsonReader::Run() {
         }
         break;
 
-      /* Value, object or array terminations. */
+      // Value, object or array terminations.
       case ',':
       case '}':
       case ']':
@@ -461,7 +461,7 @@ JsonReader::Status JsonReader::Run() {
         }
         break;
 
-      /* In-string escaping. */
+      // In-string escaping.
       case '\\':
         switch (state_) {
           case State::GRPC_JSON_STATE_OBJECT_KEY_STRING:
@@ -474,7 +474,7 @@ JsonReader::Status JsonReader::Run() {
             state_ = State::GRPC_JSON_STATE_STRING_ESCAPE;
             break;
 
-          /* This is the \\ case. */
+          // This is the \\ case.
           case State::GRPC_JSON_STATE_STRING_ESCAPE:
             if (unicode_high_surrogate_ != 0) {
               return Status::GRPC_JSON_PARSE_ERROR;
@@ -662,17 +662,17 @@ JsonReader::Status JsonReader::Run() {
                 state_ = State::GRPC_JSON_STATE_STRING_ESCAPE_U4;
                 break;
               case State::GRPC_JSON_STATE_STRING_ESCAPE_U4:
-                /* See grpc_json_writer_escape_string to have a description
-                 * of what's going on here.
-                 */
+                // See grpc_json_writer_escape_string to have a description
+                // of what's going on here.
+                //
                 if ((unicode_char_ & 0xfc00) == 0xd800) {
-                  /* high surrogate utf-16 */
+                  // high surrogate utf-16
                   if (unicode_high_surrogate_ != 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
                   }
                   unicode_high_surrogate_ = unicode_char_;
                 } else if ((unicode_char_ & 0xfc00) == 0xdc00) {
-                  /* low surrogate utf-16 */
+                  // low surrogate utf-16
                   uint32_t utf32;
                   if (unicode_high_surrogate_ == 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
@@ -686,7 +686,7 @@ JsonReader::Status JsonReader::Run() {
                   }
                   unicode_high_surrogate_ = 0;
                 } else {
-                  /* anything else */
+                  // anything else
                   if (unicode_high_surrogate_ != 0) {
                     return Status::GRPC_JSON_PARSE_ERROR;
                   }
@@ -874,8 +874,8 @@ JsonReader::Status JsonReader::Run() {
             state_ = State::GRPC_JSON_STATE_VALUE_END;
             break;
 
-          /* All of the VALUE_END cases are handled in the specialized case
-           * above. */
+          // All of the VALUE_END cases are handled in the specialized case
+          // above.
           case State::GRPC_JSON_STATE_VALUE_END:
             switch (c) {
               case ',':

data/src/core/lib/json/json_writer.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -34,17 +34,17 @@ namespace grpc_core {
 
 namespace {
 
-/* The idea of the writer is basically symmetrical of the reader. While the
- * reader emits various calls to your code, the writer takes basically the
- * same calls and emit json out of it. It doesn't try to make any check on
- * the order of the calls you do on it. Meaning you can theorically force
- * it to generate invalid json.
- *
- * Also, unlike the reader, the writer expects UTF-8 encoded input strings.
- * These strings will be UTF-8 validated, and any invalid character will
- * cut the conversion short, before any invalid UTF-8 sequence, thus forming
- * a valid UTF-8 string overall.
- */
+// The idea of the writer is basically symmetrical of the reader. While the
+// reader emits various calls to your code, the writer takes basically the
+// same calls and emit json out of it. It doesn't try to make any check on
+// the order of the calls you do on it. Meaning you can theorically force
+// it to generate invalid json.
+//
+// Also, unlike the reader, the writer expects UTF-8 encoded input strings.
+// These strings will be UTF-8 validated, and any invalid character will
+// cut the conversion short, before any invalid UTF-8 sequence, thus forming
+// a valid UTF-8 string overall.
+//
 class JsonWriter {
  public:
   static std::string Dump(const Json& value, int indent);
@@ -76,15 +76,15 @@ class JsonWriter {
   std::string output_;
 };
 
-/* This function checks if there's enough space left in the output buffer,
- * and will enlarge it if necessary. We're only allocating chunks of 256
- * bytes at a time (or multiples thereof).
- */
+// This function checks if there's enough space left in the output buffer,
+// and will enlarge it if necessary. We're only allocating chunks of 256
+// bytes at a time (or multiples thereof).
+//
 void JsonWriter::OutputCheck(size_t needed) {
   size_t free_space = output_.capacity() - output_.size();
   if (free_space >= needed) return;
   needed -= free_space;
-  /* Round up by 256 bytes. */
+  // Round up by 256 bytes.
   needed = (needed + 0xff) & ~0xffU;
   output_.reserve(output_.capacity() + needed);
 }
@@ -191,13 +191,13 @@ void JsonWriter::EscapeString(const std::string& string) {
       for (i = 0; i < extra; i++) {
         utf32 <<= 6;
         ++idx;
-        /* Breaks out and bail if we hit the end of the string. */
+        // Breaks out and bail if we hit the end of the string.
         if (idx == string.size()) {
           valid = 0;
           break;
         }
         c = static_cast<uint8_t>(string[idx]);
-        /* Breaks out and bail on any invalid UTF-8 sequence, including \0. */
+        // Breaks out and bail on any invalid UTF-8 sequence, including \0.
         if ((c & 0xc0) != 0x80) {
           valid = 0;
           break;
@@ -205,30 +205,30 @@ void JsonWriter::EscapeString(const std::string& string) {
         utf32 |= c & 0x3f;
       }
       if (!valid) break;
-      /* The range 0xd800 - 0xdfff is reserved by the surrogates ad vitam.
-       * Any other range is technically reserved for future usage, so if we
-       * don't want the software to break in the future, we have to allow
-       * anything else. The first non-unicode character is 0x110000. */
+      // The range 0xd800 - 0xdfff is reserved by the surrogates ad vitam.
+      // Any other range is technically reserved for future usage, so if we
+      // don't want the software to break in the future, we have to allow
+      // anything else. The first non-unicode character is 0x110000.
       if (((utf32 >= 0xd800) && (utf32 <= 0xdfff)) || (utf32 >= 0x110000)) {
         break;
       }
       if (utf32 >= 0x10000) {
-        /* If utf32 contains a character that is above 0xffff, it needs to be
-         * broken down into a utf-16 surrogate pair. A surrogate pair is first
-         * a high surrogate, followed by a low surrogate. Each surrogate holds
-         * 10 bits of usable data, thus allowing a total of 20 bits of data.
-         * The high surrogate marker is 0xd800, while the low surrogate marker
-         * is 0xdc00. The low 10 bits of each will be the usable data.
-         *
-         * After re-combining the 20 bits of data, one has to add 0x10000 to
-         * the resulting value, in order to obtain the original character.
-         * This is obviously because the range 0x0000 - 0xffff can be written
-         * without any special trick.
-         *
-         * Since 0x10ffff is the highest allowed character, we're working in
-         * the range 0x00000 - 0xfffff after we decrement it by 0x10000.
-         * That range is exactly 20 bits.
-         */
+        // If utf32 contains a character that is above 0xffff, it needs to be
+        // broken down into a utf-16 surrogate pair. A surrogate pair is first
+        // a high surrogate, followed by a low surrogate. Each surrogate holds
+        // 10 bits of usable data, thus allowing a total of 20 bits of data.
+        // The high surrogate marker is 0xd800, while the low surrogate marker
+        // is 0xdc00. The low 10 bits of each will be the usable data.
+        //
+        // After re-combining the 20 bits of data, one has to add 0x10000 to
+        // the resulting value, in order to obtain the original character.
+        // This is obviously because the range 0x0000 - 0xffff can be written
+        // without any special trick.
+        //
+        // Since 0x10ffff is the highest allowed character, we're working in
+        // the range 0x00000 - 0xfffff after we decrement it by 0x10000.
+        // That range is exactly 20 bits.
+        //
         utf32 -= 0x10000;
         EscapeUtf16(static_cast<uint16_t>(0xd800 | (utf32 >> 10)));
         EscapeUtf16(static_cast<uint16_t>(0xdc00 | (utf32 & 0x3ff)));
@@ -283,7 +283,7 @@ void JsonWriter::ValueString(const std::string& string) {
 void JsonWriter::DumpObject(const Json::Object& object) {
   ContainerBegins(Json::Type::OBJECT);
   for (const auto& p : object) {
-    ObjectKey(p.first.data());
+    ObjectKey(p.first);
     DumpValue(p.second);
   }
   ContainerEnds(Json::Type::OBJECT);

data/src/core/lib/load_balancing/lb_policy.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 

data/src/core/lib/load_balancing/lb_policy.h

@@ -34,7 +34,7 @@
 #include "absl/types/variant.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/backend_metric_data.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -256,10 +256,9 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
   /// Currently, pickers are always accessed from within the
   /// client_channel data plane mutex, so they do not have to be
   /// thread-safe.
-  class SubchannelPicker {
+  class SubchannelPicker : public RefCounted<SubchannelPicker> {
    public:
     SubchannelPicker() = default;
-    virtual ~SubchannelPicker() = default;
 
     virtual PickResult Pick(PickArgs args) = 0;
   };
@@ -284,7 +283,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     /// by the client channel.
     virtual void UpdateState(grpc_connectivity_state state,
                              const absl::Status& status,
-                             std::unique_ptr<SubchannelPicker>) = 0;
+                             RefCountedPtr<SubchannelPicker> picker) = 0;
 
     /// Requests that the resolver re-resolve.
     virtual void RequestReresolution() = 0;

data/src/core/lib/load_balancing/subchannel_interface.h

@@ -24,7 +24,7 @@
 
 #include "absl/status/status.h"
 
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/connectivity_state.h>
 
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"

data/src/core/lib/matchers/matchers.cc

@@ -22,6 +22,7 @@
 #include "absl/strings/ascii.h"
 #include "absl/strings/match.h"
 #include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
 namespace grpc_core {
@@ -37,7 +38,8 @@ absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
     auto regex_matcher = std::make_unique<RE2>(std::string(matcher));
     if (!regex_matcher->ok()) {
       return absl::InvalidArgumentError(
-          "Invalid regex string specified in matcher.");
+          absl::StrCat("Invalid regex string specified in matcher: ",
+                       regex_matcher->error()));
     }
     return StringMatcher(std::move(regex_matcher));
   } else {

data/src/core/lib/matchers/matchers.h

@@ -159,4 +159,4 @@ class HeaderMatcher {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_LIB_MATCHERS_MATCHERS_H */
+#endif  // GRPC_CORE_LIB_MATCHERS_MATCHERS_H