re2 2.2.0-x86_64-darwin → 2.4.0-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 748cef5b5770ec9efd1f2a16a1f8f2a1579d89fd2029781a5a78f01c8c739ada
-  data.tar.gz: 6f8ad260dfb4cdbcda85c2f5f4b9fb03a6386402d10216ace0b3e15bf2799390
+  metadata.gz: edf1c7e3653b56292efc8e46bb85ab926a458dee95c9a9557f45ae027bef8634
+  data.tar.gz: 5c768b4d45614caa2caa3e301e4cf672fc97d65986f93bda22677455678d6510
 SHA512:
-  metadata.gz: 6413cceba40aed846d080d1ed6f9dee0487d521f66e108654338e737713155ca307ce819bf00ca034b469ba38ed5ec0cf2505fe0e23fd409bd0ec9a7a26b3a9f
-  data.tar.gz: d206938a3b572ff838e001e9200b2c951c53ed6edda98efaaa6bb3b4b33fac74bd0f17c773ac2b81b9471d954ff62edec8786dfe7c9a23768c6a92728c64e0aa
+  metadata.gz: feae473be7b1d2bba5241c9f1e2865853a0a72de488e2cec72a46d60dad1e804e9c2051c5147a561f353a061d4e937cf11f4a3d9cd9fbe0f91377c64375d163e
+  data.tar.gz: 22a6791f535fd6a32dcd94f1d2b8f01532e2396395b3a566836811c6d28c93b091729081f4b374d0a0d783b7e115911d2d1efb3be933beefeaaababf83ed70ae

data/README.md

@@ -5,9 +5,9 @@ Ruby bindings to [RE2][], a "fast, safe, thread-friendly alternative to
 backtracking regular expression engines like those used in PCRE, Perl, and
 Python".
 
-**Current version:** 2.2.0  
+**Current version:** 2.4.0  
 **Supported Ruby versions:** 2.6, 2.7, 3.0, 3.1, 3.2  
-**Bundled RE2 version:** libre2.11 (2023-09-01)  
+**Bundled RE2 version:** libre2.11 (2023-11-01)  
 **Supported RE2 versions:** libre2.0 (< 2020-03-02), libre2.1 (2020-03-02), libre2.6 (2020-03-03), libre2.7 (2020-05-01), libre2.8 (2020-07-06), libre2.9 (2020-11-01), libre2.10 (2022-12-01), libre2.11 (2023-07-01)
 
 Installation
@@ -39,8 +39,9 @@ If you are using Debian, you can install the [libre2-dev][] package like so:
 
     $ sudo apt-get install libre2-dev
 
