re2 2.23.0 → 2.27.0

data/ext/re2/re2.cc

@@ -8,7 +8,7 @@
  * Released under the BSD Licence, please see LICENSE.txt
  */
 
-#include <stdint.h>
+#include <cstdint>
 
 #include <map>
 #include <sstream>
@@ -19,6 +19,7 @@
 #include <re2/set.h>
 #include <ruby.h>
 #include <ruby/encoding.h>
+#include <ruby/thread.h>
 
 #define BOOL2RUBY(v) (v ? Qtrue : Qfalse)
 
@@ -43,6 +44,132 @@ typedef struct {
   RE2::Set *set;
 } re2_set;
 
+struct nogvl_match_arg {
+  const RE2 *pattern;
+  re2::StringPiece text;
+  size_t startpos;
+  size_t endpos;
+  RE2::Anchor anchor;
+  re2::StringPiece *matches;
+  int n;
+  bool matched;
+};
+
+static void *nogvl_match(void *ptr) {
+  auto *arg = static_cast<nogvl_match_arg *>(ptr);
+#ifdef HAVE_ENDPOS_ARGUMENT
+  arg->matched = arg->pattern->Match(
+      arg->text, arg->startpos, arg->endpos,
+      arg->anchor, arg->matches, arg->n);
+#else
+  arg->matched = arg->pattern->Match(
+      arg->text, arg->startpos,
+      arg->anchor, arg->matches, arg->n);
+#endif
+  return nullptr;
+}
+
+static bool re2_match_without_gvl(
+    const RE2 *pattern, VALUE text, size_t startpos, size_t endpos,
+    RE2::Anchor anchor, re2::StringPiece *matches, int n) {
+  nogvl_match_arg arg;
+  arg.pattern = pattern;
+  arg.text = re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text));
+  arg.startpos = startpos;
+  arg.endpos = endpos;
+  arg.anchor = anchor;
+  arg.matches = matches;
+  arg.n = n;
+  arg.matched = false;
+
+  /* Abseil's synchronization primitives (SRWLOCK, SleepConditionVariableSRW)
+   * are incompatible with Ruby's Win32 Mutex-based GVL, causing
+   * WAIT_ABANDONED crashes when multiple threads match concurrently.
+   */
+#ifdef _WIN32
+  nogvl_match(&arg);
+#else
+  /* No unblocking function is needed: RE2 matching is CPU-bound computation,
+   * not a blocking system call, so a signal cannot safely interrupt it.
+   */
+  rb_thread_call_without_gvl(nogvl_match, &arg, NULL, NULL);
+#endif
+
+  return arg.matched;
+}
+
+struct nogvl_set_match_arg {
+  const RE2::Set *set;
+  re2::StringPiece text;
+  std::vector<int> *v;
+#ifdef HAVE_ERROR_INFO_ARGUMENT
+  RE2::Set::ErrorInfo *error_info;
+#endif
+  bool matched;
+};
+
+static void *nogvl_set_match(void *ptr) {
+  auto *arg = static_cast<nogvl_set_match_arg *>(ptr);
+#ifdef HAVE_ERROR_INFO_ARGUMENT
+  if (arg->error_info) {
+    arg->matched = arg->set->Match(arg->text, arg->v, arg->error_info);
+  } else {
+    arg->matched = arg->set->Match(arg->text, arg->v);
+  }
+#else
+  arg->matched = arg->set->Match(arg->text, arg->v);
+#endif
+  return nullptr;
+}
+
+struct nogvl_replace_arg {
+  std::string *str;
+  const RE2 *pattern;
+  re2::StringPiece string_pattern;
+  re2::StringPiece rewrite;
+};
+
+static void *nogvl_replace(void *ptr) {
+  auto *arg = static_cast<nogvl_replace_arg *>(ptr);
+  if (arg->pattern) {
+    RE2::Replace(arg->str, *arg->pattern, arg->rewrite);
+  } else {
+    RE2::Replace(arg->str, arg->string_pattern, arg->rewrite);
+  }
+  return nullptr;
+}
+
+static void *nogvl_global_replace(void *ptr) {
+  auto *arg = static_cast<nogvl_replace_arg *>(ptr);
+  if (arg->pattern) {
+    RE2::GlobalReplace(arg->str, *arg->pattern, arg->rewrite);
+  } else {
+    RE2::GlobalReplace(arg->str, arg->string_pattern, arg->rewrite);
+  }
+  return nullptr;
+}
+
+struct nogvl_extract_arg {
+  re2::StringPiece text;
+  const RE2 *pattern;
+  re2::StringPiece string_pattern;
+  re2::StringPiece rewrite;
+  std::string *out;
+  bool extracted;
+};
+
+static void *nogvl_extract(void *ptr) {
+  auto *arg = static_cast<nogvl_extract_arg *>(ptr);
+  if (arg->pattern) {
+    arg->extracted = RE2::Extract(arg->text, *arg->pattern,
+        arg->rewrite, arg->out);
+  } else {
+    arg->extracted = RE2::Extract(arg->text, RE2(arg->string_pattern),
+        arg->rewrite, arg->out);
+  }
+  return nullptr;
+}
+
 VALUE re2_mRE2, re2_cRegexp, re2_cMatchData, re2_cScanner, re2_cSet,
       re2_eSetMatchError, re2_eSetUnsupportedError, re2_eRegexpUnsupportedError;
 
@@ -51,7 +178,7 @@ static ID id_utf8, id_posix_syntax, id_longest_match, id_log_errors,
           id_max_mem, id_literal, id_never_nl, id_case_sensitive,
           id_perl_classes, id_word_boundary, id_one_line, id_unanchored,
           id_anchor, id_anchor_start, id_anchor_both, id_exception,
