re2 2.26.1-arm-linux-gnu → 2.27.0-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 986cde0173f07ce45537dfbda2729c511039a67efbd6cce22c0d8d34a888f988
-  data.tar.gz: bece98cf7626ce00f9a13eaf6e66680a7c550681ba4d9aaa6972af8ae805073d
+  metadata.gz: 645eab3b4e65e9324ce7c21fb194003d47e49218bc14ea9a33a971d128b8426d
+  data.tar.gz: f1459959f76efa60581508fd0b1f8360afb4ccfaf8a651d076a4b67cbd334659
 SHA512:
-  metadata.gz: eb59b0f2e444859b67cadb41c3db5716f6421b51d4e614f8c5b28091f00987db1e2456ccdb66eaaa13cee5c390c392bee338c52a8aa7942b49fff18e9657bf5a
-  data.tar.gz: b07e19256548962b6b1ee179026045b502f5fa731ea1cc96e33578e21d1f276b4e69f7d6a31c4b8d7a9eb518dfdc1a9e9953e2c05c987d81a341c4d34366ae0f
+  metadata.gz: 55cc7f7cf8a3ac43c7dfc64040a1f9f137bf04d040b99bcbc4039be358c6b6d6176239164747d8b8ad7be1a1af2a38ba82870bf00965caf2a76af7609a78aefb
+  data.tar.gz: 753a84156ac0cea64cf30e579baf613d691dd04bfd1f092ecbc5e5ad5308ecba601c360c97c4f42b5ddf0f5983b9555d09393f46564dc2e1cb5a0b81f2d401fa

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.1  
+**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) {
@@ -403,6 +530,7 @@ static VALUE re2_scanner_initialize_copy(VALUE self, VALUE other) {
 
   if (self_c->input) {
     delete self_c->input;
+    self_c->input = nullptr;
   }
 
   RB_OBJ_WRITE(self, &self_c->regexp, other_c->regexp);
@@ -481,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;
@@ -1152,6 +1298,7 @@ static VALUE re2_matchdata_initialize_copy(VALUE self, VALUE other) {
 
   if (self_m->matches) {
     delete[] self_m->matches;
+    self_m->matches = nullptr;
   }
 
   self_m->number_of_matches = other_m->number_of_matches;
@@ -1229,8 +1376,11 @@ 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)) {
@@ -1248,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;
 }
 
@@ -1257,8 +1409,11 @@ 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;
   }
 
   self_p->pattern = new(std::nothrow) RE2(other_p->pattern->pattern(),
@@ -1267,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;
 }
 
@@ -1731,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);
 
@@ -1822,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) {
@@ -1847,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);
@@ -1886,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);
 }
 
 /*
@@ -1905,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);
 }
 
 /*
@@ -1927,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;
@@ -1936,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) {
@@ -1997,34 +2154,53 @@ static VALUE re2_regexp_match_has_endpos_argument_p(VALUE) {
  */
 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);
-  std::string str_as_string(RSTRING_PTR(str), RSTRING_LEN(str));
-
-  /* Do the replacement. */
+  str = rb_str_new_frozen(str);
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
     p = unwrap_re2_regexp(pattern);
-    RE2::Replace(&str_as_string, *p->pattern,
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
-
-    return encoded_str_new(str_as_string.data(), str_as_string.size(),
-        p->pattern->options().encoding());
   } else {
-    /* Ensure pattern is a string. */
     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));
+
+  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
 
-    RE2::Replace(&str_as_string,
-        re2::StringPiece(RSTRING_PTR(pattern), RSTRING_LEN(pattern)),
-        re2::StringPiece(RSTRING_PTR(rewrite), RSTRING_LEN(rewrite)));
+  RB_GC_GUARD(rewrite);
+  RB_GC_GUARD(pattern);
 
-    return encoded_str_new(str_as_string.data(), str_as_string.size(), RE2::Options::EncodingUTF8);
+  if (p) {
+    return encoded_str_new(str_as_string.data(), str_as_string.size(),
+        p->pattern->options().encoding());
+  } else {
+    return encoded_str_new(str_as_string.data(), str_as_string.size(),
+        RE2::Options::EncodingUTF8);
   }
 }
 
@@ -2050,33 +2226,55 @@ static VALUE re2_replace(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)) {
-    p = unwrap_re2_regexp(pattern);
-    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. */
-    StringValue(pattern);
-
-    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);
   }
 }
 
@@ -2104,44 +2302,55 @@ static VALUE re2_global_replace(VALUE, VALUE str, VALUE pattern,
  */
 static VALUE re2_extract(VALUE, VALUE text, VALUE pattern,
     VALUE rewrite) {
-  /* Ensure rewrite and text are strings. */
-  StringValue(rewrite);
-  StringValue(text);
-
-  re2_pattern *p;
-  std::string out;
-  bool extracted;
+  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);
-    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;
-    }
   } else {
-    /* Ensure pattern is a string. */
     StringValue(pattern);
+    pattern = rb_str_new_frozen(pattern);
+  }
+  StringValue(rewrite);
+  rewrite = rb_str_new_frozen(rewrite);
 
-    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);
+  std::string out;
 
-    if (extracted) {
-      return encoded_str_new(out.data(), out.size(),
-          RE2::Options::EncodingUTF8);
-    } else {
-      return Qnil;
-    }
+  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;
   }
 }
 
@@ -2171,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;
   }
@@ -2179,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);
@@ -2199,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) {
@@ -2292,8 +2501,11 @@ 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);
@@ -2321,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;
@@ -2352,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);
 
-  return BOOL2RUBY(s->set->Compile());
+  bool compiled = s->set->Compile();
+
+  if (compiled) {
+    rb_obj_freeze(self);
+  }
+
+  return BOOL2RUBY(compiled);
 }
 
 /*
@@ -2450,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)) {
@@ -2466,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) {
@@ -2494,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));
       }
@@ -2509,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.1"
+  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
@@ -757,9 +781,28 @@ RSpec.describe RE2::Regexp do
       expect(re.match("one two three", nil)).to be_a(RE2::MatchData)
     end
 
+    it "raises an error when startpos exceeds INT_MAX on old RE2 ABI" do
+      skip "Underlying RE2::Match does not take int startpos" if RE2::Regexp.match_has_endpos_argument?
+      skip "size_t is not larger than a 32-bit int" if RbConfig::SIZEOF.fetch("size_t") <= (32 / 8)
+
+      re = RE2::Regexp.new('(\w+)', log_errors: false)
+
+      expect { re.match("test", start_pos: 2_147_483_648) }.to raise_error(RangeError, /startpos should be <=/)
+    end
+
     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
@@ -785,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
@@ -817,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
@@ -906,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/scanner_spec.rb

@@ -243,6 +243,52 @@ RSpec.describe RE2::Scanner do
       expect(scanner.scan).to be_nil
     end
 
+    it "advances by whole characters with zero-width matches on 2-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("à")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by whole characters with zero-width matches on 3-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\u20AC")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by whole characters with zero-width matches on 4-byte UTF-8 input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\u{1F600}")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "advances by single bytes with zero-width matches on Latin-1 input", :aggregate_failures do
+      r = RE2::Regexp.new("", utf8: false)
+      scanner = r.scan("\xC3\xA0")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
+    it "handles truncated multi-byte sequences at the end of input", :aggregate_failures do
+      r = RE2::Regexp.new("")
+      scanner = r.scan("\xC3")
+
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to eq([])
+      expect(scanner.scan).to be_nil
+    end
+
     it "raises a Type Error if given input that can't be coerced to a String" do
       r = RE2::Regexp.new('(\w+)')
 

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

@@ -86,9 +86,33 @@ RSpec.describe RE2 do
       expect { RE2.replace("woo", 0, "ah") }.to raise_error(TypeError)
     end
 
+    it "does not leak memory when given a non-String, non-RE2::Regexp pattern" do
+      expect { RE2.replace("a" * 128, 0, "ah") }.to raise_error(TypeError)
+    end
+
     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
@@ -182,9 +206,33 @@ RSpec.describe RE2 do
       expect { RE2.global_replace("woo", 0, "a") }.to raise_error(TypeError)
     end
 
+    it "does not leak memory when given a non-String, non-RE2::Regexp pattern" do
+      expect { RE2.global_replace("a" * 128, 0, "a") }.to raise_error(TypeError)
+    end
+
     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
@@ -266,9 +314,33 @@ RSpec.describe RE2 do
       expect { RE2.extract("woo", 0, '\1') }.to raise_error(TypeError)
     end
 
+    it "does not leak memory when given a non-String, non-RE2::Regexp pattern" do
+      expect { RE2.extract("a" * 128, 0, '\1') }.to raise_error(TypeError)
+    end
+
     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.1
+  version: 2.27.0
 platform: arm-linux-gnu
 authors:
 - Paul Mucur