re2 2.3.0-x86-linux → 2.4.1-x86-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f38b0e5195f957a84de2d1db7075a9c74a3e14821c54c8afa8959e9544c32de
-  data.tar.gz: b3f0d071c605ac1d50428021260008a076cac5ea1242ba9d5d18ba3cdbe5b73d
+  metadata.gz: 4238a5d5a760801c983db581366971cfaaea15ca314ec83da3f214f9f90584d0
+  data.tar.gz: ebce6fa954f8c2a01f550b7f7bf7123bb1cbec5df6dba01b75f346c17a58648b
 SHA512:
-  metadata.gz: be6b3e87ddcac59d1e83ec316756ee3dbe9f00ef03fe59e1221b808caca48df1748f75c08567180c043472076707d81e2c84285fd7abd8f5167b2290e414a530
-  data.tar.gz: 92aeac7772158a929eefa8ad89451782fd7c5388e9085dfb0629ba5035bb8d56116ab64e0b7c4d40e013edd8c574db1688c2751044a1f1c753428f5c7a584613
+  metadata.gz: c694d73e6452646420fe268691ad6966f2fd016780d30b9a1be96119bd711868b8fc1315e6b91d1703974a0d1ef98049f0588c233f70ae6d84eaf07c96491c5f
+  data.tar.gz: 448b389edfb3eb2195255341dd98c3c2a56436a79e6e9900a76e322e7c023a9d30b5acae5f898b45db66831e6d84ac01856497c5a97b1ad63f5b427dfd9c83c5

data/README.md

@@ -5,7 +5,7 @@ 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.3.0  
+**Current version:** 2.4.1  
 **Supported Ruby versions:** 2.6, 2.7, 3.0, 3.1, 3.2  
 **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)
@@ -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/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 *ptr) {
+  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  rb_gc_mark_movable(m->regexp);
+  rb_gc_mark_movable(m->text);
+}
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void re2_matchdata_compact(void *ptr) {
+  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  m->regexp = rb_gc_location(m->regexp);
+  m->text = rb_gc_location(m->text);
+}
+#endif
+
+static void re2_matchdata_free(void *ptr) {
+  re2_matchdata *m = reinterpret_cast<re2_matchdata *>(ptr);
+  if (m->matches) {
+    delete[] m->matches;
+  }
+  xfree(m);
 }
 
-static void re2_matchdata_free(re2_matchdata* self) {
-  if (self->matches) {
-    delete[] self->matches;
+static size_t re2_matchdata_memsize(const void *ptr) {
+  const re2_matchdata *m = reinterpret_cast<const re2_matchdata *>(ptr);
+  size_t size = sizeof(*m);
+  if (m->matches) {
+    size += sizeof(*m->matches) * m->number_of_matches;
   }
-  free(self);
+
+  return size;
+}
+
+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_compact)
+  },
+  // 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 *ptr) {
+  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  rb_gc_mark_movable(s->regexp);
+  rb_gc_mark_movable(s->text);
+}
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void re2_scanner_compact(void *ptr) {
+  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  s->regexp = rb_gc_location(s->regexp);
+  s->text = rb_gc_location(s->text);
 }
+#endif
 
-static void re2_scanner_mark(re2_scanner* self) {
-  rb_gc_mark(self->regexp);
-  rb_gc_mark(self->text);
+static void re2_scanner_free(void *ptr) {
+  re2_scanner *s = reinterpret_cast<re2_scanner *>(ptr);
+  if (s->input) {
+    delete s->input;
+  }
+  xfree(s);
 }
 
-static void re2_scanner_free(re2_scanner* self) {
-  if (self->input) {
-    delete self->input;
+static size_t re2_scanner_memsize(const void *ptr) {
+  const re2_scanner *s = reinterpret_cast<const re2_scanner *>(ptr);
+  size_t size = sizeof(*s);
+  if (s->input) {
+    size += sizeof(s->input);
   }
-  free(self);
+
+  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_compact)
+  },
+  // 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 *ptr) {
+  re2_pattern *p = reinterpret_cast<re2_pattern *>(ptr);
+  if (p->pattern) {
+    delete p->pattern;
+  }
+  xfree(p);
 }
 
-static void re2_regexp_free(re2_pattern* self) {
-  if (self->pattern) {
-    delete self->pattern;
+static size_t re2_regexp_memsize(const void *ptr) {
+  const re2_pattern *p = reinterpret_cast<const re2_pattern *>(ptr);
+  size_t size = sizeof(*p);
+  if (p->pattern) {
+    size += sizeof(p->pattern);
   }
-  free(self);
+
+  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) {
-  if (self->set) {
-    delete self->set;
+static void re2_set_free(void *ptr) {
+  re2_set *s = reinterpret_cast<re2_set *>(ptr);
+  if (s->set) {
+    delete s->set;
   }
-  free(self);
+  xfree(s);
 }
 
+static size_t re2_set_memsize(const void *ptr) {
+  const re2_set *s = reinterpret_cast<const re2_set *>(ptr);
+  size_t size = sizeof(*s);
+  if (s->set) {
+    size += sizeof(s->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);
@@ -1755,12 +1877,14 @@ extern "C" void Init_re2(void) {
   re2_eSetUnsupportedError = rb_define_class_under(re2_cSet, "UnsupportedError",
       rb_const_get(rb_cObject, rb_intern("StandardError")));
 
-  rb_define_alloc_func(re2_cRegexp, (VALUE (*)(VALUE))re2_regexp_allocate);
+  rb_define_alloc_func(re2_cRegexp,
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_regexp_allocate));
   rb_define_alloc_func(re2_cMatchData,
-      (VALUE (*)(VALUE))re2_matchdata_allocate);
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_matchdata_allocate));
   rb_define_alloc_func(re2_cScanner,
-      (VALUE (*)(VALUE))re2_scanner_allocate);
-  rb_define_alloc_func(re2_cSet, (VALUE (*)(VALUE))re2_set_allocate);
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_scanner_allocate));
+  rb_define_alloc_func(re2_cSet,
+      reinterpret_cast<VALUE (*)(VALUE)>(re2_set_allocate));
 
   rb_define_method(re2_cMatchData, "string",
       RUBY_METHOD_FUNC(re2_matchdata_string), 0);

data/lib/re2/version.rb

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

data/spec/re2/match_data_spec.rb

@@ -1,5 +1,14 @@
 # encoding: utf-8
+require 'objspace'
+
 RSpec.describe RE2::MatchData do
+  it "reports a larger consuming memory size when it has more matches" do
+    matches1 = RE2::Regexp.new('w(o)').match('woo')
+    matches2 = RE2::Regexp.new('w(o)(o)').match('woo')
+
+    expect(ObjectSpace.memsize_of(matches1)).to be < ObjectSpace.memsize_of(matches2)
+  end
+
   describe "#to_a" do
     it "is populated with the match and capturing groups" do
       a = RE2::Regexp.new('w(o)(o)').match('woo').to_a
@@ -129,6 +138,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.3.0
+  version: 2.4.1
 platform: x86-linux
 authors:
 - Paul Mucur
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-31 00:00:00.000000000 Z
+date: 2023-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler