re2 2.26.2-x86_64-linux-gnu → 2.27.0-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cebd541e73b7d04ed10265c89a3c0ef8f52989a11ff8065d7bded9caba0a887f
-  data.tar.gz: c023f43cf0c7782b496f22811cd079f4a72da624b98c48f1049a62ca8345781e
+  metadata.gz: b86c49eb21074e4ef2eaa58dc1234224074621dffff2ac3d7fd2d8c6b4214daf
+  data.tar.gz: bf270c0bc858ee0e63d2d3514f7a35c99539455b0dbac7fef145b33a1eb6251a
 SHA512:
-  metadata.gz: 0e75a3f78b09dbff07b53b9566382bd03227efecb246065451c9b30063c053c2d48cfd6a42ac44746a5a182aafc563cd2879094193acdb467f4400e7c12af308
-  data.tar.gz: 17755302c984c920b3510463a91e2d7d7280d7f49e5180662a52e46400751a0f3aa4a67625c7e5147df2f6d0b1f8fea69c3d795f6d70d13b5e6d88e15ce44d03
+  metadata.gz: 0fcf3b3b7d9f47754f70996160a26be706afd222f75c181a114e4014c088642cb3b2d185fedc2dc58fc54f2211ac834ac5f7526ff748dd894c4ed8d4eca5ebbf
+  data.tar.gz: 2e4d7a22246ea69ebc4d00428f347033d5e2d911e3f46735b662eb1be4be541d31dbe33efbad9165067a284e1c21c2d152a18c824ebb6ecec9f66e5eeb7ab631

data/README.md