-          id_submatches, id_startpos, id_endpos;
+          id_submatches, id_startpos, id_endpos, id_symbolize_names;
 
 inline VALUE encoded_str_new(const char *str, long length, RE2::Options::Encoding encoding) {
   if (encoding == RE2::Options::EncodingUTF8) {
@@ -126,18 +253,22 @@ static void parse_re2_options(RE2::Options* re2_options, const VALUE options) {
 }
 
 static void re2_matchdata_mark(void *ptr) {
-  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  re2_matchdata *m = static_cast<re2_matchdata *>(ptr);
   rb_gc_mark_movable(m->regexp);
+
+  /* Text must not be movable because StringPiece matches hold pointers into
+   * its underlying buffer; moving the string would invalidate them.
+   */
   rb_gc_mark(m->text);
 }
 
 static void re2_matchdata_compact(void *ptr) {
-  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  re2_matchdata *m = static_cast<re2_matchdata *>(ptr);
   m->regexp = rb_gc_location(m->regexp);
 }
 
 static void re2_matchdata_free(void *ptr) {
-  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  re2_matchdata *m = static_cast<re2_matchdata *>(ptr);
   if (m->matches) {
     delete[] m->matches;
   }
@@ -145,7 +276,7 @@ static void re2_matchdata_free(void *ptr) {
 }
 
 static size_t re2_matchdata_memsize(const void *ptr) {
-  const re2_matchdata *m = reinterpret_cast<const re2_matchdata *>(ptr);
+  const re2_matchdata *m = static_cast<const re2_matchdata *>(ptr);
   size_t size = sizeof(*m);
   if (m->matches) {
     size += sizeof(*m->matches) * m->number_of_matches;
@@ -170,18 +301,22 @@ static const rb_data_type_t re2_matchdata_data_type = {
 };
 
 static void re2_scanner_mark(void *ptr) {
-  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  re2_scanner *s = static_cast<re2_scanner *>(ptr);
   rb_gc_mark_movable(s->regexp);
+
+  /* Text must not be movable because the StringPiece input holds a pointer
+   * into its underlying buffer; moving the string would invalidate it.
+   */
   rb_gc_mark(s->text);
 }
 
 static void re2_scanner_compact(void *ptr) {
-  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  re2_scanner *s = static_cast<re2_scanner *>(ptr);
   s->regexp = rb_gc_location(s->regexp);
 }
 
 static void re2_scanner_free(void *ptr) {
-  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  re2_scanner *s = static_cast<re2_scanner *>(ptr);
   if (s->input) {
     delete s->input;
   }
@@ -189,7 +324,7 @@ static void re2_scanner_free(void *ptr) {
 }
 
 static size_t re2_scanner_memsize(const void *ptr) {
-  const re2_scanner *s = reinterpret_cast<const re2_scanner *>(ptr);
+  const re2_scanner *s = static_cast<const re2_scanner *>(ptr);
   size_t size = sizeof(*s);
   if (s->input) {
     size += sizeof(*s->input);
@@ -214,7 +349,7 @@ static const rb_data_type_t re2_scanner_data_type = {
 };
 
 static void re2_regexp_free(void *ptr) {
-  re2_pattern *p = reinterpret_cast<re2_pattern *>(ptr);
+  re2_pattern *p = static_cast<re2_pattern *>(ptr);
   if (p->pattern) {
     delete p->pattern;
   }
@@ -222,7 +357,7 @@ static void re2_regexp_free(void *ptr) {
 }
 
 static size_t re2_regexp_memsize(const void *ptr) {
-  const re2_pattern *p = reinterpret_cast<const re2_pattern *>(ptr);
+  const re2_pattern *p = static_cast<const re2_pattern *>(ptr);
   size_t size = sizeof(*p);
   if (p->pattern) {
     size += sizeof(*p->pattern);
@@ -242,9 +377,64 @@ static const rb_data_type_t re2_regexp_data_type = {
   0,
   // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
   // macro to update VALUE references, as to trigger write barriers.
-  RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+  RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE
 };
 
+static re2_pattern *unwrap_re2_regexp(VALUE self) {
+  re2_pattern *p;
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  if (!p->pattern) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Regexp");
+  }
+  return p;
+}
+
+static re2_matchdata *unwrap_re2_matchdata(VALUE self) {
+  re2_matchdata *m;
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  if (!RTEST(m->regexp)) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::MatchData");
+  }
+  return m;
+}
+
+static re2_scanner *unwrap_re2_scanner(VALUE self) {
+  re2_scanner *c;
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  if (!RTEST(c->regexp)) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Scanner");
+  }
+  return c;
+}
+
+/*
+ * Returns an array of names of all named capturing groups. Names are returned
+ * in alphabetical order rather than definition order, as RE2 stores named
+ * groups internally in a sorted map.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [Array<String>] an array of names of named capturing groups
+ * @example
+ *   RE2::Regexp.new('(?P<a>\d+) (?P<b>\w+)').names #=> ["a", "b"]
+ */
+static VALUE re2_regexp_names(const VALUE self) {
+  re2_pattern *p = unwrap_re2_regexp(self);
+
+  const auto& groups = p->pattern->NamedCapturingGroups();
+  VALUE names = rb_ary_new2(groups.size());
+
+  for (const auto& group : groups) {
+    rb_ary_push(names,
+        encoded_str_new(group.first.data(), group.first.size(),
+          p->pattern->options().encoding()));
+  }
+
+  return names;
+}
+
 static VALUE re2_matchdata_allocate(VALUE klass) {
   re2_matchdata *m;
 
@@ -269,8 +459,7 @@ static VALUE re2_scanner_allocate(VALUE klass) {
  *   m.string #=> "bob 123"
  */
 static VALUE re2_matchdata_string(const VALUE self) {
-  re2_matchdata *m;
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return m->text;
 }
@@ -287,8 +476,7 @@ static VALUE re2_matchdata_string(const VALUE self) {
  *   c.string #=> "foo"
  */
 static VALUE re2_scanner_string(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return c->text;
 }
@@ -302,8 +490,7 @@ static VALUE re2_scanner_string(const VALUE self) {
  *   c.eof? #=> true
  */
 static VALUE re2_scanner_eof(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return BOOL2RUBY(c->eof);
 }
@@ -320,13 +507,12 @@ static VALUE re2_scanner_eof(const VALUE self) {
  *   e.scan #=> ["1"]
  */
 static VALUE re2_scanner_rewind(VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   delete c->input;
   c->input = new(std::nothrow) re2::StringPiece(
       RSTRING_PTR(c->text), RSTRING_LEN(c->text));
-  if (c->input == 0) {
+  if (c->input == nullptr) {
     rb_raise(rb_eNoMemError,
              "not enough memory to allocate StringPiece for input");
   }
@@ -336,6 +522,35 @@ static VALUE re2_scanner_rewind(VALUE self) {
   return self;
 }
 
+static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
+  re2_scanner *self_c;
+  re2_scanner *other_c = unwrap_re2_scanner(other);
+
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, self_c);
+
+  if (self_c->input) {
+    delete self_c->input;
+    self_c->input = nullptr;
+  }
+
+  RB_OBJ_WRITE(self, &self_c->regexp, other_c->regexp);
+  RB_OBJ_WRITE(self, &self_c->text, other_c->text);
+  self_c->number_of_capturing_groups = other_c->number_of_capturing_groups;
+  self_c->eof = other_c->eof;
+
+  if (other_c->input) {
+    self_c->input = new(std::nothrow) re2::StringPiece(*other_c->input);
+    if (self_c->input == nullptr) {
+      rb_raise(rb_eNoMemError,
+               "not enough memory to allocate StringPiece for input");
+    }
+  } else {
+    self_c->input = nullptr;
+  }
+
+  return self;
+}
+
 /*
  * Scan the given text incrementally for matches using
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L447-L463
@@ -356,11 +571,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
  *   s.scan #=> ["bar"]
  */
 static VALUE re2_scanner_scan(VALUE self) {
-  re2_pattern *p;
-  re2_scanner *c;
-
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
-  TypedData_Get_Struct(c->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_scanner *c = unwrap_re2_scanner(self);
+  re2_pattern *p = unwrap_re2_regexp(c->regexp);
 
   std::vector<RE2::Arg> argv(c->number_of_capturing_groups);
   std::vector<RE2::Arg*> args(c->number_of_capturing_groups);
@@ -385,7 +597,7 @@ static VALUE re2_scanner_scan(VALUE self) {
     VALUE result = rb_ary_new2(c->number_of_capturing_groups);
 
     for (int i = 0; i < c->number_of_capturing_groups; ++i) {
-      if (matches[i].empty()) {
+      if (matches[i].data() == nullptr) {
         rb_ary_push(result, Qnil);
       } else {
         rb_ary_push(result, encoded_str_new(matches[i].data(),
@@ -397,9 +609,27 @@ static VALUE re2_scanner_scan(VALUE self) {
     /* Check whether we've exhausted the input yet. */
     c->eof = new_input_size == 0;
 
-    /* If the match didn't advance the input, we need to do this ourselves. */
+    /* If the match didn't advance the input, we need to do this ourselves,
+     * advancing by a whole character to avoid splitting multi-byte characters.
+     *
+     * The lookup table approach is taken from RE2's own Python extension: the
+     * high 4 bits of a UTF-8 lead byte determine the character's byte length.
+     *
+     * See https://github.com/google/re2/blob/972a15cedd008d846f1a39b2e88ce48d7f166cbd/python/_re2.cc#L46-L48
+     */
     if (!input_advanced && new_input_size > 0) {
-      c->input->remove_prefix(1);
+      size_t char_size = 1;
+
+      if (p->pattern->options().encoding() == RE2::Options::EncodingUTF8) {
+        char_size = "\1\1\1\1\1\1\1\1\1\1\1\1\2\2\3\4"
+            [((*c->input)[0] & 0xFF) >> 4];
+
+        if (char_size > new_input_size) {
+          char_size = new_input_size;
+        }
+      }
+
+      c->input->remove_prefix(char_size);
     }
 
     return result;
@@ -409,47 +639,44 @@ static VALUE re2_scanner_scan(VALUE self) {
 }
 
 static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   int id;
 
   if (RB_INTEGER_TYPE_P(idx)) {
     id = NUM2INT(idx);
   } else if (SYMBOL_P(idx)) {
-    const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
-    std::map<std::string, int>::const_iterator search = groups.find(rb_id2name(SYM2ID(idx)));
+    const auto& groups = p->pattern->NamedCapturingGroups();
+    auto search = groups.find(rb_id2name(SYM2ID(idx)));
 
     if (search != groups.end()) {
       id = search->second;
     } else {
-      return NULL;
+      return nullptr;
     }
   } else {
     StringValue(idx);
 
-    const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
-    std::map<std::string, int>::const_iterator search = groups.find(std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)));
+    const auto& groups = p->pattern->NamedCapturingGroups();
+    auto search = groups.find(std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)));
 
     if (search != groups.end()) {
       id = search->second;
     } else {
-      return NULL;
+      return nullptr;
     }
   }
 
   if (id >= 0 && id < m->number_of_matches) {
     re2::StringPiece *match = &m->matches[id];
 
-    if (!match->empty()) {
+    if (match->data() != nullptr) {
       return match;
     }
   }
 
-  return NULL;
+  return nullptr;
 }
 
 /*
@@ -458,14 +685,12 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
  *
  * @return [Integer] the number of elements
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.size   #=> 2
  *   m.length #=> 2
  */
 static VALUE re2_matchdata_size(const VALUE self) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return INT2FIX(m->number_of_matches);
 }
@@ -477,17 +702,15 @@ static VALUE re2_matchdata_size(const VALUE self) {
  * @return [Integer, nil] the offset of the start of the match or `nil` if
  *   there is no such submatch
  * @example
- *   m = RE2::Regexp.new('ob (\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('ob (\d+)').partial_match("bob 123")
  *   m.begin(0) #=> 1
  *   m.begin(1) #=> 4
  */
 static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
-  if (match == NULL) {
+  if (match == nullptr) {
     return Qnil;
   } else {
     long offset = match->data() - RSTRING_PTR(m->text);
@@ -504,17 +727,15 @@ static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
  * @return [Integer, nil] the offset of the character following the end of the
  *   match or `nil` if there is no such match
  * @example
- *   m = RE2::Regexp.new('ob (\d+) b').match("bob 123 bob")
+ *   m = RE2::Regexp.new('ob (\d+) b').partial_match("bob 123 bob")
  *   m.end(0) #=> 9
  *   m.end(1) #=> 7
  */
 static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
-  re2_matchdata *m;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
-  if (match == NULL) {
+  if (match == nullptr) {
     return Qnil;
   } else {
     long offset = (match->data() - RSTRING_PTR(m->text)) + match->size();
@@ -523,17 +744,129 @@ static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
   }
 }
 
+/*
+ * Returns the portion of the original string before the match.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [String] the portion of the original string before the match
+ * @example
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123 456")
+ *   m.pre_match #=> "bob "
+ */
+static VALUE re2_matchdata_pre_match(const VALUE self) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
+
+  re2::StringPiece *match = &m->matches[0];
+  if (match->data() == nullptr) {
+    return Qnil;
+  }
+
+  long offset = match->data() - RSTRING_PTR(m->text);
+
+  return encoded_str_new(RSTRING_PTR(m->text), offset,
+      p->pattern->options().encoding());
+}
+
+/*
+ * Returns the portion of the original string after the match.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [String] the portion of the original string after the match
+ * @example
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123 456")
+ *   m.post_match #=> " 456"
+ */
+static VALUE re2_matchdata_post_match(const VALUE self) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
+
+  re2::StringPiece *match = &m->matches[0];
+  if (match->data() == nullptr) {
+    return Qnil;
+  }
+
+  long start = (match->data() - RSTRING_PTR(m->text)) + match->size();
+  long remaining = RSTRING_LEN(m->text) - start;
+
+  return encoded_str_new(RSTRING_PTR(m->text) + start, remaining,
+      p->pattern->options().encoding());
+}
+
+/*
+ * Returns a two-element array containing the beginning and ending offsets of
+ * the nth match.
+ *
+ * @param [Integer, String, Symbol] n the name or number of the match
+ * @return [Array<Integer>, nil] a two-element array with the beginning and
+ *   ending offsets of the match or `nil` if there is no such match
+ * @example
+ *   m = RE2::Regexp.new('ob (\d+)').partial_match("bob 123")
+ *   m.offset(0) #=> [1, 7]
+ *   m.offset(1) #=> [4, 7]
+ */
+static VALUE re2_matchdata_offset(const VALUE self, VALUE n) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
+  if (match == nullptr) {
+    return Qnil;
+  }
+
+  long start = match->data() - RSTRING_PTR(m->text);
+  long end_pos = start + match->size();
+
+  VALUE array = rb_ary_new2(2);
+  rb_ary_push(array, LONG2NUM(rb_str_sublen(m->text, start)));
+  rb_ary_push(array, LONG2NUM(rb_str_sublen(m->text, end_pos)));
+
+  return array;
+}
+
+/*
+ * Returns the length of the nth match in characters. This is equivalent to
+ * `m[n].length` but without allocating a new string.
+ *
+ * @param [Integer, String, Symbol] n the name or number of the match
+ * @return [Integer, nil] the length of the match or `nil` if there is no such
+ *   match
+ * @example
+ *   m = RE2::Regexp.new('(?P<word>\w+) (?P<number>\d+)').partial_match("alice 123")
+ *   m.match_length(0)       #=> 9
+ *   m.match_length(1)       #=> 5
+ *   m.match_length(:number) #=> 3
+ */
+static VALUE re2_matchdata_match_length(const VALUE self, VALUE n) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  re2::StringPiece *match = re2_matchdata_find_match(n, self);
+  if (match == nullptr) {
+    return Qnil;
+  }
+
+  long start = match->data() - RSTRING_PTR(m->text);
+  long end_pos = start + match->size();
+  long char_len = rb_str_sublen(m->text, end_pos) - rb_str_sublen(m->text, start);
+
+  return LONG2NUM(char_len);
+}
+
 /*
  * Returns the {RE2::Regexp} used in the match.
  *
  * @return [RE2::Regexp] the regular expression used in the match
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.regexp #=> #<RE2::Regexp /(\d+)/>
  */
 static VALUE re2_matchdata_regexp(const VALUE self) {
-  re2_matchdata *m;
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
 
   return m->regexp;
 }
@@ -547,8 +880,7 @@ static VALUE re2_matchdata_regexp(const VALUE self) {
  *   c.regexp #=> #<RE2::Regexp /(\d+)/>
  */
 static VALUE re2_scanner_regexp(const VALUE self) {
-  re2_scanner *c;
-  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  re2_scanner *c = unwrap_re2_scanner(self);
 
   return c->regexp;
 }
@@ -569,21 +901,18 @@ static VALUE re2_regexp_allocate(VALUE klass) {
  *
  * @return [Array<String, nil>] the array of matches
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.to_a #=> ["123", "123"]
  */
 static VALUE re2_matchdata_to_a(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   VALUE array = rb_ary_new2(m->number_of_matches);
   for (int i = 0; i < m->number_of_matches; ++i) {
     re2::StringPiece *match = &m->matches[i];
 
-    if (match->empty()) {
+    if (match->data() == nullptr) {
       rb_ary_push(array, Qnil);
     } else {
       rb_ary_push(array, encoded_str_new(match->data(), match->size(),
@@ -595,18 +924,15 @@ static VALUE re2_matchdata_to_a(const VALUE self) {
 }
 
 static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   if (nth < 0 || nth >= m->number_of_matches) {
     return Qnil;
   } else {
     re2::StringPiece *match = &m->matches[nth];
 
-    if (match->empty()) {
+    if (match->data() == nullptr) {
       return Qnil;
     } else {
       return encoded_str_new(match->data(), match->size(),
@@ -616,14 +942,11 @@ static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
 }
 
 static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
-
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
-  std::map<std::string, int>::const_iterator search = groups.find(name);
+  const auto& groups = p->pattern->NamedCapturingGroups();
+  auto search = groups.find(name);
 
   if (search != groups.end()) {
     return re2_matchdata_nth_match(search->second, self);
@@ -645,7 +968,7 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [Integer] index the index of the match to fetch
  *   @return [String, nil] the specified match or `nil` if it isn't present
  *   @example
- *     m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *     m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *     m[0] #=> "123"
  *
  * @overload [](start, length)
@@ -655,7 +978,7 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [Integer] length the number of elements to fetch
  *   @return [Array<String, nil>] the specified matches
  *   @example
- *     m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *     m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *     m[0, 1] #=> ["123"]
  *
  * @overload [](range)
@@ -664,8 +987,8 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [Range] range the range of match indexes to fetch
  *   @return [Array<String, nil>] the specified matches
  *   @example
- *     m = RE2::Regexp.new('(\d+)').match("bob 123")
- *     m[0..1] #=> "[123", "123"]
+ *     m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
+ *     m[0..1] #=> ["123", "123"]
  *
  * @overload [](name)
  *   Access a particular match by name.
@@ -673,7 +996,7 @@ static VALUE re2_matchdata_named_match(const std::string &name, const VALUE self
  *   @param [String, Symbol] name the name of the match to fetch
  *   @return [String, nil] the specific match or `nil` if it isn't present
  *   @example
- *     m = RE2::Regexp.new('(?P<number>\d+)').match("bob 123")
+ *     m = RE2::Regexp.new('(?P<number>\d+)').partial_match("bob 123")
  *     m["number"] #=> "123"
  *     m[:number]  #=> "123"
  */
@@ -697,6 +1020,9 @@ static VALUE re2_matchdata_aref(int argc, VALUE *argv, const VALUE self) {
  * Returns the entire matched string.
  *
  * @return [String] the entire matched string
+ * @example
+ *   m = RE2::Regexp.new('(?P<number>\d+)').partial_match("bob 123")
+ *   m.to_s #=> "123"
  */
 static VALUE re2_matchdata_to_s(const VALUE self) {
   return re2_matchdata_nth_match(0, self);
@@ -711,15 +1037,12 @@ static VALUE re2_matchdata_to_s(const VALUE self) {
  *
  * @return [String] a printable version of the match
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
  *   m.inspect #=> "#<RE2::MatchData \"123\" 1:\"123\">"
  */
 static VALUE re2_matchdata_inspect(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   std::ostringstream output;
   output << "#<RE2::MatchData";
@@ -749,7 +1072,7 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
 }
 
 /*
- * Returns the array of submatches for pattern matching.
+ * Returns the array of submatches.
  *
  * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
  * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
@@ -758,11 +1081,12 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
  *
  * @return [Array<String, nil>] the array of submatches
  * @example
- *   m = RE2::Regexp.new('(\d+)').match("bob 123")
+ *   m = RE2::Regexp.new('(\d+)').partial_match("bob 123")
+ *   m.captures    #=> ["123"]
  *   m.deconstruct #=> ["123"]
  *
  * @example pattern matching
- *   case RE2::Regexp.new('(\d+) (\d+)').match("bob 123 456")
+ *   case RE2::Regexp.new('(\d+) (\d+)').partial_match("bob 123 456")
  *   in x, y
  *     puts "Matched #{x} #{y}"
  *   else
@@ -770,17 +1094,14 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
  *   end
  */
 static VALUE re2_matchdata_deconstruct(const VALUE self) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
   VALUE array = rb_ary_new2(m->number_of_matches - 1);
   for (int i = 1; i < m->number_of_matches; ++i) {
     re2::StringPiece *match = &m->matches[i];
 
-    if (match->empty()) {
+    if (match->data() == nullptr) {
       rb_ary_push(array, Qnil);
     } else {
       rb_ary_push(array, encoded_str_new(match->data(), match->size(),
@@ -806,14 +1127,14 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
  * @param [Array<Symbol>, nil] keys an array of `Symbol` capturing group names
  *   or `nil` to return all names
  * @example
- *   m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+ *   m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
  *   m.deconstruct_keys(nil)                #=> {numbers: "123", letters: "abc"}
  *   m.deconstruct_keys([:numbers])         #=> {numbers: "123"}
  *   m.deconstruct_keys([:fruit])           #=> {}
  *   m.deconstruct_keys([:letters, :fruit]) #=> {letters: "abc"}
  *
  * @example pattern matching
- *   case RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').match('123 abc')
+ *   case RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
  *   in numbers:, letters:
  *     puts "Numbers: #{numbers}, letters: #{letters}"
  *   else
@@ -821,20 +1142,17 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
  *   end
  */
 static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys) {
-  re2_matchdata *m;
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
-  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
 
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  const auto& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
 
   if (NIL_P(keys)) {
-    for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+    for (const auto& group : groups) {
       rb_hash_aset(capturing_groups,
-          ID2SYM(rb_intern(it->first.data())),
-          re2_matchdata_nth_match(it->second, self));
+          ID2SYM(rb_intern2(group.first.data(), group.first.size())),
+          re2_matchdata_nth_match(group.second, self));
     }
   } else {
     Check_Type(keys, T_ARRAY);
@@ -844,7 +1162,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
         VALUE key = rb_ary_entry(keys, i);
         Check_Type(key, T_SYMBOL);
         const char *name = rb_id2name(SYM2ID(key));
-        std::map<std::string, int>::const_iterator search = groups.find(name);
+        auto search = groups.find(name);
 
         if (search != groups.end()) {
           rb_hash_aset(capturing_groups, key, re2_matchdata_nth_match(search->second, self));
@@ -858,6 +1176,151 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   return capturing_groups;
 }
 
+/*
+ * Returns a hash of capturing group names to matched strings.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @overload named_captures
+ *   Returns a hash with string keys.
+ *
+ *   @return [Hash] a hash of capturing group names to matching strings
+ *   @example
+ *     m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
+ *     m.named_captures #=> {"numbers" => "123", "letters" => "abc"}
+ *
+ * @overload named_captures(symbolize_names:)
+ *   Returns a hash with string or symbol keys.
+ *
+ *   @param [Boolean] symbolize_names whether to return group names as symbols
+ *   @return [Hash] a hash of capturing group names to matching strings
+ *   @example
+ *     m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
+ *     m.named_captures
+ *     #=> {"numbers" => "123", "letters" => "abc"}
+ *     m.named_captures(symbolize_names: true) #=> {numbers: "123", letters: "abc"}
+ */
+static VALUE re2_matchdata_named_captures(int argc, VALUE *argv, const VALUE self) {
+  VALUE opts;
+  rb_scan_args(argc, argv, "0:", &opts);
+
+  bool symbolize = false;
+  if (!NIL_P(opts)) {
+    VALUE sym = rb_hash_aref(opts, ID2SYM(id_symbolize_names));
+    symbolize = RTEST(sym);
+  }
+
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+  re2_pattern *p = unwrap_re2_regexp(m->regexp);
+
+  const auto& groups = p->pattern->NamedCapturingGroups();
+  VALUE result = rb_hash_new();
+
+  for (const auto& group : groups) {
+    VALUE key;
+    if (symbolize) {
+      key = ID2SYM(rb_intern2(group.first.data(), group.first.size()));
+    } else {
+      key = encoded_str_new(group.first.data(), group.first.size(),
+              p->pattern->options().encoding());
+    }
+    rb_hash_aset(result, key, re2_matchdata_nth_match(group.second, self));
+  }
+
+  return result;
+}
+
+/*
+ * Returns an array of names of named capturing groups. Names are returned in
+ * alphabetical order rather than definition order, as RE2 stores named groups
+ * internally in a sorted map.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @return [Array<String>] an array of names of named capturing groups
+ * @example
+ *   m = RE2::Regexp.new('(?P<numbers>\d+) (?P<letters>[a-zA-Z]+)').partial_match('123 abc')
+ *   m.names #=> ["letters", "numbers"]
+ */
+static VALUE re2_matchdata_names(const VALUE self) {
+  re2_matchdata *m = unwrap_re2_matchdata(self);
+
+  return re2_regexp_names(m->regexp);
+}
+
+/*
+ * Returns an array of match values at the given indices or names.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @param [Integer, String, Symbol] indexes the indices or names of
+ *   the matches to fetch
+ * @return [Array<String, nil>] the values at the given indices or names
+ * @example
+ *   m = RE2::Regexp.new('(?P<a>\d+) (?P<b>\d+)').partial_match("123 456")
+ *   m.values_at(1, 2)   #=> ["123", "456"]
+ *   m.values_at(:a, :b) #=> ["123", "456"]
+ *   m.values_at(1, :b)  #=> ["123", "456"]
+ */
+static VALUE re2_matchdata_values_at(int argc, VALUE *argv, const VALUE self) {
+  unwrap_re2_matchdata(self);
+
+  VALUE result = rb_ary_new2(argc);
+
+  for (int i = 0; i < argc; ++i) {
+    VALUE idx = argv[i];
+
+    if (TYPE(idx) == T_STRING) {
+      rb_ary_push(result, re2_matchdata_named_match(
+            std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)), self));
+    } else if (SYMBOL_P(idx)) {
+      rb_ary_push(result, re2_matchdata_named_match(
+            rb_id2name(SYM2ID(idx)), self));
+    } else {
+      rb_ary_push(result, re2_matchdata_nth_match(NUM2INT(idx), self));
+    }
+  }
+
+  return result;
+}
+
+static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
+  re2_matchdata *self_m;
+  re2_matchdata *other_m = unwrap_re2_matchdata(other);
+
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, self_m);
+
+  if (self_m->matches) {
+    delete[] self_m->matches;
+    self_m->matches = nullptr;
+  }
+
+  self_m->number_of_matches = other_m->number_of_matches;
+  RB_OBJ_WRITE(self, &self_m->regexp, other_m->regexp);
+  RB_OBJ_WRITE(self, &self_m->text, other_m->text);
+
+  if (other_m->matches) {
+    self_m->matches = new(std::nothrow) re2::StringPiece[other_m->number_of_matches];
+    if (self_m->matches == nullptr) {
+      rb_raise(rb_eNoMemError,
+               "not enough memory to allocate StringPiece for matches");
+    }
+    for (int i = 0; i < other_m->number_of_matches; ++i) {
+      self_m->matches[i] = other_m->matches[i];
+    }
+  } else {
+    self_m->matches = nullptr;
+  }
+
+  return self;
+}
+
 /*
  * Shorthand to compile a new {RE2::Regexp}.
  *
@@ -913,6 +1376,13 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 
   TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
+  rb_check_frozen(self);
+
+  if (p->pattern) {
+    delete p->pattern;
+    p->pattern = nullptr;
+  }
+
   if (RTEST(options)) {
     RE2::Options re2_options;
     parse_re2_options(&re2_options, options);
@@ -924,10 +1394,36 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
         re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)));
   }
 
-  if (p->pattern == 0) {
+  if (p->pattern == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
   }
 
+  rb_obj_freeze(self);
+
+  return self;
+}
+
+static VALUE re2_regexp_initialize_copy(VALUE self, VALUE other) {
+  re2_pattern *self_p;
+  re2_pattern *other_p = unwrap_re2_regexp(other);
+
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, self_p);
+
+  rb_check_frozen(self);
+
+  if (self_p->pattern) {
+    delete self_p->pattern;
+    self_p->pattern = nullptr;
+  }
+
+  self_p->pattern = new(std::nothrow) RE2(other_p->pattern->pattern(),
+                                          other_p->pattern->options());
+  if (self_p->pattern == nullptr) {
+    rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
+  }
+
+  rb_obj_freeze(self);
+
   return self;
 }
 
@@ -945,9 +1441,7 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
  *   re2.inspect #=> "#<RE2::Regexp /woo?/>"
  */
 static VALUE re2_regexp_inspect(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   std::ostringstream output;
 
@@ -970,8 +1464,7 @@ static VALUE re2_regexp_inspect(const VALUE self) {
  *   re2.to_s #=> "woo?"
  */
 static VALUE re2_regexp_to_s(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return encoded_str_new(p->pattern->pattern().data(),
       p->pattern->pattern().size(),
@@ -987,8 +1480,7 @@ static VALUE re2_regexp_to_s(const VALUE self) {
  *   re2.ok? #=> true
  */
 static VALUE re2_regexp_ok(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->ok());
 }
@@ -1003,8 +1495,7 @@ static VALUE re2_regexp_ok(const VALUE self) {
  *   re2.utf8? #=> true
  */
 static VALUE re2_regexp_utf8(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8);
 }
@@ -1019,8 +1510,7 @@ static VALUE re2_regexp_utf8(const VALUE self) {
  *   re2.posix_syntax? #=> true
  */
 static VALUE re2_regexp_posix_syntax(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().posix_syntax());
 }
@@ -1035,8 +1525,7 @@ static VALUE re2_regexp_posix_syntax(const VALUE self) {
  *   re2.longest_match? #=> true
  */
 static VALUE re2_regexp_longest_match(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().longest_match());
 }
@@ -1051,8 +1540,7 @@ static VALUE re2_regexp_longest_match(const VALUE self) {
  *   re2.log_errors? #=> true
  */
 static VALUE re2_regexp_log_errors(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().log_errors());
 }
@@ -1066,8 +1554,7 @@ static VALUE re2_regexp_log_errors(const VALUE self) {
  *   re2.max_mem #=> 1024
  */
 static VALUE re2_regexp_max_mem(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->options().max_mem());
 }
@@ -1082,8 +1569,7 @@ static VALUE re2_regexp_max_mem(const VALUE self) {
  *   re2.literal? #=> true
  */
 static VALUE re2_regexp_literal(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().literal());
 }
@@ -1098,8 +1584,7 @@ static VALUE re2_regexp_literal(const VALUE self) {
  *   re2.never_nl? #=> true
  */
 static VALUE re2_regexp_never_nl(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().never_nl());
 }
@@ -1114,8 +1599,7 @@ static VALUE re2_regexp_never_nl(const VALUE self) {
  *   re2.case_sensitive? #=> true
  */
 static VALUE re2_regexp_case_sensitive(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().case_sensitive());
 }
@@ -1144,8 +1628,7 @@ static VALUE re2_regexp_case_insensitive(const VALUE self) {
  *   re2.perl_classes? #=> true
  */
 static VALUE re2_regexp_perl_classes(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().perl_classes());
 }
@@ -1160,8 +1643,7 @@ static VALUE re2_regexp_perl_classes(const VALUE self) {
  *   re2.word_boundary? #=> true
  */
 static VALUE re2_regexp_word_boundary(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().word_boundary());
 }
@@ -1176,8 +1658,7 @@ static VALUE re2_regexp_word_boundary(const VALUE self) {
  *   re2.one_line? #=> true
  */
 static VALUE re2_regexp_one_line(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return BOOL2RUBY(p->pattern->options().one_line());
 }
@@ -1189,8 +1670,7 @@ static VALUE re2_regexp_one_line(const VALUE self) {
  * @return [String, nil] the error string or `nil`
  */
 static VALUE re2_regexp_error(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1210,8 +1690,7 @@ static VALUE re2_regexp_error(const VALUE self) {
  * @return [String, nil] the offending portion of the regexp or `nil`
  */
 static VALUE re2_regexp_error_arg(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1230,8 +1709,7 @@ static VALUE re2_regexp_error_arg(const VALUE self) {
  * @return [Integer] the regexp "cost"
  */
 static VALUE re2_regexp_program_size(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->ProgramSize());
 }
@@ -1242,9 +1720,7 @@ static VALUE re2_regexp_program_size(const VALUE self) {
  * @return [Hash] the options
  */
 static VALUE re2_regexp_options(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
   VALUE options = rb_hash_new();
 
   rb_hash_aset(options, ID2SYM(id_utf8),
@@ -1294,8 +1770,7 @@ static VALUE re2_regexp_options(const VALUE self) {
  * @return [Integer] the number of capturing subpatterns
  */
 static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
-  re2_pattern *p;
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
 
   return INT2FIX(p->pattern->NumberOfCapturingGroups());
 }
@@ -1310,17 +1785,15 @@ static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
  * @return [Hash] a hash of names to capturing indices
  */
 static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
-  re2_pattern *p;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
-  const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
+  re2_pattern *p = unwrap_re2_regexp(self);
+  const auto& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
 
-  for (std::map<std::string, int>::const_iterator it = groups.begin(); it != groups.end(); ++it) {
+  for (const auto& group : groups) {
     rb_hash_aset(capturing_groups,
-        encoded_str_new(it->first.data(), it->first.size(),
+        encoded_str_new(group.first.data(), group.first.size(),
           p->pattern->options().encoding()),
-        INT2FIX(it->second));
+        INT2FIX(group.second));
   }
 
   return capturing_groups;
@@ -1415,14 +1888,15 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 
   rb_scan_args(argc, argv, "11", &text, &options);
 
-  /* Ensure text is a string. */
+  /* Coerce and freeze text to prevent mutation. */
   StringValue(text);
+  text = rb_str_new_frozen(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  p = unwrap_re2_regexp(self);
 
   int n;
-  int startpos = 0;
-  int endpos = RSTRING_LEN(text);
+  size_t startpos = 0;
+  size_t endpos = RSTRING_LEN(text);
   RE2::Anchor anchor = RE2::UNANCHORED;
 
   if (RTEST(options)) {
@@ -1440,11 +1914,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
       VALUE endpos_option = rb_hash_aref(options, ID2SYM(id_endpos));
       if (!NIL_P(endpos_option)) {
 #ifdef HAVE_ENDPOS_ARGUMENT
-        endpos = NUM2INT(endpos_option);
+        ssize_t endpos_value = NUM2SSIZET(endpos_option);
 
-        if (endpos < 0) {
+        if (endpos_value < 0) {
           rb_raise(rb_eArgError, "endpos should be >= 0");
         }
+
+        endpos = static_cast<size_t>(endpos_value);
 #else
         rb_raise(re2_eRegexpUnsupportedError, "current version of RE2::Match() does not support endpos argument");
 #endif
@@ -1483,11 +1959,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 
       VALUE startpos_option = rb_hash_aref(options, ID2SYM(id_startpos));
       if (!NIL_P(startpos_option)) {
-        startpos = NUM2INT(startpos_option);
+        ssize_t startpos_value = NUM2SSIZET(startpos_option);
 
-        if (startpos < 0) {
+        if (startpos_value < 0) {
           rb_raise(rb_eArgError, "startpos should be >= 0");
         }
+
+        startpos = static_cast<size_t>(startpos_value);
       }
     }
   } else {
@@ -1502,16 +1980,18 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
     rb_raise(rb_eArgError, "startpos should be <= endpos");
   }
 
-  if (n == 0) {
-#ifdef HAVE_ENDPOS_ARGUMENT
-    bool matched = p->pattern->Match(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
-        startpos, endpos, anchor, 0, 0);
-#else
-    bool matched = p->pattern->Match(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
-        startpos, anchor, 0, 0);
+#ifndef HAVE_ENDPOS_ARGUMENT
+  /* Old RE2's Match() takes int startpos. Reject values that would overflow. */
+  if (startpos > INT_MAX) {
+    rb_raise(rb_eRangeError, "startpos should be <= %d", INT_MAX);
+  }
 #endif
+
+  if (n == 0) {
+    bool matched = re2_match_without_gvl(
+        p->pattern, text, startpos, endpos, anchor, 0, 0);
+    RB_GC_GUARD(text);
+
     return BOOL2RUBY(matched);
   } else {
     if (n == INT_MAX) {
@@ -1522,22 +2002,15 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
     n += 1;
 
     re2::StringPiece *matches = new(std::nothrow) re2::StringPiece[n];
-    if (matches == 0) {
+    if (matches == nullptr) {
       rb_raise(rb_eNoMemError,
                "not enough memory to allocate StringPieces for matches");
     }
 
-    text = rb_str_new_frozen(text);
+    bool matched = re2_match_without_gvl(
+        p->pattern, text, startpos, endpos, anchor, matches, n);
+    RB_GC_GUARD(text);
 
-#ifdef HAVE_ENDPOS_ARGUMENT
-    bool matched = p->pattern->Match(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
-        startpos, endpos, anchor, matches, n);
-#else
-    bool matched = p->pattern->Match(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
-        startpos, anchor, matches, n);
-#endif
     if (matched) {
       VALUE matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
       TypedData_Get_Struct(matchdata, re2_matchdata, &re2_matchdata_data_type, m);
@@ -1561,19 +2034,20 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L413-L427
  * `PartialMatch`}.
  *
+ * @param [String] text the text to search
  * @return [Boolean] whether the match was successful
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
-  re2_pattern *p;
-
-  /* Ensure text is a string. */
   StringValue(text);
+  text = rb_str_new_frozen(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
+  bool matched = re2_match_without_gvl(
+      p->pattern, text, 0, RSTRING_LEN(text), RE2::UNANCHORED, 0, 0);
+  RB_GC_GUARD(text);
 
-  return BOOL2RUBY(RE2::PartialMatch(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
+  return BOOL2RUBY(matched);
 }
 
 /*
@@ -1581,19 +2055,20 @@ static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
  * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L376-L411
  * `FullMatch`}.
  *
+ * @param [String] text the text to search
  * @return [Boolean] whether the match was successful
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_full_match_p(const VALUE self, VALUE text) {
-  re2_pattern *p;
-
-  /* Ensure text is a string. */
   StringValue(text);
+  text = rb_str_new_frozen(text);
 
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
+  re2_pattern *p = unwrap_re2_regexp(self);
+  bool matched = re2_match_without_gvl(
+      p->pattern, text, 0, RSTRING_LEN(text), RE2::ANCHOR_BOTH, 0, 0);
+  RB_GC_GUARD(text);
 
-  return BOOL2RUBY(RE2::FullMatch(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)), *p->pattern));
+  return BOOL2RUBY(matched);
 }
 
 /*
@@ -1609,21 +2084,19 @@ static VALUE re2_regexp_full_match_p(const VALUE self, VALUE text) {
  *   #=> #<RE2::Scanner:0x0000000000000001>
  */
 static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
-  /* Ensure text is a string. */
   StringValue(text);
+  text = rb_str_new_frozen(text);
 
-  re2_pattern *p;
+  re2_pattern *p = unwrap_re2_regexp(self);
   re2_scanner *c;
-
-  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
   VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
   TypedData_Get_Struct(scanner, re2_scanner, &re2_scanner_data_type, c);
 
   RB_OBJ_WRITE(scanner, &c->regexp, self);
-  RB_OBJ_WRITE(scanner, &c->text, rb_str_new_frozen(text));
+  RB_OBJ_WRITE(scanner, &c->text, text);
   c->input = new(std::nothrow) re2::StringPiece(
       RSTRING_PTR(c->text), RSTRING_LEN(c->text));
-  if (c->input == 0) {
+  if (c->input == nullptr) {
     rb_raise(rb_eNoMemError,
              "not enough memory to allocate StringPiece for input");
   }
@@ -1675,40 +2148,59 @@ static VALUE re2_regexp_match_has_endpos_argument_p(VALUE) {
  * @raise [TypeError] if the given rewrite or pattern (if not provided as a
  *   {RE2::Regexp}) cannot be coerced to `String`s
  * @example
- *   RE2.Replace("hello there", "hello", "howdy") #=> "howdy there"
+ *   RE2.replace("hello there", "hello", "howdy") #=> "howdy there"
  *   re2 = RE2::Regexp.new("hel+o")
- *   RE2.Replace("hello there", re2, "yo")        #=> "yo there"
+ *   RE2.replace("hello there", re2, "yo")        #=> "yo there"
  */
-static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
+static VALUE re2_replace(VALUE, VALUE str, VALUE pattern,
     VALUE rewrite) {
-  /* Ensure rewrite is a string. */
-  StringValue(rewrite);
+  re2_pattern *p = nullptr;
 
-  re2_pattern *p;
-
-  /* Take a copy of str so it can be modified in-place by
-   * RE2::Replace.
+  /* Coerce and freeze all arguments before any C++ allocations so that any
+   * Ruby exceptions (via longjmp) cannot bypass C++ destructors and leak
+   * memory, and later coercions cannot mutate earlier strings.
    */
   StringValue(str);
+  str = rb_str_new_frozen(str);
+  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
+    p = unwrap_re2_regexp(pattern);
+  } else {
+    StringValue(pattern);
+    pattern = rb_str_new_frozen(pattern);
+  }
+  StringValue(rewrite);
+  rewrite = rb_str_new_frozen(rewrite);
+
+  /* Take a copy of str so it can be modified in-place by RE2::Replace. */
   std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
 
-  /* Do the replacement. */
-  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
-    RE2::Replace(&str_as_string, *p->pattern,
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
+  nogvl_replace_arg arg;
+  arg.str = &str_as_string;
+  if (p) {
+    arg.pattern = p->pattern;
+  } else {
+    arg.pattern = nullptr;
+    arg.string_pattern = re2::StringPiece(
+        RSTRING_PTR(pattern), RSTRING_LEN(pattern));
+  }
+  arg.rewrite = re2::StringPiece(
+      RSTRING_PTR(rewrite), RSTRING_LEN(rewrite));
+
+#ifdef _WIN32
+  nogvl_replace(&arg);
+#else
+  rb_thread_call_without_gvl(nogvl_replace, &arg, NULL, NULL);
+#endif
 
+  RB_GC_GUARD(rewrite);
+  RB_GC_GUARD(pattern);
+
+  if (p) {
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
   } else {
-    /* Ensure pattern is a string. */
-    StringValue(pattern);
-
-    RE2::Replace(&str_as_string,
-        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)),
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
-
-    return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
+    return encoded_str_new(str_as_string.data(), str_as_string.size(),
+        RE2::Options::EncodingUTF8);
   }
 }
 
@@ -1729,38 +2221,136 @@ static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
  * @return [String] the resulting string
  * @example
  *   re2 = RE2::Regexp.new("oo?")
- *   RE2.GlobalReplace("whoops-doops", re2, "e") #=> "wheps-deps"
- *   RE2.GlobalReplace("hello there", "e", "i")  #=> "hillo thiri"
+ *   RE2.global_replace("whoops-doops", re2, "e") #=> "wheps-deps"
+ *   RE2.global_replace("hello there", "e", "i")  #=> "hillo thiri"
  */
-static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
+static VALUE re2_global_replace(VALUE, VALUE str, VALUE pattern,
                                VALUE rewrite) {
-  /* Ensure rewrite is a string. */
+  re2_pattern *p = nullptr;
+
+  /* Coerce and freeze all arguments before any C++ allocations so that any
+   * Ruby exceptions (via longjmp) cannot bypass C++ destructors and leak
+   * memory, and later coercions cannot mutate earlier strings.
+   */
+  StringValue(str);
+  str = rb_str_new_frozen(str);
+  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
+    p = unwrap_re2_regexp(pattern);
+  } else {
+    StringValue(pattern);
+    pattern = rb_str_new_frozen(pattern);
+  }
   StringValue(rewrite);
+  rewrite = rb_str_new_frozen(rewrite);
 
   /* Take a copy of str so it can be modified in-place by
    * RE2::GlobalReplace.
    */
-  re2_pattern *p;
-  StringValue(str);
   std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
 
-  /* Do the replacement. */
-  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
-    RE2::GlobalReplace(&str_as_string, *p->pattern,
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
+  nogvl_replace_arg arg;
+  arg.str = &str_as_string;
+  if (p) {
+    arg.pattern = p->pattern;
+  } else {
+    arg.pattern = nullptr;
+    arg.string_pattern = re2::StringPiece(
+        RSTRING_PTR(pattern), RSTRING_LEN(pattern));
+  }
+  arg.rewrite = re2::StringPiece(
+      RSTRING_PTR(rewrite), RSTRING_LEN(rewrite));
 
+#ifdef _WIN32
+  nogvl_global_replace(&arg);
+#else
+  rb_thread_call_without_gvl(nogvl_global_replace, &arg, NULL, NULL);
+#endif
+
+  RB_GC_GUARD(rewrite);
+  RB_GC_GUARD(pattern);
+
+  if (p) {
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
         p->pattern->options().encoding());
   } else {
-    /* Ensure pattern is a string. */
+    return encoded_str_new(str_as_string.data(), str_as_string.size(),
+        RE2::Options::EncodingUTF8);
+  }
+}
+
+/*
+ * If `pattern` matches `text`, returns a copy of `rewrite` with substitutions
+ * using
+ * {https://github.com/google/re2/blob/bc0faab533e2b27b85b8ad312abf061e33ed6b5d/re2/re2.h#L499-L510
+ * `Extract`}. Non-matching portions of `text` are ignored.
+ *
+ * Note RE2 only supports UTF-8 and ISO-8859-1 encoding so strings will be
+ * returned in UTF-8 by default or ISO-8859-1 if the `:utf8` option for the
+ * {RE2::Regexp} is set to `false` (any other encoding's behaviour is undefined).
+ *
+ * @param [String] text the string from which to extract
+ * @param [String, RE2::Regexp] pattern a regexp matching the text
+ * @param [String] rewrite the rewrite string with `\1`-style substitutions
+ * @return [String, nil] the extracted string on a successful match or nil if
+ *   there is no match
+ * @raise [TypeError] if the given rewrite or pattern (if not provided as a
+ *   {RE2::Regexp}) cannot be coerced to `String`s
+ * @example
+ *   RE2.extract("alice@example.com", '(\w+)@(\w+)', '\2-\1')
+ *   #=> "example-alice"
+ *   RE2.extract("no match", '(\d+)', '\1') #=> nil
+ */
+static VALUE re2_extract(VALUE, VALUE text, VALUE pattern,
+    VALUE rewrite) {
+  re2_pattern *p = nullptr;
+
+  /* Coerce and freeze all arguments before any C++ allocations so that any
+   * Ruby exceptions (via longjmp) cannot bypass C++ destructors and leak
+   * memory, and later coercions cannot mutate earlier strings.
+   */
+  StringValue(text);
+  text = rb_str_new_frozen(text);
+  if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
+    p = unwrap_re2_regexp(pattern);
+  } else {
     StringValue(pattern);
+    pattern = rb_str_new_frozen(pattern);
+  }
+  StringValue(rewrite);
+  rewrite = rb_str_new_frozen(rewrite);
 
-    RE2::GlobalReplace(&str_as_string,
-        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)),
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
+  std::string out;
 
-    return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
+  nogvl_extract_arg arg;
+  arg.text = re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text));
+  if (p) {
+    arg.pattern = p->pattern;
+  } else {
+    arg.pattern = nullptr;
+    arg.string_pattern = re2::StringPiece(
+        RSTRING_PTR(pattern), RSTRING_LEN(pattern));
+  }
+  arg.rewrite = re2::StringPiece(
+      RSTRING_PTR(rewrite), RSTRING_LEN(rewrite));
+  arg.out = &out;
+  arg.extracted = false;
+
+#ifdef _WIN32
+  nogvl_extract(&arg);
+#else
+  rb_thread_call_without_gvl(nogvl_extract, &arg, NULL, NULL);
+#endif
+
+  RB_GC_GUARD(text);
+  RB_GC_GUARD(rewrite);
+  RB_GC_GUARD(pattern);
+
+  if (arg.extracted) {
+    return encoded_str_new(out.data(), out.size(),
+        p ? p->pattern->options().encoding()
+          : RE2::Options::EncodingUTF8);
+  } else {
+    return Qnil;
   }
 }
 
@@ -1775,9 +2365,12 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
  * @raise [TypeError] if the given unquoted string cannot be coerced to a `String`
  * @return [String] the escaped string
  * @example
- *   RE2::Regexp.escape("1.5-2.0?") #=> "1\.5\-2\.0\?"
+ *   RE2.escape("1.5-2.0?")         #=> "1\\.5\\-2\\.0\\?"
+ *   RE2.quote("1.5-2.0?")          #=> "1\\.5\\-2\\.0\\?"
+ *   RE2::Regexp.escape("1.5-2.0?") #=> "1\\.5\\-2\\.0\\?"
+ *   RE2::Regexp.quote("1.5-2.0?")  #=> "1\\.5\\-2\\.0\\?"
  */
-static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
+static VALUE re2_escape(VALUE, VALUE unquoted) {
   StringValue(unquoted);
 
   std::string quoted_string = RE2::QuoteMeta(
@@ -1787,7 +2380,7 @@ static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
 }
 
 static void re2_set_free(void *ptr) {
-  re2_set *s = reinterpret_cast<re2_set *>(ptr);
+  re2_set *s = static_cast<re2_set *>(ptr);
   if (s->set) {
     delete s->set;
   }
@@ -1795,7 +2388,7 @@ static void re2_set_free(void *ptr) {
 }
 
 static size_t re2_set_memsize(const void *ptr) {
-  const re2_set *s = reinterpret_cast<const re2_set *>(ptr);
+  const re2_set *s = static_cast<const re2_set *>(ptr);
   size_t size = sizeof(*s);
   if (s->set) {
     size += sizeof(*s->set);
@@ -1815,9 +2408,18 @@ static const rb_data_type_t re2_set_data_type = {
   0,
   // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
   // macro to update VALUE references, as to trigger write barriers.
-  RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+  RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE
 };
 
+static re2_set *unwrap_re2_set(VALUE self) {
+  re2_set *s;
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  if (!s->set) {
+    rb_raise(rb_eTypeError, "uninitialized RE2::Set");
+  }
+  return s;
+}
+
 static VALUE re2_set_allocate(VALUE klass) {
   re2_set *s;
   VALUE result = TypedData_Make_Struct(klass, re2_set, &re2_set_data_type, s);
@@ -1825,6 +2427,10 @@ static VALUE re2_set_allocate(VALUE klass) {
   return result;
 }
 
+static VALUE re2_set_initialize_copy(VALUE, VALUE) {
+  rb_raise(rb_eTypeError, "cannot copy RE2::Set");
+}
+
 /*
  * Returns a new {RE2::Set} object, a collection of patterns that can be
  * searched for simultaneously.
@@ -1895,8 +2501,15 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
     parse_re2_options(&re2_options, options);
   }
 
+  rb_check_frozen(self);
+
+  if (s->set) {
+    delete s->set;
+    s->set = nullptr;
+  }
+
   s->set = new(std::nothrow) RE2::Set(re2_options, re2_anchor);
-  if (s->set == 0) {
+  if (s->set == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2::Set object");
   }
 
@@ -1919,8 +2532,8 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
 static VALUE re2_set_add(VALUE self, VALUE pattern) {
   StringValue(pattern);
 
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
+  rb_check_frozen(self);
 
   int index;
   VALUE msg;
@@ -1951,10 +2564,16 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
  *   set.compile #=> true
  */
 static VALUE re2_set_compile(VALUE self) {
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
+  rb_check_frozen(self);
 
-  return BOOL2RUBY(s->set->Compile());
+  bool compiled = s->set->Compile();
+
+  if (compiled) {
+    rb_obj_freeze(self);
+  }
+
+  return BOOL2RUBY(compiled);
 }
 
 /*
@@ -1968,8 +2587,7 @@ static VALUE re2_set_compile(VALUE self) {
  */
 static VALUE re2_set_size(VALUE self) {
 #ifdef HAVE_SET_SIZE
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  re2_set *s = unwrap_re2_set(self);
 
   return INT2FIX(s->set->Size());
 #else
@@ -2052,8 +2670,9 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   rb_scan_args(argc, argv, "11", &str, &options);
 
   StringValue(str);
-  re2_set *s;
-  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
+  str = rb_str_new_frozen(str);
+
+  re2_set *s = unwrap_re2_set(self);
 
   if (RTEST(options)) {
     Check_Type(options, T_HASH);
@@ -2069,8 +2688,21 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   if (raise_exception) {
 #ifdef HAVE_ERROR_INFO_ARGUMENT
     RE2::Set::ErrorInfo e;
-    bool match_failed = !s->set->Match(
-        re2::StringPiece(RSTRING_PTR(str), RSTRING_LEN(str)), &v, &e);
+    nogvl_set_match_arg arg;
+    arg.set = s->set;
+    arg.text = re2::StringPiece(RSTRING_PTR(str), RSTRING_LEN(str));
+    arg.v = &v;
+    arg.error_info = &e;
+    arg.matched = false;
+
+#ifdef _WIN32
+    nogvl_set_match(&arg);
+#else
+    rb_thread_call_without_gvl(nogvl_set_match, &arg, NULL, NULL);
+#endif
+    RB_GC_GUARD(str);
+
+    bool match_failed = !arg.matched;
     VALUE result = rb_ary_new2(v.size());
 
     if (match_failed) {
@@ -2087,8 +2719,8 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
           rb_raise(re2_eSetMatchError, "Unknown RE2::Set::ErrorKind: %d", e.kind);
       }
     } else {
-      for (std::vector<int>::size_type i = 0; i < v.size(); ++i) {
-        rb_ary_push(result, INT2FIX(v[i]));
+      for (int index : v) {
+        rb_ary_push(result, INT2FIX(index));
       }
     }
 
@@ -2097,13 +2729,27 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
     rb_raise(re2_eSetUnsupportedError, "current version of RE2::Set::Match() does not output error information, :exception option can only be set to false");
 #endif
   } else {
-    bool matched = s->set->Match(
-        re2::StringPiece(RSTRING_PTR(str), RSTRING_LEN(str)), &v);
+    nogvl_set_match_arg arg;
+    arg.set = s->set;
+    arg.text = re2::StringPiece(RSTRING_PTR(str), RSTRING_LEN(str));
+    arg.v = &v;
+#ifdef HAVE_ERROR_INFO_ARGUMENT
+    arg.error_info = nullptr;
+#endif
+    arg.matched = false;
+
+#ifdef _WIN32
+    nogvl_set_match(&arg);
+#else
+    rb_thread_call_without_gvl(nogvl_set_match, &arg, NULL, NULL);
+#endif
+    RB_GC_GUARD(str);
+
     VALUE result = rb_ary_new2(v.size());
 
-    if (matched) {
-      for (std::vector<int>::size_type i = 0; i < v.size(); ++i) {
-        rb_ary_push(result, INT2FIX(v[i]));
+    if (arg.matched) {
+      for (int index : v) {
+        rb_ary_push(result, INT2FIX(index));
       }
     }
 
@@ -2112,6 +2758,8 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
 }
 
 extern "C" void Init_re2(void) {
+  rb_ext_ractor_safe(true);
+
   re2_mRE2 = rb_define_module("RE2");
   re2_cRegexp = rb_define_class_under(re2_mRE2, "Regexp", rb_cObject);
   re2_eRegexpUnsupportedError = rb_define_class_under(re2_cRegexp,
@@ -2147,6 +2795,14 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_matchdata_begin), 1);
   rb_define_method(re2_cMatchData, "end",
       RUBY_METHOD_FUNC(re2_matchdata_end), 1);
+  rb_define_method(re2_cMatchData, "pre_match",
+      RUBY_METHOD_FUNC(re2_matchdata_pre_match), 0);
+  rb_define_method(re2_cMatchData, "post_match",
+      RUBY_METHOD_FUNC(re2_matchdata_post_match), 0);
+  rb_define_method(re2_cMatchData, "offset",
+      RUBY_METHOD_FUNC(re2_matchdata_offset), 1);
+  rb_define_method(re2_cMatchData, "match_length",
+      RUBY_METHOD_FUNC(re2_matchdata_match_length), 1);
   rb_define_method(re2_cMatchData, "[]", RUBY_METHOD_FUNC(re2_matchdata_aref),
       -1);
   rb_define_method(re2_cMatchData, "to_s",
@@ -2155,8 +2811,18 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_matchdata_inspect), 0);
   rb_define_method(re2_cMatchData, "deconstruct",
       RUBY_METHOD_FUNC(re2_matchdata_deconstruct), 0);
+  rb_define_method(re2_cMatchData, "captures",
+      RUBY_METHOD_FUNC(re2_matchdata_deconstruct), 0);
+  rb_define_method(re2_cMatchData, "named_captures",
+      RUBY_METHOD_FUNC(re2_matchdata_named_captures), -1);
+  rb_define_method(re2_cMatchData, "names",
+      RUBY_METHOD_FUNC(re2_matchdata_names), 0);
+  rb_define_method(re2_cMatchData, "values_at",
+      RUBY_METHOD_FUNC(re2_matchdata_values_at), -1);
   rb_define_method(re2_cMatchData, "deconstruct_keys",
       RUBY_METHOD_FUNC(re2_matchdata_deconstruct_keys), 1);
+  rb_define_method(re2_cMatchData, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_matchdata_initialize_copy), 1);
 
   rb_define_method(re2_cScanner, "string",
       RUBY_METHOD_FUNC(re2_scanner_string), 0);
@@ -2168,11 +2834,15 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_scanner_scan), 0);
   rb_define_method(re2_cScanner, "rewind",
       RUBY_METHOD_FUNC(re2_scanner_rewind), 0);
+  rb_define_method(re2_cScanner, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_scanner_initialize_copy), 1);
 
   rb_define_singleton_method(re2_cRegexp, "match_has_endpos_argument?",
       RUBY_METHOD_FUNC(re2_regexp_match_has_endpos_argument_p), 0);
   rb_define_method(re2_cRegexp, "initialize",
       RUBY_METHOD_FUNC(re2_regexp_initialize), -1);
+  rb_define_method(re2_cRegexp, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_regexp_initialize_copy), 1);
   rb_define_method(re2_cRegexp, "ok?", RUBY_METHOD_FUNC(re2_regexp_ok), 0);
   rb_define_method(re2_cRegexp, "error", RUBY_METHOD_FUNC(re2_regexp_error),
       0);
@@ -2186,6 +2856,10 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_regexp_number_of_capturing_groups), 0);
   rb_define_method(re2_cRegexp, "named_capturing_groups",
       RUBY_METHOD_FUNC(re2_regexp_named_capturing_groups), 0);
+  rb_define_method(re2_cRegexp, "named_captures",
+      RUBY_METHOD_FUNC(re2_regexp_named_capturing_groups), 0);
+  rb_define_method(re2_cRegexp, "names",
+      RUBY_METHOD_FUNC(re2_regexp_names), 0);
   rb_define_method(re2_cRegexp, "match", RUBY_METHOD_FUNC(re2_regexp_match),
       -1);
   rb_define_method(re2_cRegexp, "match?", RUBY_METHOD_FUNC(re2_regexp_match_p),
@@ -2240,22 +2914,34 @@ extern "C" void Init_re2(void) {
       RUBY_METHOD_FUNC(re2_set_size_p), 0);
   rb_define_method(re2_cSet, "initialize",
       RUBY_METHOD_FUNC(re2_set_initialize), -1);
+  rb_define_method(re2_cSet, "initialize_copy",
+      RUBY_METHOD_FUNC(re2_set_initialize_copy), 1);
   rb_define_method(re2_cSet, "add", RUBY_METHOD_FUNC(re2_set_add), 1);
   rb_define_method(re2_cSet, "compile", RUBY_METHOD_FUNC(re2_set_compile), 0);
   rb_define_method(re2_cSet, "match", RUBY_METHOD_FUNC(re2_set_match), -1);
   rb_define_method(re2_cSet, "size", RUBY_METHOD_FUNC(re2_set_size), 0);
   rb_define_method(re2_cSet, "length", RUBY_METHOD_FUNC(re2_set_size), 0);
 
+  rb_define_module_function(re2_mRE2, "replace",
+      RUBY_METHOD_FUNC(re2_replace), 3);
   rb_define_module_function(re2_mRE2, "Replace",
-      RUBY_METHOD_FUNC(re2_Replace), 3);
+      RUBY_METHOD_FUNC(re2_replace), 3);
+  rb_define_module_function(re2_mRE2, "global_replace",
+      RUBY_METHOD_FUNC(re2_global_replace), 3);
   rb_define_module_function(re2_mRE2, "GlobalReplace",
-      RUBY_METHOD_FUNC(re2_GlobalReplace), 3);
+      RUBY_METHOD_FUNC(re2_global_replace), 3);
+  rb_define_module_function(re2_mRE2, "extract",
+      RUBY_METHOD_FUNC(re2_extract), 3);
   rb_define_module_function(re2_mRE2, "QuoteMeta",
-      RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+      RUBY_METHOD_FUNC(re2_escape), 1);
+  rb_define_module_function(re2_mRE2, "escape",
+      RUBY_METHOD_FUNC(re2_escape), 1);
+  rb_define_module_function(re2_mRE2, "quote",
+      RUBY_METHOD_FUNC(re2_escape), 1);
   rb_define_singleton_method(re2_cRegexp, "escape",
-      RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+      RUBY_METHOD_FUNC(re2_escape), 1);
   rb_define_singleton_method(re2_cRegexp, "quote",
-      RUBY_METHOD_FUNC(re2_QuoteMeta), 1);
+      RUBY_METHOD_FUNC(re2_escape), 1);
 
   // (see RE2::Regexp#initialize)
   rb_define_singleton_method(re2_cRegexp, "compile",
@@ -2283,4 +2969,5 @@ extern "C" void Init_re2(void) {
   id_submatches = rb_intern("submatches");
   id_startpos = rb_intern("startpos");
   id_endpos = rb_intern("endpos");
+  id_symbolize_names = rb_intern("symbolize_names");
 }