re2 2.26.2 → 2.28.0

data/ext/re2/re2.cc

@@ -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)
 
@@ -41,8 +42,142 @@ typedef struct {
 
 typedef struct {
   RE2::Set *set;
+  bool compiled;
 } 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;
+}
+
+static std::string group_name(VALUE key) {
+  VALUE str = SYMBOL_P(key) ? rb_sym2str(key) : key;
+  str = rb_str_conv_enc(str, rb_enc_get(str), rb_utf8_encoding());
+
+  return std::string(RSTRING_PTR(str), RSTRING_LEN(str));
+}
+
 VALUE re2_mRE2, re2_cRegexp, re2_cMatchData, re2_cScanner, re2_cSet,
       re2_eSetMatchError, re2_eSetUnsupportedError, re2_eRegexpUnsupportedError;
 
@@ -126,7 +261,7 @@ 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
@@ -136,12 +271,12 @@ static void re2_matchdata_mark(void *ptr) {
 }
 
 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;
   }
@@ -149,7 +284,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;
@@ -174,7 +309,7 @@ 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
@@ -184,12 +319,12 @@ static void re2_scanner_mark(void *ptr) {
 }
 
 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;
   }
@@ -197,7 +332,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);
@@ -222,7 +357,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;
   }
@@ -230,7 +365,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);
@@ -250,7 +385,7 @@ 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) {
@@ -285,9 +420,9 @@ static re2_scanner *unwrap_re2_scanner(VALUE self) {
  * 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).
+ * Note RE2 stores capturing group names as UTF-8, even if the {RE2::Regexp}
+ * sets the `:utf8` option to false so strings will always be returned in
+ * UTF-8.
  *
  * @return [Array<String>] an array of names of named capturing groups
  * @example
@@ -300,9 +435,7 @@ static VALUE re2_regexp_names(const VALUE self) {
   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()));
+    rb_ary_push(names, rb_utf8_str_new(group.first.data(), group.first.size()));
   }
 
   return names;
@@ -396,6 +529,8 @@ static VALUE re2_scanner_rewind(VALUE self) {
 }
 
 static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
+  if (self == other) return self;
+
   re2_scanner *self_c;
   re2_scanner *other_c = unwrap_re2_scanner(other);
 
@@ -519,20 +654,13 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
 
   if (RB_INTEGER_TYPE_P(idx)) {
     id = NUM2INT(idx);
-  } else if (SYMBOL_P(idx)) {
-    const auto& groups = p->pattern->NamedCapturingGroups();
-    auto search = groups.find(rb_id2name(SYM2ID(idx)));
-
-    if (search != groups.end()) {
-      id = search->second;
-    } else {
-      return nullptr;
-    }
   } else {
-    StringValue(idx);
+    if (!SYMBOL_P(idx)) {
+      StringValue(idx);
+    }
 
     const auto& groups = p->pattern->NamedCapturingGroups();
-    auto search = groups.find(std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)));
+    auto search = groups.find(group_name(idx));
 
     if (search != groups.end()) {
       id = search->second;
@@ -877,11 +1005,8 @@ static VALUE re2_matchdata_aref(int argc, VALUE *argv, const VALUE self) {
   VALUE idx, rest;
   rb_scan_args(argc, argv, "11", &idx, &rest);
 
-  if (TYPE(idx) == T_STRING) {
-    return re2_matchdata_named_match(
-        std::string(RSTRING_PTR(idx), RSTRING_LEN(idx)), self);
-  } else if (SYMBOL_P(idx)) {
-    return re2_matchdata_named_match(rb_id2name(SYM2ID(idx)), self);
+  if (TYPE(idx) == T_STRING || SYMBOL_P(idx)) {
+    return re2_matchdata_named_match(group_name(idx), self);
   } else if (!NIL_P(rest) || !RB_INTEGER_TYPE_P(idx) || NUM2INT(idx) < 0) {
     return rb_ary_aref(argc, argv, re2_matchdata_to_a(self));
   } else {
@@ -995,6 +1120,7 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
  * 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).
+ * Capturing group names will always be returned in UTF-8.
  *
  * @return [Hash] a hash of capturing group names to submatches
  * @param [Array<Symbol>, nil] keys an array of `Symbol` capturing group names
@@ -1024,7 +1150,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   if (NIL_P(keys)) {
     for (const auto& group : groups) {
       rb_hash_aset(capturing_groups,
-          ID2SYM(rb_intern2(group.first.data(), group.first.size())),
+          rb_str_intern(rb_utf8_str_new(group.first.data(), group.first.size())),
           re2_matchdata_nth_match(group.second, self));
     }
   } else {
@@ -1034,8 +1160,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
       for (int i = 0; i < RARRAY_LEN(keys); ++i) {
         VALUE key = rb_ary_entry(keys, i);
         Check_Type(key, T_SYMBOL);
-        const char *name = rb_id2name(SYM2ID(key));
-        auto search = groups.find(name);
+        auto search = groups.find(group_name(key));
 
         if (search != groups.end()) {
           rb_hash_aset(capturing_groups, key, re2_matchdata_nth_match(search->second, self));
@@ -1055,6 +1180,7 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
  * 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).
+ * Capturing group names will always be returned in UTF-8.
  *
  * @overload named_captures
  *   Returns a hash with string keys.
@@ -1092,12 +1218,9 @@ static VALUE re2_matchdata_named_captures(int argc, VALUE *argv, const VALUE sel
   VALUE result = rb_hash_new();
 
   for (const auto& group : groups) {
-    VALUE key;
+    VALUE key = rb_utf8_str_new(group.first.data(), group.first.size());
     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());
+      key = rb_str_intern(key);
     }
     rb_hash_aset(result, key, re2_matchdata_nth_match(group.second, self));
   }
@@ -1110,9 +1233,9 @@ static VALUE re2_matchdata_named_captures(int argc, VALUE *argv, const VALUE sel
  * 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).
+ * Note RE2 stores capturing group names as UTF-8, even if the {RE2::Regexp}
+ * sets the `:utf8` option to false so strings will always be returned in
+ * UTF-8.
  *
  * @return [Array<String>] an array of names of named capturing groups
  * @example
@@ -1149,12 +1272,8 @@ static VALUE re2_matchdata_values_at(int argc, VALUE *argv, const VALUE self) {
   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));
+    if (TYPE(idx) == T_STRING || SYMBOL_P(idx)) {
+      rb_ary_push(result, re2_matchdata_named_match(group_name(idx), self));
     } else {
       rb_ary_push(result, re2_matchdata_nth_match(NUM2INT(idx), self));
     }
@@ -1164,6 +1283,8 @@ static VALUE re2_matchdata_values_at(int argc, VALUE *argv, const VALUE self) {
 }
 
 static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
+  if (self == other) return self;
+
   re2_matchdata *self_m;
   re2_matchdata *other_m = unwrap_re2_matchdata(other);
 
@@ -1249,26 +1370,23 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 
   TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
-  if (p->pattern) {
-    delete p->pattern;
-    p->pattern = nullptr;
-  }
+  RE2::Options re2_options;
 
   if (RTEST(options)) {
-    RE2::Options re2_options;
     parse_re2_options(&re2_options, options);
-
-    p->pattern = new(std::nothrow) RE2(
-        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)), re2_options);
-  } else {
-    p->pattern = new(std::nothrow) RE2(
-        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)));
   }
 
+  rb_check_frozen(self);
+
+  p->pattern = new(std::nothrow) RE2(
+      re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)), re2_options);
+
   if (p->pattern == nullptr) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
   }
 
+  rb_obj_freeze(self);
+
   return self;
 }
 
@@ -1278,6 +1396,8 @@ static VALUE re2_regexp_initialize_copy(VALUE self, VALUE 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;
@@ -1289,6 +1409,8 @@ static VALUE re2_regexp_initialize_copy(VALUE self, VALUE other) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
   }
 
+  rb_obj_freeze(self);
+
   return self;
 }
 
@@ -1643,9 +1765,9 @@ static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
 /*
  * Returns a hash of names to capturing indices of groups.
  *
- * 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).
+ * Note RE2 stores capturing group names as UTF-8, even if the {RE2::Regexp}
+ * sets the `:utf8` option to false so strings will always be returned in
+ * UTF-8.
  *
  * @return [Hash] a hash of names to capturing indices
  */
@@ -1656,8 +1778,7 @@ static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
 
   for (const auto& group : groups) {
     rb_hash_aset(capturing_groups,
-        encoded_str_new(group.first.data(), group.first.size(),
-          p->pattern->options().encoding()),
+        rb_utf8_str_new(group.first.data(), group.first.size()),
         INT2FIX(group.second));
   }
 
@@ -1753,8 +1874,9 @@ 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);
 
   p = unwrap_re2_regexp(self);
 
@@ -1852,15 +1974,10 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
 #endif
 
   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);
-#endif
+    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) {
@@ -1876,17 +1993,10 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
                "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);
@@ -1915,13 +2025,15 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
-  /* Ensure text is a string. */
   StringValue(text);
+  text = rb_str_new_frozen(text);
 
   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);
 }
 
 /*
@@ -1934,13 +2046,15 @@ static VALUE re2_regexp_match_p(const VALUE self, VALUE text) {
  * @raise [TypeError] if text cannot be coerced to a `String`
  */
 static VALUE re2_regexp_full_match_p(const VALUE self, VALUE text) {
-  /* Ensure text is a string. */
   StringValue(text);
+  text = rb_str_new_frozen(text);
 
   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);
 }
 
 /*
@@ -1956,8 +2070,8 @@ 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 = unwrap_re2_regexp(self);
   re2_scanner *c;
@@ -1965,7 +2079,7 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   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 == nullptr) {
@@ -2028,35 +2142,51 @@ static VALUE re2_replace(VALUE, VALUE str, VALUE pattern,
     VALUE rewrite) {
   re2_pattern *p = nullptr;
 
-  /* Coerce all arguments before any C++ allocations so that any Ruby
-   * exceptions (via longjmp) cannot bypass C++ destructors and leak memory.
+  /* 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.
-   */
+  /* 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. */
+  nogvl_replace_arg arg;
+  arg.str = &str_as_string;
   if (p) {
-    RE2::Replace(&str_as_string, *p->pattern,
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
+    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 {
-    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);
   }
 }
 
@@ -2084,35 +2214,53 @@ static VALUE re2_global_replace(VALUE, VALUE str, VALUE pattern,
                                VALUE rewrite) {
   re2_pattern *p = nullptr;
 
-  /* Coerce all arguments before any C++ allocations so that any Ruby
-   * exceptions (via longjmp) cannot bypass C++ destructors and leak memory.
+  /* 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.
    */
   std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
 
-  /* Do the replacement. */
+  nogvl_replace_arg arg;
+  arg.str = &str_as_string;
   if (p) {
-    RE2::GlobalReplace(&str_as_string, *p->pattern,
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
+    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 {
-    RE2::GlobalReplace(&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);
   }
 }
 
@@ -2142,46 +2290,53 @@ static VALUE re2_extract(VALUE, VALUE text, VALUE pattern,
     VALUE rewrite) {
   re2_pattern *p = nullptr;
 
-  /* Coerce all arguments before any C++ allocations so that any Ruby
-   * exceptions (via longjmp) cannot bypass C++ destructors and leak memory.
+  /* 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);
 
   std::string out;
-  bool extracted;
 
+  nogvl_extract_arg arg;
+  arg.text = re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text));
   if (p) {
-    extracted = RE2::Extract(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
-        *p->pattern,
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)),
-        &out);
-
-    if (extracted) {
-      return encoded_str_new(out.data(), out.size(),
-          p->pattern->options().encoding());
-    } else {
-      return Qnil;
-    }
+    arg.pattern = p->pattern;
   } else {
-    extracted = RE2::Extract(
-        re2::StringPiece(RSTRING_PTR(text), RSTRING_LEN(text)),
-        RE2(re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern))),
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)),
-        &out);
-
-    if (extracted) {
-      return encoded_str_new(out.data(), out.size(),
-          RE2::Options::EncodingUTF8);
-    } else {
-      return Qnil;
-    }
+    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;
   }
 }
 
@@ -2211,7 +2366,7 @@ static VALUE re2_escape(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;
   }
@@ -2219,7 +2374,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);
@@ -2239,7 +2394,7 @@ 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) {
@@ -2332,9 +2487,14 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
     parse_re2_options(&re2_options, options);
   }
 
+  rb_check_frozen(self);
+
+  /* Prevent re-initialisation: #match releases the GVL while holding a
+   * pointer to s->set, so replacing s->set from another thread would free
+   * the object out from under a concurrent match.
+   */
   if (s->set) {
-    delete s->set;
-    s->set = nullptr;
+    rb_raise(rb_eTypeError, "already initialized RE2::Set");
   }
 
   s->set = new(std::nothrow) RE2::Set(re2_options, re2_anchor);
@@ -2362,6 +2522,7 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
   StringValue(pattern);
 
   re2_set *s = unwrap_re2_set(self);
+  rb_check_frozen(self);
 
   int index;
   VALUE msg;
@@ -2393,8 +2554,16 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
  */
 static VALUE re2_set_compile(VALUE self) {
   re2_set *s = unwrap_re2_set(self);
+  rb_check_frozen(self);
+
+  bool compiled = s->set->Compile();
 
-  return BOOL2RUBY(s->set->Compile());
+  if (compiled) {
+    s->compiled = true;
+    rb_obj_freeze(self);
+  }
+
+  return BOOL2RUBY(compiled);
 }
 
 /*
@@ -2491,6 +2660,8 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
   rb_scan_args(argc, argv, "11", &str, &options);
 
   StringValue(str);
+  str = rb_str_new_frozen(str);
+
   re2_set *s = unwrap_re2_set(self);
 
   if (RTEST(options)) {
@@ -2506,9 +2677,27 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
 
   if (raise_exception) {
 #ifdef HAVE_ERROR_INFO_ARGUMENT
+    /* RE2::Set::Match dereferences a null program after a failed Compile. */
+    if (!s->compiled) {
+      rb_raise(re2_eSetMatchError, "#match must not be called before #compile");
+    }
+
     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) {
@@ -2535,11 +2724,29 @@ 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);
+    if (!s->compiled) {
+      return rb_ary_new();
+    }
+
+    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) {
+    if (arg.matched) {
       for (int index : v) {
         rb_ary_push(result, INT2FIX(index));
       }
@@ -2550,6 +2757,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,