grpc 1.36.0 → 1.37.0.pre1

data/src/core/lib/gprpp/atomic.h

@@ -81,8 +81,8 @@ class Atomic {
 
   // Atomically increment a counter only if the counter value is not zero.
   // Returns true if increment took place; false if counter is zero.
-  bool IncrementIfNonzero(MemoryOrder load_order = MemoryOrder::ACQUIRE) {
-    T count = storage_.load(static_cast<std::memory_order>(load_order));
+  bool IncrementIfNonzero() {
+    T count = storage_.load(std::memory_order_acquire);
     do {
       // If zero, we are done (without an increment). If not, we must do a CAS
       // to maintain the contract: do not increment the counter if it is already
@@ -91,7 +91,7 @@ class Atomic {
         return false;
       }
     } while (!CompareExchangeWeak(&count, count + 1, MemoryOrder::ACQ_REL,
-                                  load_order));
+                                  MemoryOrder::ACQUIRE));
     return true;
   }
 

data/src/core/lib/gprpp/dual_ref_counted.h

@@ -170,8 +170,8 @@ class DualRefCounted : public Orphanable {
 #endif
     const uint64_t prev_ref_pair =
         refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
 #ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
     if (trace != nullptr) {
       gpr_log(GPR_INFO, "%s:%p weak_unref %d -> %d (refs=%d)", trace, this,
@@ -192,10 +192,10 @@ class DualRefCounted : public Orphanable {
 #endif
     const uint64_t prev_ref_pair =
         refs_.FetchSub(MakeRefPair(0, 1), MemoryOrder::ACQ_REL);
-    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
 #ifndef NDEBUG
+    const uint32_t weak_refs = GetWeakRefs(prev_ref_pair);
     const uint32_t strong_refs = GetStrongRefs(prev_ref_pair);
-    if (trace_ != nullptr) {
+    if (trace != nullptr) {
       gpr_log(GPR_INFO, "%s:%p %s:%d weak_unref %d -> %d (refs=%d) %s", trace,
               this, location.file(), location.line(), weak_refs, weak_refs - 1,
               strong_refs, reason);

data/src/core/lib/gprpp/ref_counted_ptr.h

@@ -83,6 +83,7 @@ class RefCountedPtr {
   }
 
   // Copy assignment.
+  // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
   RefCountedPtr& operator=(const RefCountedPtr& other) {
     // Note: Order of reffing and unreffing is important here in case value_
     // and other.value_ are the same object.
@@ -235,6 +236,7 @@ class WeakRefCountedPtr {
   }
 
   // Copy assignment.
+  // NOLINTNEXTLINE(bugprone-unhandled-self-assignment)
   WeakRefCountedPtr& operator=(const WeakRefCountedPtr& other) {
     // Note: Order of reffing and unreffing is important here in case value_
     // and other.value_ are the same object.

data/src/core/lib/gprpp/thd.h

@@ -157,7 +157,7 @@ class Thread {
   Thread& operator=(const Thread&) = delete;
 
   /// The thread states are as follows:
-  /// FAKE -- just a dummy placeholder Thread created by the default constructor
+  /// FAKE -- just a phony placeholder Thread created by the default constructor
   /// ALIVE -- an actual thread of control exists associated with this thread
   /// STARTED -- the thread of control has been started
   /// DONE -- the thread of control has completed and been joined

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

@@ -146,7 +146,7 @@ class TracedBuffer {
 #else  /* GRPC_LINUX_ERRQUEUE */
 class TracedBuffer {
  public:
-  /* Dummy shutdown function */
+  /* Phony shutdown function */
   static void Shutdown(grpc_core::TracedBuffer** /*head*/, void* /*remaining*/,
                        grpc_error* shutdown_err) {
     GRPC_ERROR_UNREF(shutdown_err);

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

@@ -202,9 +202,9 @@ void CFStreamHandle::Unref(const char* file, int line, const char* reason) {
 
 #else
 
-/* Creating a dummy function so that the grpc_cfstream library will be
+/* Creating a phony function so that the grpc_cfstream library will be
  * non-empty.
  */
-void CFStreamDummy() {}
+void CFStreamPhony() {}
 
 #endif

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

@@ -219,7 +219,7 @@ static grpc_error* grpc_error_create_from_vector(const char* file, int line,
 
 grpc_error* grpc_error_set_int(grpc_error* src, grpc_error_ints which,
                                intptr_t value) GRPC_MUST_USE_RESULT;
-/// It is an error to pass nullptr as `p`. Caller should allocate a dummy
+/// It is an error to pass nullptr as `p`. Caller should allocate a phony
 /// intptr_t for `p`, even if the value of `p` is not used.
 bool grpc_error_get_int(grpc_error* error, grpc_error_ints which, intptr_t* p);
 /// This call takes ownership of the slice; the error is responsible for

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

@@ -20,7 +20,7 @@
 /// is enabled (see iomgr_posix_cfstream.cc), a global thread is started to
 /// handle and trigger all the CFStream events. The CFStream streams register
 /// themselves with the run loop with functions grpc_apple_register_read_stream
-/// and grpc_apple_register_read_stream. Pollsets are dummy and block on a
+/// and grpc_apple_register_read_stream. Pollsets are phony and block on a
 /// condition variable in pollset_work().
 
 #include <grpc/support/port_platform.h>

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

@@ -388,9 +388,9 @@ static void fd_shutdown_internal(grpc_fd* fd, grpc_error* why,
     if (!releasing_fd) {
       shutdown(fd->fd, SHUT_RDWR);
     } else {
-      /* we need a dummy event for earlier linux versions. */
-      epoll_event dummy_event;
-      if (epoll_ctl(g_epoll_set.epfd, EPOLL_CTL_DEL, fd->fd, &dummy_event) !=
+      /* we need a phony event for earlier linux versions. */
+      epoll_event phony_event;
+      if (epoll_ctl(g_epoll_set.epfd, EPOLL_CTL_DEL, fd->fd, &phony_event) !=
           0) {
         gpr_log(GPR_ERROR, "epoll_ctl failed: %s", strerror(errno));
       }

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

@@ -89,7 +89,7 @@ namespace {
 
 grpc_poll_function_type real_poll_function;
 
-int dummy_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
+int phony_poll(struct pollfd fds[], nfds_t nfds, int timeout) {
   if (timeout == 0) {
     return real_poll_function(fds, nfds, 0);
   } else {
@@ -103,10 +103,10 @@ const grpc_event_engine_vtable* init_non_polling(bool explicit_request) {
   if (!explicit_request) {
     return nullptr;
   }
-  // return the simplest engine as a dummy but also override the poller
+  // return the simplest engine as a phony but also override the poller
   auto ret = grpc_init_poll_posix(explicit_request);
   real_poll_function = grpc_poll_function;
-  grpc_poll_function = dummy_poll;
+  grpc_poll_function = phony_poll;
 
   return ret;
 }

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

@@ -58,7 +58,9 @@ static grpc_millis timespan_to_millis_round_down(gpr_timespec ts) {
   double x = GPR_MS_PER_SEC * static_cast<double>(ts.tv_sec) +
              static_cast<double>(ts.tv_nsec) / GPR_NS_PER_MS;
   if (x < 0) return 0;
-  if (x > GRPC_MILLIS_INF_FUTURE) return GRPC_MILLIS_INF_FUTURE;
+  if (x > static_cast<double>(GRPC_MILLIS_INF_FUTURE)) {
+    return GRPC_MILLIS_INF_FUTURE;
+  }
   return static_cast<grpc_millis>(x);
 }
 
@@ -72,7 +74,9 @@ static grpc_millis timespan_to_millis_round_up(gpr_timespec ts) {
              static_cast<double>(GPR_NS_PER_SEC - 1) /
                  static_cast<double>(GPR_NS_PER_SEC);
   if (x < 0) return 0;
-  if (x > GRPC_MILLIS_INF_FUTURE) return GRPC_MILLIS_INF_FUTURE;
+  if (x > static_cast<double>(GRPC_MILLIS_INF_FUTURE)) {
+    return GRPC_MILLIS_INF_FUTURE;
+  }
   return static_cast<grpc_millis>(x);
 }
 

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

@@ -132,7 +132,7 @@ struct grpc_resource_quota {
      scaled to the range [0..RESOURCE_USAGE_ESTIMATION_MAX] */
   gpr_atm memory_usage_estimation;
 
-  /* Master combiner lock: all activity on a quota executes under this combiner
+  /* Main combiner lock: all activity on a quota executes under this combiner
    * (so no mutex is needed for this data structure) */
   grpc_core::Combiner* combiner;
   /* Size of the resource quota */

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

@@ -215,6 +215,25 @@ void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
   grpc_sockaddr_set_port(out, port);
 }
 
+grpc_error* grpc_string_to_sockaddr_new(grpc_resolved_address* out,
+                                        const char* addr, int port) {
+  memset(out, 0, sizeof(grpc_resolved_address));
+  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
+  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
+  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
+    addr6->sin6_family = GRPC_AF_INET6;
+    out->len = sizeof(grpc_sockaddr_in6);
+  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
+    addr4->sin_family = GRPC_AF_INET;
+    out->len = sizeof(grpc_sockaddr_in);
+  } else {
+    return GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+        absl::StrCat("Failed to parse address:", addr).c_str());
+  }
+  grpc_sockaddr_set_port(out, port);
+  return GRPC_ERROR_NONE;
+}
+
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (resolved_addr->len == 0) return "";
   grpc_resolved_address addr_normalized;
@@ -294,3 +313,104 @@ int grpc_sockaddr_set_port(grpc_resolved_address* resolved_addr, int port) {
       return 0;
   }
 }
+
+std::string grpc_sockaddr_get_packed_host(
+    const grpc_resolved_address* resolved_addr) {
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (addr->sa_family == GRPC_AF_INET) {
+    const grpc_sockaddr_in* addr4 =
+        reinterpret_cast<const grpc_sockaddr_in*>(addr);
+    const char* addr_bytes = reinterpret_cast<const char*>(&addr4->sin_addr);
+    return std::string(addr_bytes, 4);
+  } else if (addr->sa_family == GRPC_AF_INET6) {
+    const grpc_sockaddr_in6* addr6 =
+        reinterpret_cast<const grpc_sockaddr_in6*>(addr);
+    const char* addr_bytes = reinterpret_cast<const char*>(&addr6->sin6_addr);
+    return std::string(addr_bytes, 16);
+  } else {
+    GPR_ASSERT(false);
+  }
+}
+
+void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
+                             uint32_t mask_bits) {
+  grpc_sockaddr* addr = reinterpret_cast<grpc_sockaddr*>(address->addr);
+  if (addr->sa_family == GRPC_AF_INET) {
+    grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(addr);
+    if (mask_bits == 0) {
+      memset(&addr4->sin_addr, 0, sizeof(addr4->sin_addr));
+      return;
+    } else if (mask_bits >= 32) {
+      return;
+    }
+    uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+    addr4->sin_addr.s_addr &= grpc_htonl(mask_ip_addr);
+  } else if (addr->sa_family == GRPC_AF_INET6) {
+    grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(addr);
+    if (mask_bits == 0) {
+      memset(&addr6->sin6_addr, 0, sizeof(addr6->sin6_addr));
+      return;
+    } else if (mask_bits >= 128) {
+      return;
+    }
+    // We cannot use s6_addr32 since it is not defined on all platforms that we
+    // need it on.
+    uint32_t address_parts[4];
+    GPR_ASSERT(sizeof(addr6->sin6_addr) == sizeof(address_parts));
+    memcpy(address_parts, &addr6->sin6_addr, sizeof(grpc_in6_addr));
+    if (mask_bits <= 32) {
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[0] &= grpc_htonl(mask_ip_addr);
+      memset(&address_parts[1], 0, sizeof(uint32_t));
+      memset(&address_parts[2], 0, sizeof(uint32_t));
+      memset(&address_parts[3], 0, sizeof(uint32_t));
+    } else if (mask_bits <= 64) {
+      mask_bits -= 32;
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[1] &= grpc_htonl(mask_ip_addr);
+      memset(&address_parts[2], 0, sizeof(uint32_t));
+      memset(&address_parts[3], 0, sizeof(uint32_t));
+    } else if (mask_bits <= 96) {
+      mask_bits -= 64;
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[2] &= grpc_htonl(mask_ip_addr);
+      memset(&address_parts[3], 0, sizeof(uint32_t));
+    } else {
+      mask_bits -= 96;
+      uint32_t mask_ip_addr = (~(uint32_t(0))) << (32 - mask_bits);
+      address_parts[3] &= grpc_htonl(mask_ip_addr);
+    }
+    memcpy(&addr6->sin6_addr, address_parts, sizeof(grpc_in6_addr));
+  }
+}
+
+bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
+                                const grpc_resolved_address* subnet_address,
+                                uint32_t mask_bits) {
+  auto* addr = reinterpret_cast<const grpc_sockaddr*>(address->addr);
+  auto* subnet_addr =
+      reinterpret_cast<const grpc_sockaddr*>(subnet_address->addr);
+  if (addr->sa_family != subnet_addr->sa_family) return false;
+  grpc_resolved_address masked_address;
+  memcpy(&masked_address, address, sizeof(grpc_resolved_address));
+  addr = reinterpret_cast<grpc_sockaddr*>((&masked_address)->addr);
+  grpc_sockaddr_mask_bits(&masked_address, mask_bits);
+  if (addr->sa_family == GRPC_AF_INET) {
+    auto* addr4 = reinterpret_cast<const grpc_sockaddr_in*>(addr);
+    auto* subnet_addr4 = reinterpret_cast<const grpc_sockaddr_in*>(subnet_addr);
+    if (memcmp(&addr4->sin_addr, &subnet_addr4->sin_addr,
+               sizeof(addr4->sin_addr)) == 0) {
+      return true;
+    }
+  } else if (addr->sa_family == GRPC_AF_INET6) {
+    auto* addr6 = reinterpret_cast<const grpc_sockaddr_in6*>(addr);
+    auto* subnet_addr6 =
+        reinterpret_cast<const grpc_sockaddr_in6*>(subnet_addr);
+    if (memcmp(&addr6->sin6_addr, &subnet_addr6->sin6_addr,
+               sizeof(addr6->sin6_addr)) == 0) {
+      return true;
+    }
+  }
+  return false;
+}

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

@@ -66,9 +66,16 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
                                     bool normalize);
 
+// TODO(yashykt): Remove this function and replace usages with
+// `grpc_string_to_sockaddr_new`
 void grpc_string_to_sockaddr(grpc_resolved_address* out, const char* addr,
                              int port);
 
+// Newer form of grpc_string_to_sockaddr which returns an error instead of
+// crashing if \a addr is not IPv6/IPv6
+grpc_error* grpc_string_to_sockaddr_new(grpc_resolved_address* out,
+                                        const char* addr, int port);
+
 /* Returns the URI string corresponding to \a addr */
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
 
@@ -77,4 +84,22 @@ const char* grpc_sockaddr_get_uri_scheme(const grpc_resolved_address* addr);
 
 int grpc_sockaddr_get_family(const grpc_resolved_address* resolved_addr);
 
+std::string grpc_sockaddr_get_packed_host(
+    const grpc_resolved_address* resolved_addr);
+
+// Applies a mask of \a mask_bits to IPv4/IPv6 addresses. Has no effect if the
+// address type is not IPv4/IPv6.
+void grpc_sockaddr_mask_bits(grpc_resolved_address* address,
+                             uint32_t mask_bits);
+
+// If \a address is IPv4/IPv6, checks if the IP address falls in the CIDR
+// specified by \a subnet_address and \a mask_bits.
+// Returns false if \a address is not an IPv4/IPv6 address. The ports (if set)
+// are ignored for matching purposes. Note that, \a subnet_address should be
+// normalized, i.e., `grpc_sockaddr_mask_bits` should have been called on it if
+// necessary.
+bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
+                                const grpc_resolved_address* subnet_address,
+                                uint32_t mask_bits);
+
 #endif /* GRPC_CORE_LIB_IOMGR_SOCKADDR_UTILS_H */

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

@@ -1673,10 +1673,7 @@ static bool tcp_can_track_err(grpc_endpoint* ep) {
   if (getsockname(tcp->fd, &addr, &len) < 0) {
     return false;
   }
-  if (addr.sa_family == AF_INET || addr.sa_family == AF_INET6) {
-    return true;
-  }
-  return false;
+  return addr.sa_family == AF_INET || addr.sa_family == AF_INET6;
 }
 
 static const grpc_endpoint_vtable vtable = {tcp_read,

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

@@ -252,8 +252,8 @@ static void accept_new_connection(grpc_custom_socket* socket) {
   uv_socket->accept_error = GRPC_ERROR_NONE;
   uv_socket->pending_connections -= 1;
   if (uv_socket->accept_error != GRPC_ERROR_NONE) {
-    uv_stream_t dummy_handle;
-    uv_accept((uv_stream_t*)uv_socket->handle, &dummy_handle);
+    uv_stream_t phony_handle;
+    uv_accept((uv_stream_t*)uv_socket->handle, &phony_handle);
     uv_socket->accept_cb(socket, new_socket, error);
   } else {
     uv_socket_t* uv_new_socket = (uv_socket_t*)gpr_malloc(sizeof(uv_socket_t));

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

@@ -409,7 +409,7 @@ static void timer_init(grpc_timer* timer, grpc_millis deadline,
   }
   gpr_mu_unlock(&shard->mu);
 
-  /* Deadline may have decreased, we need to adjust the master queue.  Note
+  /* Deadline may have decreased, we need to adjust the main queue.  Note
      that there is a potential racy unlocked region here.  There could be a
      reordering of multiple grpc_timer_init calls, at this point, but the < test
      below should ensure that we err on the side of caution.  There could
@@ -639,7 +639,7 @@ static grpc_timer_check_result run_some_expired_timers(grpc_millis now,
 
       /* An grpc_timer_init() on the shard could intervene here, adding a new
          timer that is earlier than new_min_deadline.  However,
-         grpc_timer_init() will block on the master_lock before it can call
+         grpc_timer_init() will block on the mutex before it can call
          set_min_deadline, so this one will complete first and then the Addtimer
          will reduce the min_deadline (perhaps unnecessarily). */
       g_shard_queue[0]->min_deadline = new_min_deadline;

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

@@ -133,7 +133,7 @@ static void run_some_timers() {
   }
   grpc_core::ExecCtx::Get()->Flush();
   gpr_mu_lock(&g_mu);
-  // garbage collect any threads hanging out that are dead
+  // garbage collect any threads that are dead
   gc_completed_threads();
   // get ready to wait again
   ++g_waiter_count;

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

@@ -17,7 +17,7 @@
  */
 
 /*
- * This is a dummy file to provide an invalid specialized_wakeup_fd_vtable on
+ * This is a phony file to provide an invalid specialized_wakeup_fd_vtable on
  * systems without anything better than pipe.
  */
 

data/src/core/lib/{security/authorization → matchers}/matchers.cc

@@ -14,7 +14,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/lib/security/authorization/matchers.h"
+#include "src/core/lib/matchers/matchers.h"
 
 #include "absl/memory/memory.h"
 #include "absl/strings/str_cat.h"
@@ -29,12 +29,12 @@ namespace grpc_core {
 //
 
 absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
-                                                    const std::string& matcher,
+                                                    absl::string_view matcher,
                                                     bool case_sensitive) {
   if (type == Type::SAFE_REGEX) {
     RE2::Options options;
     options.set_case_sensitive(case_sensitive);
-    auto regex_matcher = absl::make_unique<RE2>(matcher, options);
+    auto regex_matcher = absl::make_unique<RE2>(std::string(matcher), options);
     if (!regex_matcher->ok()) {
       return absl::InvalidArgumentError(
           "Invalid regex string specified in matcher.");
@@ -45,7 +45,7 @@ absl::StatusOr<StringMatcher> StringMatcher::Create(Type type,
   }
 }
 
-StringMatcher::StringMatcher(Type type, const std::string& matcher,
+StringMatcher::StringMatcher(Type type, absl::string_view matcher,
                              bool case_sensitive)
     : type_(type), string_matcher_(matcher), case_sensitive_(case_sensitive) {}
 
@@ -164,7 +164,7 @@ std::string StringMatcher::ToString() const {
 //
 
 absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
-    const std::string& name, Type type, const std::string& matcher,
+    absl::string_view name, Type type, absl::string_view matcher,
     int64_t range_start, int64_t range_end, bool present_match,
     bool invert_match) {
   if (static_cast<int>(type) < 5) {
@@ -189,14 +189,14 @@ absl::StatusOr<HeaderMatcher> HeaderMatcher::Create(
   }
 }
 
-HeaderMatcher::HeaderMatcher(const std::string& name, Type type,
+HeaderMatcher::HeaderMatcher(absl::string_view name, Type type,
                              StringMatcher string_matcher, bool invert_match)
     : name_(name),
       type_(type),
       matcher_(std::move(string_matcher)),
       invert_match_(invert_match) {}
 
-HeaderMatcher::HeaderMatcher(const std::string& name, int64_t range_start,
+HeaderMatcher::HeaderMatcher(absl::string_view name, int64_t range_start,
                              int64_t range_end, bool invert_match)
     : name_(name),
       type_(Type::RANGE),
@@ -204,7 +204,7 @@ HeaderMatcher::HeaderMatcher(const std::string& name, int64_t range_start,
       range_end_(range_end),
       invert_match_(invert_match) {}
 
-HeaderMatcher::HeaderMatcher(const std::string& name, bool present_match,
+HeaderMatcher::HeaderMatcher(absl::string_view name, bool present_match,
                              bool invert_match)
     : name_(name),
       type_(Type::PRESENT),