@@ -6,7 +6,7 @@ Python".
 
 [![Build Status](https://github.com/mudge/re2/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/mudge/re2/actions)
 
-**Current version:** 2.26.2  
+**Current version:** 2.27.0  
 **Bundled RE2 version:** libre2.11 (2025-11-05)  
 
 ```ruby

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)
 
@@ -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;
 
@@ -126,7 +253,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 +263,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 +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;
@@ -174,7 +301,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 +311,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 +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);
@@ -222,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;
   }
@@ -230,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);
@@ -250,7 +377,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) {
@@ -1249,6 +1376,8 @@ 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;
@@ -1269,6 +1398,8 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
     rb_raise(rb_eNoMemError, "not enough memory to allocate RE2 object");
   }
 
+  rb_obj_freeze(self);
+
   return self;
 }
 
@@ -1278,6 +1409,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 +1422,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;
 }
 
@@ -1753,8 +1888,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 +1988,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 +2007,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 +2039,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 +2060,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 +2084,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 +2093,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 +2156,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 +2228,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 +2304,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 +2380,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 +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);
@@ -2239,7 +2408,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,6 +2501,8 @@ 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;
@@ -2362,6 +2533,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 +2565,15 @@ 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) {
+    rb_obj_freeze(self);
+  }
+
+  return BOOL2RUBY(compiled);
 }
 
 /*
@@ -2491,6 +2670,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)) {
@@ -2507,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) {
@@ -2535,11 +2729,25 @@ 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) {
+    if (arg.matched) {
       for (int index : v) {
         rb_ary_push(result, INT2FIX(index));
       }
@@ -2550,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,

data/lib/re2/version.rb

@@ -10,5 +10,5 @@
 
 
 module RE2
-  VERSION = "2.26.2"
+  VERSION = "2.27.0"
 end

data/spec/re2/regexp_spec.rb

@@ -39,6 +39,16 @@ RSpec.describe RE2::Regexp do
 
       expect(re).to be_a(RE2::Regexp)
     end
+
+    it "returns a frozen object" do
+      expect(RE2::Regexp.new('woo')).to be_frozen
+    end
+
+    it "cannot be re-initialized" do
+      re = RE2::Regexp.new('woo')
+
+      expect { re.send(:initialize, 'bar') }.to raise_error(FrozenError)
+    end
   end
 
   describe "#dup" do
@@ -70,6 +80,13 @@ RSpec.describe RE2::Regexp do
       expect(copy).to_not be_case_sensitive
     end
 
+    it "returns a frozen copy" do
+      re = described_class.new('(\d+)')
+      copy = re.dup
+
+      expect(copy).to be_frozen
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.dup }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
@@ -83,6 +100,13 @@ RSpec.describe RE2::Regexp do
       expect(copy.to_s).to eq('woo')
     end
 
+    it "returns a frozen copy" do
+      re = described_class.new('woo')
+      copy = re.clone
+
+      expect(copy).to be_frozen
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.clone }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
@@ -769,6 +793,16 @@ RSpec.describe RE2::Regexp do
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.match("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { re.match("one two").values_at(1, 2) }
+      end
+
+      expect(threads.map(&:value)).to all(eq(["one", "two"]))
+    end
   end
 
   describe "#match?" do
@@ -794,6 +828,16 @@ RSpec.describe RE2::Regexp do
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.match?("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { re.match?("one two") }
+      end
+
+      expect(threads.map(&:value)).to all(eq(true))
+    end
   end
 
   describe "#partial_match?" do
@@ -826,6 +870,16 @@ RSpec.describe RE2::Regexp do
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.partial_match?("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\d+)')
+
+      threads = 10.times.map do
+        Thread.new { re.partial_match?("alice 123") }
+      end
+
+      expect(threads.map(&:value)).to all(eq(true))
+    end
   end
 
   describe "#=~" do
@@ -915,6 +969,16 @@ RSpec.describe RE2::Regexp do
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.full_match?("test") }.to raise_error(TypeError, /uninitialized RE2::Regexp/)
     end
+
+    it "can be run concurrently" do
+      re = RE2::Regexp.new('(\w+) (\d+)')
+
+      threads = 10.times.map do
+        Thread.new { re.full_match?("alice 123") }
+      end
+
+      expect(threads.map(&:value)).to all(eq(true))
+    end
   end
 
   describe "#ok?" do

data/spec/re2/set_spec.rb

@@ -84,14 +84,12 @@ RSpec.describe RE2::Set do
       expect { set.add("(?P<#{'o' * 200}") }.to raise_error(ArgumentError, "str rejected by RE2::Set->Add(): invalid named capture group: (?P<oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo")
     end
 
-    it "raises an error if called after #compile" do
+    it "raises a FrozenError if called after #compile" do
       set = RE2::Set.new(:unanchored, log_errors: false)
       set.add("abc")
       set.compile
 
-      silence_stderr do
-        expect { set.add("def") }.to raise_error(ArgumentError)
-      end
+      expect { set.add("def") }.to raise_error(FrozenError)
     end
 
     it "raises an error if given a pattern that can't be coerced to a String" do
@@ -121,6 +119,29 @@ RSpec.describe RE2::Set do
       expect(set.compile).to be_truthy
     end
 
+    it "freezes the set on successful compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect(set).to be_frozen
+    end
+
+    it "is not frozen before compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+
+      expect(set).to_not be_frozen
+    end
+
+    it "cannot be re-initialized after compilation" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.compile
+
+      expect { set.send(:initialize) }.to raise_error(FrozenError)
+    end
+
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.compile }.to raise_error(TypeError, /uninitialized RE2::Set/)
     end
@@ -226,6 +247,20 @@ RSpec.describe RE2::Set do
     it "raises an error when called on an uninitialized object" do
       expect { described_class.allocate.match("foo") }.to raise_error(TypeError, /uninitialized RE2::Set/)
     end
+
+    it "can be run concurrently" do
+      set = RE2::Set.new
+      set.add("abc")
+      set.add("def")
+      set.add("ghi")
+      set.compile
+
+      threads = 10.times.map do
+        Thread.new { set.match("abcdefghi", exception: false) }
+      end
+
+      expect(threads.map(&:value)).to all(eq([0, 1, 2]))
+    end
   end
 
   describe "#size" do

data/spec/re2_spec.rb

@@ -93,6 +93,26 @@ RSpec.describe RE2 do
     it "raises a Type Error for a replacement that can't be converted to String" do
       expect { RE2.replace("woo", "oo", 0) }.to raise_error(TypeError)
     end
+
+    it "can be run concurrently with the same RE2::Regexp pattern" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { RE2.replace("one two", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one"))
+    end
+
+    it "can be run concurrently with the same string pattern" do
+      re = '(\w+)\s(\w+)'
+
+      threads = 10.times.map do
+        Thread.new { RE2.replace("one two", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one"))
+    end
   end
 
   describe ".Replace" do
@@ -193,6 +213,26 @@ RSpec.describe RE2 do
     it "raises a Type Error for a replacement that can't be converted to String" do
       expect { RE2.global_replace("woo", "o", 0) }.to raise_error(TypeError)
     end
+
+    it "can be run concurrently with the same RE2::Regexp pattern" do
+      re = RE2::Regexp.new('(\w+)\s(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { RE2.global_replace("one two three four", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one four three"))
+    end
+
+    it "can be run concurrently with the same string pattern" do
+      re = '(\w+)\s(\w+)'
+
+      threads = 10.times.map do
+        Thread.new { RE2.global_replace("one two three four", re, '\2 \1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("two one four three"))
+    end
   end
 
   describe ".GlobalReplace" do
@@ -281,6 +321,26 @@ RSpec.describe RE2 do
     it "raises a Type Error for a rewrite that can't be converted to String" do
       expect { RE2.extract("woo", '(\w+)', 0) }.to raise_error(TypeError)
     end
+
+    it "can be run concurrently with the same RE2::Regexp pattern" do
+      re = RE2::Regexp.new('(\w+)@(\w+)')
+
+      threads = 10.times.map do
+        Thread.new { RE2.extract("alice@example", re, '\2-\1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("example-alice"))
+    end
+
+    it "can be run concurrently with the same string pattern" do
+      re = '(\w+)@(\w+)'
+
+      threads = 10.times.map do
+        Thread.new { RE2.extract("alice@example", re, '\2-\1') }
+      end
+
+      expect(threads.map(&:value)).to all(eq("example-alice"))
+    end
   end
 
   describe "#escape" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.26.2
+  version: 2.27.0
 platform: x86_64-linux-gnu
 authors:
 - Paul Mucur