-Recent versions of RE2 require a compiler with C++14 support such as
-[clang](http://clang.llvm.org/) 3.4 or [gcc](https://gcc.gnu.org/) 5.
+Recent versions of RE2 require [CMake](https://cmake.org) and a compiler with
+C++14 support such as [clang](http://clang.llvm.org/) 3.4 or
+[gcc](https://gcc.gnu.org/) 5.
 
 If you are using a packaged Ruby distribution, make sure you also have the
 Ruby header files installed such as those provided by the [ruby-dev][] package
@@ -269,6 +270,9 @@ Contributions
 * Thanks to [Peter Zhu](https://github.com/peterzhu2118) for
   [ruby_memcheck](https://github.com/Shopify/ruby_memcheck) and helping find
   the memory leaks fixed in 2.1.3.
+* Thanks to [Jean Boussier](https://github.com/byroot) for contributing the
+  switch to Ruby's `TypedData` API and the resulting garbage collection
+  improvements in 2.4.0.
 
 Contact
 -------

data/dependencies.yml

@@ -1,7 +1,7 @@
 ---
 libre2:
-  version: '2023-09-01'
-  sha256: 5bb6875ae1cd1e9fedde98018c346db7260655f86fdb8837e3075103acd3649b
+  version: '2023-11-01'
+  sha256: 4e6593ac3c71de1c0f322735bc8b0492a72f66ffccfad76e259fa21c41d27d8a
 abseil:
   version: '20230802.1'
   sha256: 987ce98f02eefbaf930d6e38ab16aa05737234d7afbab2d5c4ea7adbe50c28ed

data/ext/re2/extconf.rb

@@ -128,6 +128,7 @@ def build_extension(static_p = false)
 
   have_library("stdc++")
   have_header("stdint.h")
+  have_func("rb_gc_mark_movable") # introduced in Ruby 2.7
 
   if !static_p and !have_library("re2")
     abort "You must have re2 installed and specified with --with-re2-dir, please see https://github.com/google/re2/wiki/Install"

data/ext/re2/re2.cc

@@ -122,49 +122,145 @@ static void parse_re2_options(RE2::Options* re2_options, const VALUE options) {
   }
 }
 
-static void re2_matchdata_mark(re2_matchdata* self) {
-  rb_gc_mark(self->regexp);
-  rb_gc_mark(self->text);
+/* For compatibility with ruby < 2.7 */
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+#define re2_compact_callback(x) .dcompact = (x),
+#else
+#define rb_gc_mark_movable(x) rb_gc_mark(x)
+#define re2_compact_callback(x)
+#endif
+
+static void re2_matchdata_mark(void *data) {
+  re2_matchdata *self = (re2_matchdata *)data;
+  rb_gc_mark_movable(self->regexp);
+  rb_gc_mark_movable(self->text);
 }
 
-static void re2_matchdata_free(re2_matchdata* self) {
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void re2_matchdata_update_references(void *data) {
+  re2_matchdata *self = (re2_matchdata *)data;
+  self->regexp = rb_gc_location(self->regexp);
+  self->text = rb_gc_location(self->text);
+}
+#endif
+
+static void re2_matchdata_free(void *data) {
+  re2_matchdata *self = (re2_matchdata *)data;
   if (self->matches) {
     delete[] self->matches;
   }
-  free(self);
+  xfree(self);
+}
+
+static size_t re2_matchdata_memsize(const void *data) {
+  const re2_matchdata *self = (const re2_matchdata *)data;
+  size_t size = sizeof(re2_matchdata);
+  if (self->matches) {
+    size += sizeof(self->matches) * self->number_of_matches;
+  }
+
+  return size;
 }
 
-static void re2_scanner_mark(re2_scanner* self) {
-  rb_gc_mark(self->regexp);
-  rb_gc_mark(self->text);
+static const rb_data_type_t re2_matchdata_data_type = {
+  .wrap_struct_name = "RE2::MatchData",
+  .function = {
+    .dmark = re2_matchdata_mark,
+    .dfree = re2_matchdata_free,
+    .dsize = re2_matchdata_memsize,
+    re2_compact_callback(re2_matchdata_update_references)
+  },
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static void re2_scanner_mark(void *data) {
+  re2_scanner *self = (re2_scanner *)data;
+  rb_gc_mark_movable(self->regexp);
+  rb_gc_mark_movable(self->text);
 }
 
-static void re2_scanner_free(re2_scanner* self) {
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void re2_scanner_update_references(void *data) {
+  re2_scanner *self = (re2_scanner *)data;
+  self->regexp = rb_gc_location(self->regexp);
+  self->text = rb_gc_location(self->text);
+}
+#endif
+
+static void re2_scanner_free(void *data) {
+  re2_scanner *self = (re2_scanner *)data;
   if (self->input) {
     delete self->input;
   }
-  free(self);
+  xfree(self);
 }
 
-static void re2_regexp_free(re2_pattern* self) {
+static size_t re2_scanner_memsize(const void *data) {
+  const re2_scanner *self = (const re2_scanner *)data;
+  size_t size = sizeof(re2_scanner);
+  if (self->input) {
+    size += sizeof(self->input);
+  }
+
+  return size;
+}
+
+static const rb_data_type_t re2_scanner_data_type = {
+  .wrap_struct_name = "RE2::Scanner",
+  .function = {
+    .dmark = re2_scanner_mark,
+    .dfree = re2_scanner_free,
+    .dsize = re2_scanner_memsize,
+    re2_compact_callback(re2_scanner_update_references)
+  },
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static void re2_regexp_free(void *data) {
+  re2_pattern *self = (re2_pattern *)data;
   if (self->pattern) {
     delete self->pattern;
   }
-  free(self);
+  xfree(self);
 }
 
+static size_t re2_regexp_memsize(const void *data) {
+  const re2_pattern *self = (const re2_pattern *)data;
+  size_t size = sizeof(re2_pattern);
+  if (self->pattern) {
+    size += sizeof(self->pattern);
+  }
+
+  return size;
+}
+
+static const rb_data_type_t re2_regexp_data_type = {
+  .wrap_struct_name = "RE2::Regexp",
+  .function = {
+    .dmark = NULL,
+    .dfree = re2_regexp_free,
+    .dsize = re2_regexp_memsize,
+  },
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
 static VALUE re2_matchdata_allocate(VALUE klass) {
   re2_matchdata *m;
 
-  return Data_Make_Struct(klass, re2_matchdata, re2_matchdata_mark,
-      re2_matchdata_free, m);
+  return TypedData_Make_Struct(klass, re2_matchdata, &re2_matchdata_data_type,
+      m);
 }
 
 static VALUE re2_scanner_allocate(VALUE klass) {
   re2_scanner *c;
 
-  return Data_Make_Struct(klass, re2_scanner, re2_scanner_mark,
-      re2_scanner_free, c);
+  return TypedData_Make_Struct(klass, re2_scanner, &re2_scanner_data_type, c);
 }
 
 /*
@@ -177,7 +273,7 @@ static VALUE re2_scanner_allocate(VALUE klass) {
  */
 static VALUE re2_matchdata_string(const VALUE self) {
   re2_matchdata *m;
-  Data_Get_Struct(self, re2_matchdata, m);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
 
   return m->text;
 }
@@ -192,7 +288,7 @@ static VALUE re2_matchdata_string(const VALUE self) {
  */
 static VALUE re2_scanner_string(const VALUE self) {
   re2_scanner *c;
-  Data_Get_Struct(self, re2_scanner, c);
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
 
   return c->text;
 }
@@ -207,7 +303,7 @@ static VALUE re2_scanner_string(const VALUE self) {
  */
 static VALUE re2_scanner_eof(const VALUE self) {
   re2_scanner *c;
-  Data_Get_Struct(self, re2_scanner, c);
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
 
   return BOOL2RUBY(c->eof);
 }
@@ -225,7 +321,7 @@ static VALUE re2_scanner_eof(const VALUE self) {
  */
 static VALUE re2_scanner_rewind(VALUE self) {
   re2_scanner *c;
-  Data_Get_Struct(self, re2_scanner, c);
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
 
   delete c->input;
   c->input = new(std::nothrow) re2::StringPiece(RSTRING_PTR(c->text));
@@ -252,8 +348,8 @@ static VALUE re2_scanner_scan(VALUE self) {
   re2_pattern *p;
   re2_scanner *c;
 
-  Data_Get_Struct(self, re2_scanner, c);
-  Data_Get_Struct(c->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
+  TypedData_Get_Struct(c->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   std::vector<RE2::Arg> argv(c->number_of_capturing_groups);
   std::vector<RE2::Arg*> args(c->number_of_capturing_groups);
@@ -308,8 +404,8 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   int id;
 
@@ -349,7 +445,8 @@ static re2::StringPiece *re2_matchdata_find_match(VALUE idx, const VALUE self) {
  */
 static VALUE re2_matchdata_size(const VALUE self) {
   re2_matchdata *m;
-  Data_Get_Struct(self, re2_matchdata, m);
+
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
 
   return INT2FIX(m->number_of_matches);
 }
@@ -367,7 +464,7 @@ static VALUE re2_matchdata_size(const VALUE self) {
 static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
   re2_matchdata *m;
 
-  Data_Get_Struct(self, re2_matchdata, m);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
@@ -392,7 +489,7 @@ static VALUE re2_matchdata_begin(const VALUE self, VALUE n) {
 static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
   re2_matchdata *m;
 
-  Data_Get_Struct(self, re2_matchdata, m);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
 
   re2::StringPiece *match = re2_matchdata_find_match(n, self);
   if (match == NULL) {
@@ -414,7 +511,7 @@ static VALUE re2_matchdata_end(const VALUE self, VALUE n) {
  */
 static VALUE re2_matchdata_regexp(const VALUE self) {
   re2_matchdata *m;
-  Data_Get_Struct(self, re2_matchdata, m);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
 
   return m->regexp;
 }
@@ -429,7 +526,7 @@ static VALUE re2_matchdata_regexp(const VALUE self) {
  */
 static VALUE re2_scanner_regexp(const VALUE self) {
   re2_scanner *c;
-  Data_Get_Struct(self, re2_scanner, c);
+  TypedData_Get_Struct(self, re2_scanner, &re2_scanner_data_type, c);
 
   return c->regexp;
 }
@@ -437,7 +534,7 @@ static VALUE re2_scanner_regexp(const VALUE self) {
 static VALUE re2_regexp_allocate(VALUE klass) {
   re2_pattern *p;
 
-  return Data_Make_Struct(klass, re2_pattern, 0, re2_regexp_free, p);
+  return TypedData_Make_Struct(klass, re2_pattern, &re2_regexp_data_type, p);
 }
 
 /*
@@ -456,8 +553,8 @@ static VALUE re2_matchdata_to_a(const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   VALUE array = rb_ary_new2(m->number_of_matches);
   for (int i = 0; i < m->number_of_matches; ++i) {
@@ -478,8 +575,8 @@ static VALUE re2_matchdata_nth_match(int nth, const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   if (nth < 0 || nth >= m->number_of_matches) {
     return Qnil;
@@ -499,8 +596,8 @@ static VALUE re2_matchdata_named_match(const char* name, const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   std::map<std::string, int>::const_iterator search = groups.find(name);
@@ -599,8 +696,8 @@ static VALUE re2_matchdata_inspect(const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   std::ostringstream output;
   output << "#<RE2::MatchData";
@@ -651,8 +748,8 @@ static VALUE re2_matchdata_deconstruct(const VALUE self) {
   re2_matchdata *m;
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   VALUE array = rb_ary_new2(m->number_of_matches - 1);
   for (int i = 1; i < m->number_of_matches; ++i) {
@@ -701,8 +798,8 @@ static VALUE re2_matchdata_deconstruct_keys(const VALUE self, const VALUE keys)
   re2_matchdata *m;
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_matchdata, m);
-  Data_Get_Struct(m->regexp, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_matchdata, &re2_matchdata_data_type, m);
+  TypedData_Get_Struct(m->regexp, re2_pattern, &re2_regexp_data_type, p);
 
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
@@ -790,7 +887,7 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
   /* Ensure pattern is a string. */
   StringValue(pattern);
 
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   if (RTEST(options)) {
     RE2::Options re2_options;
@@ -823,7 +920,7 @@ static VALUE re2_regexp_initialize(int argc, VALUE *argv, VALUE self) {
 static VALUE re2_regexp_inspect(const VALUE self) {
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   std::ostringstream output;
 
@@ -847,7 +944,7 @@ static VALUE re2_regexp_inspect(const VALUE self) {
  */
 static VALUE re2_regexp_to_s(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return encoded_str_new(p->pattern->pattern().data(),
       p->pattern->pattern().size(),
@@ -865,7 +962,7 @@ static VALUE re2_regexp_to_s(const VALUE self) {
  */
 static VALUE re2_regexp_ok(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->ok());
 }
@@ -881,7 +978,7 @@ static VALUE re2_regexp_ok(const VALUE self) {
  */
 static VALUE re2_regexp_utf8(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().encoding() == RE2::Options::EncodingUTF8);
 }
@@ -897,7 +994,7 @@ static VALUE re2_regexp_utf8(const VALUE self) {
  */
 static VALUE re2_regexp_posix_syntax(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().posix_syntax());
 }
@@ -913,7 +1010,7 @@ static VALUE re2_regexp_posix_syntax(const VALUE self) {
  */
 static VALUE re2_regexp_longest_match(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().longest_match());
 }
@@ -929,7 +1026,7 @@ static VALUE re2_regexp_longest_match(const VALUE self) {
  */
 static VALUE re2_regexp_log_errors(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().log_errors());
 }
@@ -945,7 +1042,7 @@ static VALUE re2_regexp_log_errors(const VALUE self) {
  */
 static VALUE re2_regexp_max_mem(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return INT2FIX(p->pattern->options().max_mem());
 }
@@ -961,7 +1058,7 @@ static VALUE re2_regexp_max_mem(const VALUE self) {
  */
 static VALUE re2_regexp_literal(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().literal());
 }
@@ -977,7 +1074,7 @@ static VALUE re2_regexp_literal(const VALUE self) {
  */
 static VALUE re2_regexp_never_nl(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().never_nl());
 }
@@ -993,7 +1090,7 @@ static VALUE re2_regexp_never_nl(const VALUE self) {
  */
 static VALUE re2_regexp_case_sensitive(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().case_sensitive());
 }
@@ -1023,7 +1120,7 @@ static VALUE re2_regexp_case_insensitive(const VALUE self) {
  */
 static VALUE re2_regexp_perl_classes(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().perl_classes());
 }
@@ -1039,7 +1136,7 @@ static VALUE re2_regexp_perl_classes(const VALUE self) {
  */
 static VALUE re2_regexp_word_boundary(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().word_boundary());
 }
@@ -1055,7 +1152,7 @@ static VALUE re2_regexp_word_boundary(const VALUE self) {
  */
 static VALUE re2_regexp_one_line(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return BOOL2RUBY(p->pattern->options().one_line());
 }
@@ -1068,7 +1165,7 @@ static VALUE re2_regexp_one_line(const VALUE self) {
  */
 static VALUE re2_regexp_error(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1089,7 +1186,7 @@ static VALUE re2_regexp_error(const VALUE self) {
  */
 static VALUE re2_regexp_error_arg(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   if (p->pattern->ok()) {
     return Qnil;
@@ -1109,7 +1206,7 @@ static VALUE re2_regexp_error_arg(const VALUE self) {
  */
 static VALUE re2_regexp_program_size(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return INT2FIX(p->pattern->ProgramSize());
 }
@@ -1123,7 +1220,7 @@ static VALUE re2_regexp_program_size(const VALUE self) {
 static VALUE re2_regexp_options(const VALUE self) {
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
   VALUE options = rb_hash_new();
 
   rb_hash_aset(options, ID2SYM(id_utf8),
@@ -1174,7 +1271,7 @@ static VALUE re2_regexp_options(const VALUE self) {
  */
 static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
   re2_pattern *p;
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   return INT2FIX(p->pattern->NumberOfCapturingGroups());
 }
@@ -1191,7 +1288,7 @@ static VALUE re2_regexp_number_of_capturing_groups(const VALUE self) {
 static VALUE re2_regexp_named_capturing_groups(const VALUE self) {
   re2_pattern *p;
 
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
   const std::map<std::string, int>& groups = p->pattern->NamedCapturingGroups();
   VALUE capturing_groups = rb_hash_new();
 
@@ -1267,7 +1364,7 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
   /* Ensure text is a string. */
   StringValue(text);
 
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
 
   int n;
 
@@ -1299,11 +1396,13 @@ static VALUE re2_regexp_match(int argc, VALUE *argv, const VALUE self) {
     n += 1;
 
     VALUE matchdata = rb_class_new_instance(0, 0, re2_cMatchData);
-    Data_Get_Struct(matchdata, re2_matchdata, m);
+    TypedData_Get_Struct(matchdata, re2_matchdata, &re2_matchdata_data_type, m);
     m->matches = new(std::nothrow) re2::StringPiece[n];
-    m->regexp = self;
-    m->text = rb_str_dup(text);
-    rb_str_freeze(m->text);
+    RB_OBJ_WRITE(matchdata, &m->regexp, self);
+    if (!RTEST(rb_obj_frozen_p(text))) {
+      text = rb_str_freeze(rb_str_dup(text));
+    }
+    RB_OBJ_WRITE(matchdata, &m->text, text);
 
     if (m->matches == 0) {
       rb_raise(rb_eNoMemError,
@@ -1352,13 +1451,13 @@ static VALUE re2_regexp_scan(const VALUE self, VALUE text) {
   re2_pattern *p;
   re2_scanner *c;
 
-  Data_Get_Struct(self, re2_pattern, p);
+  TypedData_Get_Struct(self, re2_pattern, &re2_regexp_data_type, p);
   VALUE scanner = rb_class_new_instance(0, 0, re2_cScanner);
-  Data_Get_Struct(scanner, re2_scanner, c);
+  TypedData_Get_Struct(scanner, re2_scanner, &re2_scanner_data_type, c);
 
   c->input = new(std::nothrow) re2::StringPiece(RSTRING_PTR(text));
-  c->regexp = self;
-  c->text = text;
+  RB_OBJ_WRITE(scanner, &c->regexp, self);
+  RB_OBJ_WRITE(scanner, &c->text, text);
 
   if (p->pattern->ok()) {
     c->number_of_capturing_groups = p->pattern->NumberOfCapturingGroups();
@@ -1402,7 +1501,7 @@ static VALUE re2_Replace(VALUE, VALUE str, VALUE pattern,
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    Data_Get_Struct(pattern, re2_pattern, p);
+    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
     RE2::Replace(&str_as_string, *p->pattern, RSTRING_PTR(rewrite));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
@@ -1446,7 +1545,7 @@ static VALUE re2_GlobalReplace(VALUE, VALUE str, VALUE pattern,
 
   /* Do the replacement. */
   if (rb_obj_is_kind_of(pattern, re2_cRegexp)) {
-    Data_Get_Struct(pattern, re2_pattern, p);
+    TypedData_Get_Struct(pattern, re2_pattern, &re2_regexp_data_type, p);
     RE2::GlobalReplace(&str_as_string, *p->pattern, RSTRING_PTR(rewrite));
 
     return encoded_str_new(str_as_string.data(), str_as_string.size(),
@@ -1480,16 +1579,39 @@ static VALUE re2_QuoteMeta(VALUE, VALUE unquoted) {
   return rb_str_new(quoted_string.data(), quoted_string.size());
 }
 
-static void re2_set_free(re2_set *self) {
+static void re2_set_free(void *data) {
+  re2_set *self = (re2_set *)data;
   if (self->set) {
     delete self->set;
   }
-  free(self);
+  xfree(self);
+}
+
+static size_t re2_set_memsize(const void *data) {
+  const re2_set *self = (const re2_set *)data;
+  size_t size = sizeof(re2_set);
+  if (self->set) {
+    size += sizeof(self->set);
+  }
+
+  return size;
 }
 
+static const rb_data_type_t re2_set_data_type = {
+  .wrap_struct_name = "RE2::Set",
+  .function = {
+    .dmark = NULL,
+    .dfree = re2_set_free,
+    .dsize = re2_set_memsize,
+  },
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
 static VALUE re2_set_allocate(VALUE klass) {
   re2_set *s;
-  VALUE result = Data_Make_Struct(klass, re2_set, 0, re2_set_free, s);
+  VALUE result = TypedData_Make_Struct(klass, re2_set, &re2_set_data_type, s);
 
   return result;
 }
@@ -1540,7 +1662,7 @@ static VALUE re2_set_initialize(int argc, VALUE *argv, VALUE self) {
   re2_set *s;
 
   rb_scan_args(argc, argv, "02", &anchor, &options);
-  Data_Get_Struct(self, re2_set, s);
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
 
   RE2::Anchor re2_anchor = RE2::UNANCHORED;
 
@@ -1588,7 +1710,7 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
   StringValue(pattern);
 
   re2_set *s;
-  Data_Get_Struct(self, re2_set, s);
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
 
   /* To prevent the memory of the err string leaking when we call rb_raise,
    * take a copy of it and let it go out of scope.
@@ -1621,7 +1743,7 @@ static VALUE re2_set_add(VALUE self, VALUE pattern) {
  */
 static VALUE re2_set_compile(VALUE self) {
   re2_set *s;
-  Data_Get_Struct(self, re2_set, s);
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
 
   return BOOL2RUBY(s->set->Compile());
 }
@@ -1688,7 +1810,7 @@ static VALUE re2_set_match(int argc, VALUE *argv, const VALUE self) {
 
   StringValue(str);
   re2_set *s;
-  Data_Get_Struct(self, re2_set, s);
+  TypedData_Get_Struct(self, re2_set, &re2_set_data_type, s);
 
   if (RTEST(options)) {
     Check_Type(options, T_HASH);

data/lib/re2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RE2
-  VERSION = "2.2.0"
+  VERSION = "2.4.0"
 end

data/spec/re2/match_data_spec.rb

@@ -129,6 +129,12 @@ RSpec.describe RE2::MatchData do
       re = RE2::Regexp.new('(\D+)').match("bob")
       expect(re.string).to be_frozen
     end
+
+    it "does not copy the string if it was already frozen" do
+      string = "bob".freeze
+      re = RE2::Regexp.new('(\D+)').match(string)
+      expect(re.string).to equal(string)
+    end
   end
 
   describe "#size" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: re2
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.4.0
 platform: x86_64-darwin
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-23 00:00:00.000000000 Z
+date: 2023-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler