From 6a630d992ea6101bc2656f75954214f7e5babf7a Mon Sep 17 00:00:00 2001
From: Nobuyoshi Nakada <nobu@ruby-lang.org>
Date: Sun, 11 Jan 2026 17:09:40 +0900
Subject: [PATCH 1/4] Push the commits to the origin at `make matz` [ci skip]

---
 defs/gmake.mk | 36 +++++++++++++++++++++++++-----------
 1 file changed, 25 insertions(+), 11 deletions(-)

diff --git a/defs/gmake.mk b/defs/gmake.mk
index e6f553fa8c1b5d..2fc0ff8733af63 100644
--- a/defs/gmake.mk
+++ b/defs/gmake.mk
@@ -541,24 +541,25 @@ ruby.pc: $(filter-out ruby.pc,$(ruby_pc))
 #    Just update the version in the title of NEWS.md.
 
 matz: up
-matz: OLD := $(MAJOR).$(MINOR).0
+matz-commit: OLD := $(MAJOR).$(MINOR).0
 ifdef NEW
-matz: MAJOR := $(word 1,$(subst ., ,$(NEW)))
-matz: MINOR := $(word 2,$(subst ., ,$(NEW)))
-matz: $(DOT_WAIT) bump_news
+matz-commit: MAJOR := $(word 1,$(subst ., ,$(NEW)))
+matz-commit: MINOR := $(word 2,$(subst ., ,$(NEW)))
+matz-commit: $(DOT_WAIT) bump_news
 bump_news$(DOT_WAIT): up
 bump_headers$(DOT_WAIT): bump_news
 else
-matz: MINOR := $(shell expr $(MINOR) + 1)
-matz: $(DOT_WAIT) reset_news
+matz-commit: MINOR := $(shell expr $(MINOR) + 1)
+matz-commit: $(DOT_WAIT) reset_news
 flush_news$(DOT_WAIT): up
 bump_headers$(DOT_WAIT): reset_news
 endif
 
-matz: $(DOT_WAIT) bump_headers
-matz: override NEW := $(MAJOR).$(MINOR).0
-matz: files := include/ruby/version.h include/ruby/internal/abi.h
-matz: message := Development of $(NEW) started.
+matz: $(DOT_WAIT) matz-commit
+matz-commit: bump_headers
+matz-commit: override NEW := $(MAJOR).$(MINOR).0
+matz-commit: files := include/ruby/version.h include/ruby/internal/abi.h
+matz-commit: message := Development of $(NEW) started.
 
 flush_news:
 	$(GIT_IN_SRC) mv -f NEWS.md doc/NEWS/NEWS-$(OLD).md
@@ -589,10 +590,23 @@ bump_news:
 	-e 'BEGIN {new = ARGV.shift; print gets("").sub(/Ruby \K[0-9.]+/, new)}' \
 	$(NEW) NEWS.md
 
-matz:
+matz: matz-commit matz-push
+
+matz-commit:
 	$(GIT_IN_SRC) add NEWS.md $(files)
 	$(GIT_IN_SRC) commit -m "$(message)"
 
+GIT_REMOTE_ORIGIN = origin
+
+matz-push: matz-commit
+	$(eval origin_url := $(shell $(GIT_IN_SRC) remote get-url $(GIT_REMOTE_ORIGIN)))
+	$(if $(origin_url),,@false)
+	$(eval last_commit := $(shell $(GIT_IN_SRC) log -n1 --format=%H --author=matz HEAD~..HEAD))
+	$(if $(last_commit),,$(ECHO) No matz commits 1>&2; false)
+	$(if $(filter 12-25 12-26,$(shell date +%m-%d)),,$(ECHO) Not the release date 1>&2; false)
+	$(ECHO) $$'\e[31m'Pushing to $$'\e[7m'$(GIT_REMOTE_ORIGIN)$$'\e[27m'" ($(origin_url))"$$'\e[m'
+	$(GIT_IN_SRC) push $(GIT_REMOTE_ORIGIN)
+
 tags:
 	$(MAKE) GIT="$(GIT)" -C "$(srcdir)" -f defs/tags.mk
 

From 73be9992e93072be803ffd5173e29dcf597e04ef Mon Sep 17 00:00:00 2001
From: Jean Boussier <jean.boussier@gmail.com>
Date: Sun, 11 Jan 2026 09:54:18 +0100
Subject: [PATCH 2/4] Disambiguate private and public RSTRUCT_ helpers

RSTRUCT_LEN / RSTRUCT_GET / RSTRUCT_SET all existing in two
versions, one public that does type and frozens checks
and one private that doesn't.

The problem is that this is error prone because the public version
is always accessible, but the private one require to include
`internal/struct.h`. So you may have some code that rely on the
public version, and later on the private header is included and
changes the behavior.

This already led to introducing a bug in YJIT & ZJIT:
https://github.com/ruby/ruby/pull/15835
---
 gc.c              |  5 ++-
 internal/range.h  |  6 ++--
 internal/struct.h | 38 +++++---------------
 marshal.c         |  4 +--
 ractor.c          |  4 +--
 struct.c          | 88 +++++++++++++++++++++++------------------------
 vm_insnhelper.c   |  4 +--
 7 files changed, 64 insertions(+), 85 deletions(-)

diff --git a/gc.c b/gc.c
index e81c004bd88bea..1fe3dbf0aebb4b 100644
--- a/gc.c
+++ b/gc.c
@@ -2461,9 +2461,8 @@ rb_obj_memsize_of(VALUE obj)
         break;
 
       case T_STRUCT:
-        if ((RBASIC(obj)->flags & RSTRUCT_EMBED_LEN_MASK) == 0 &&
-            RSTRUCT(obj)->as.heap.ptr) {
-            size += sizeof(VALUE) * RSTRUCT_LEN(obj);
+        if (RSTRUCT_EMBED_LEN(obj) == 0) {
+            size += sizeof(VALUE) * RSTRUCT_LEN_RAW(obj);
         }
         break;
 
diff --git a/internal/range.h b/internal/range.h
index 2394937bf87461..80493ce13e4008 100644
--- a/internal/range.h
+++ b/internal/range.h
@@ -18,19 +18,19 @@ static inline VALUE RANGE_EXCL(VALUE r);
 static inline VALUE
 RANGE_BEG(VALUE r)
 {
-    return RSTRUCT(r)->as.ary[0];
+    return RSTRUCT_GET_RAW(r, 0);
 }
 
 static inline VALUE
 RANGE_END(VALUE r)
 {
-    return RSTRUCT_GET(r, 1);
+    return RSTRUCT_GET_RAW(r, 1);
 }
 
 static inline VALUE
 RANGE_EXCL(VALUE r)
 {
-    return RSTRUCT_GET(r, 2);
+    return RSTRUCT_GET_RAW(r, 2);
 }
 
 VALUE
diff --git a/internal/struct.h b/internal/struct.h
index 337f96a336d796..d3c81573931cfa 100644
--- a/internal/struct.h
+++ b/internal/struct.h
@@ -49,36 +49,16 @@ struct RStruct {
 
 #define RSTRUCT(obj) ((struct RStruct *)(obj))
 
-#ifdef RSTRUCT_LEN
-# undef RSTRUCT_LEN
-#endif
-
-#ifdef RSTRUCT_PTR
-# undef RSTRUCT_PTR
-#endif
-
-#ifdef RSTRUCT_SET
-# undef RSTRUCT_SET
-#endif
-
-#ifdef RSTRUCT_GET
-# undef RSTRUCT_GET
-#endif
-
-#define RSTRUCT_LEN internal_RSTRUCT_LEN
-#define RSTRUCT_SET internal_RSTRUCT_SET
-#define RSTRUCT_GET internal_RSTRUCT_GET
-
 /* struct.c */
 VALUE rb_struct_init_copy(VALUE copy, VALUE s);
 VALUE rb_struct_lookup(VALUE s, VALUE idx);
 VALUE rb_struct_s_keyword_init(VALUE klass);
 static inline long RSTRUCT_EMBED_LEN(VALUE st);
-static inline long RSTRUCT_LEN(VALUE st);
+static inline long RSTRUCT_LEN_RAW(VALUE st);
 static inline int RSTRUCT_LENINT(VALUE st);
 static inline const VALUE *RSTRUCT_CONST_PTR(VALUE st);
-static inline void RSTRUCT_SET(VALUE st, long k, VALUE v);
-static inline VALUE RSTRUCT_GET(VALUE st, long k);
+static inline void RSTRUCT_SET_RAW(VALUE st, long k, VALUE v);
+static inline VALUE RSTRUCT_GET_RAW(VALUE st, long k);
 
 static inline long
 RSTRUCT_EMBED_LEN(VALUE st)
@@ -89,7 +69,7 @@ RSTRUCT_EMBED_LEN(VALUE st)
 }
 
 static inline long
-RSTRUCT_LEN(VALUE st)
+RSTRUCT_LEN_RAW(VALUE st)
 {
     if (FL_TEST_RAW(st, RSTRUCT_EMBED_LEN_MASK)) {
         return RSTRUCT_EMBED_LEN(st);
@@ -102,7 +82,7 @@ RSTRUCT_LEN(VALUE st)
 static inline int
 RSTRUCT_LENINT(VALUE st)
 {
-    return rb_long2int(RSTRUCT_LEN(st));
+    return rb_long2int(RSTRUCT_LEN_RAW(st));
 }
 
 static inline const VALUE *
@@ -119,13 +99,13 @@ RSTRUCT_CONST_PTR(VALUE st)
 }
 
 static inline void
-RSTRUCT_SET(VALUE st, long k,  VALUE v)
+RSTRUCT_SET_RAW(VALUE st, long k,  VALUE v)
 {
     RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[k], v);
 }
 
 static inline VALUE
-RSTRUCT_GET(VALUE st, long k)
+RSTRUCT_GET_RAW(VALUE st, long k)
 {
     return RSTRUCT_CONST_PTR(st)[k];
 }
@@ -137,7 +117,7 @@ RSTRUCT_FIELDS_OBJ(VALUE st)
     VALUE fields_obj;
     if (embed_len) {
         RUBY_ASSERT(!FL_TEST_RAW(st, RSTRUCT_GEN_FIELDS));
-        fields_obj = RSTRUCT_GET(st, embed_len);
+        fields_obj = RSTRUCT_GET_RAW(st, embed_len);
     }
     else {
         fields_obj = RSTRUCT(st)->as.heap.fields_obj;
@@ -151,7 +131,7 @@ RSTRUCT_SET_FIELDS_OBJ(VALUE st, VALUE fields_obj)
     const long embed_len = RSTRUCT_EMBED_LEN(st);
     if (embed_len) {
         RUBY_ASSERT(!FL_TEST_RAW(st, RSTRUCT_GEN_FIELDS));
-        RSTRUCT_SET(st, embed_len, fields_obj);
+        RSTRUCT_SET_RAW(st, embed_len, fields_obj);
     }
     else {
         RB_OBJ_WRITE(st, &RSTRUCT(st)->as.heap.fields_obj, fields_obj);
diff --git a/marshal.c b/marshal.c
index 8cd4dc6079a39a..9d9a83097ce267 100644
--- a/marshal.c
+++ b/marshal.c
@@ -1084,7 +1084,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
           case T_STRUCT:
             w_class(TYPE_STRUCT, obj, arg, TRUE);
             {
-                long len = RSTRUCT_LEN(obj);
+                long len = RSTRUCT_LEN_RAW(obj);
                 VALUE mem;
                 long i;
 
@@ -1092,7 +1092,7 @@ w_object(VALUE obj, struct dump_arg *arg, int limit)
                 mem = rb_struct_members(obj);
                 for (i=0; i<len; i++) {
                     w_symbol(RARRAY_AREF(mem, i), arg);
-                    w_object(RSTRUCT_GET(obj, i), arg, limit);
+                    w_object(RSTRUCT_GET_RAW(obj, i), arg, limit);
                 }
             }
             break;
diff --git a/ractor.c b/ractor.c
index f4c2e243be02e3..2dcbbd10a054bc 100644
--- a/ractor.c
+++ b/ractor.c
@@ -1348,7 +1348,7 @@ obj_traverse_i(VALUE obj, struct obj_traverse_data *data)
 
       case T_STRUCT:
         {
-            long len = RSTRUCT_LEN(obj);
+            long len = RSTRUCT_LEN_RAW(obj);
             const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
 
             for (long i=0; i<len; i++) {
@@ -1909,7 +1909,7 @@ obj_traverse_replace_i(VALUE obj, struct obj_traverse_replace_data *data)
 
       case T_STRUCT:
         {
-            long len = RSTRUCT_LEN(obj);
+            long len = RSTRUCT_LEN_RAW(obj);
             const VALUE *ptr = RSTRUCT_CONST_PTR(obj);
 
             for (long i=0; i<len; i++) {
diff --git a/struct.c b/struct.c
index 145d65f389d6d0..65410ebdf302b8 100644
--- a/struct.c
+++ b/struct.c
@@ -83,9 +83,9 @@ rb_struct_members(VALUE s)
 {
     VALUE members = rb_struct_s_members(rb_obj_class(s));
 
-    if (RSTRUCT_LEN(s) != RARRAY_LEN(members)) {
+    if (RSTRUCT_LEN_RAW(s) != RARRAY_LEN(members)) {
         rb_raise(rb_eTypeError, "struct size differs (%ld required %ld given)",
-                 RARRAY_LEN(members), RSTRUCT_LEN(s));
+                 RARRAY_LEN(members), RSTRUCT_LEN_RAW(s));
     }
     return members;
 }
@@ -161,10 +161,10 @@ struct_member_pos(VALUE s, VALUE name)
     mask = RARRAY_LEN(back);
 
     if (mask <= AREF_HASH_THRESHOLD) {
-        if (UNLIKELY(RSTRUCT_LEN(s) != mask)) {
+        if (UNLIKELY(RSTRUCT_LEN_RAW(s) != mask)) {
             rb_raise(rb_eTypeError,
                      "struct size differs (%ld required %ld given)",
-                     mask, RSTRUCT_LEN(s));
+                     mask, RSTRUCT_LEN_RAW(s));
         }
         for (j = 0; j < mask; j++) {
             if (RARRAY_AREF(back, j) == name)
@@ -173,9 +173,9 @@ struct_member_pos(VALUE s, VALUE name)
         return -1;
     }
 
-    if (UNLIKELY(RSTRUCT_LEN(s) != FIX2INT(RARRAY_AREF(back, mask-1)))) {
+    if (UNLIKELY(RSTRUCT_LEN_RAW(s) != FIX2INT(RARRAY_AREF(back, mask-1)))) {
         rb_raise(rb_eTypeError, "struct size differs (%d required %ld given)",
-                 FIX2INT(RARRAY_AREF(back, mask-1)), RSTRUCT_LEN(s));
+                 FIX2INT(RARRAY_AREF(back, mask-1)), RSTRUCT_LEN_RAW(s));
     }
 
     mask -= 3;
@@ -235,7 +235,7 @@ rb_struct_getmember(VALUE obj, ID id)
     VALUE slot = ID2SYM(id);
     int i = struct_member_pos(obj, slot);
     if (i != -1) {
-        return RSTRUCT_GET(obj, i);
+        return RSTRUCT_GET_RAW(obj, i);
     }
     rb_name_err_raise("'%1$s' is not a struct member", obj, ID2SYM(id));
 
@@ -733,7 +733,7 @@ struct_hash_set_i(VALUE key, VALUE val, VALUE arg)
     }
     else {
         rb_struct_modify(args->self);
-        RSTRUCT_SET(args->self, i, val);
+        RSTRUCT_SET_RAW(args->self, i, val);
     }
     return ST_CONTINUE;
 }
@@ -782,7 +782,7 @@ rb_struct_initialize_m(int argc, const VALUE *argv, VALUE self)
             rb_raise(rb_eArgError, "struct size differs");
         }
         for (long i=0; i<argc; i++) {
-            RSTRUCT_SET(self, i, argv[i]);
+            RSTRUCT_SET_RAW(self, i, argv[i]);
         }
         if (n > argc) {
             rb_mem_clear((VALUE *)RSTRUCT_CONST_PTR(self)+argc, n-argc);
@@ -917,8 +917,8 @@ rb_struct_each(VALUE s)
     long i;
 
     RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
-    for (i=0; i<RSTRUCT_LEN(s); i++) {
-        rb_yield(RSTRUCT_GET(s, i));
+    for (i=0; i<RSTRUCT_LEN_RAW(s); i++) {
+        rb_yield(RSTRUCT_GET_RAW(s, i));
     }
     return s;
 }
@@ -955,16 +955,16 @@ rb_struct_each_pair(VALUE s)
     RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
     members = rb_struct_members(s);
     if (rb_block_pair_yield_optimizable()) {
-        for (i=0; i<RSTRUCT_LEN(s); i++) {
+        for (i=0; i<RSTRUCT_LEN_RAW(s); i++) {
             VALUE key = rb_ary_entry(members, i);
-            VALUE value = RSTRUCT_GET(s, i);
+            VALUE value = RSTRUCT_GET_RAW(s, i);
             rb_yield_values(2, key, value);
         }
     }
     else {
-        for (i=0; i<RSTRUCT_LEN(s); i++) {
+        for (i=0; i<RSTRUCT_LEN_RAW(s); i++) {
             VALUE key = rb_ary_entry(members, i);
-            VALUE value = RSTRUCT_GET(s, i);
+            VALUE value = RSTRUCT_GET_RAW(s, i);
             rb_yield(rb_assoc_new(key, value));
         }
     }
@@ -989,7 +989,7 @@ inspect_struct(VALUE s, VALUE prefix, int recur)
     }
 
     members = rb_struct_members(s);
-    len = RSTRUCT_LEN(s);
+    len = RSTRUCT_LEN_RAW(s);
 
     for (i=0; i<len; i++) {
         VALUE slot;
@@ -1010,7 +1010,7 @@ inspect_struct(VALUE s, VALUE prefix, int recur)
             rb_str_append(str, rb_inspect(slot));
         }
         rb_str_cat2(str, "=");
-        rb_str_append(str, rb_inspect(RSTRUCT_GET(s, i)));
+        rb_str_append(str, rb_inspect(RSTRUCT_GET_RAW(s, i)));
     }
     rb_str_cat2(str, ">");
 
@@ -1051,7 +1051,7 @@ rb_struct_inspect(VALUE s)
 static VALUE
 rb_struct_to_a(VALUE s)
 {
-    return rb_ary_new4(RSTRUCT_LEN(s), RSTRUCT_CONST_PTR(s));
+    return rb_ary_new4(RSTRUCT_LEN_RAW(s), RSTRUCT_CONST_PTR(s));
 }
 
 /*
@@ -1080,13 +1080,13 @@ rb_struct_to_a(VALUE s)
 static VALUE
 rb_struct_to_h(VALUE s)
 {
-    VALUE h = rb_hash_new_with_size(RSTRUCT_LEN(s));
+    VALUE h = rb_hash_new_with_size(RSTRUCT_LEN_RAW(s));
     VALUE members = rb_struct_members(s);
     long i;
     int block_given = rb_block_given_p();
 
-    for (i=0; i<RSTRUCT_LEN(s); i++) {
-        VALUE k = rb_ary_entry(members, i), v = RSTRUCT_GET(s, i);
+    for (i=0; i<RSTRUCT_LEN_RAW(s); i++) {
+        VALUE k = rb_ary_entry(members, i), v = RSTRUCT_GET_RAW(s, i);
         if (block_given)
             rb_hash_set_pair(h, rb_yield_values(2, k, v));
         else
@@ -1127,7 +1127,7 @@ rb_struct_deconstruct_keys(VALUE s, VALUE keys)
                  rb_obj_class(keys));
 
     }
-    if (RSTRUCT_LEN(s) < RARRAY_LEN(keys)) {
+    if (RSTRUCT_LEN_RAW(s) < RARRAY_LEN(keys)) {
         return rb_hash_new_with_size(0);
     }
     h = rb_hash_new_with_size(RARRAY_LEN(keys));
@@ -1137,7 +1137,7 @@ rb_struct_deconstruct_keys(VALUE s, VALUE keys)
         if (i < 0) {
             return h;
         }
-        rb_hash_aset(h, key, RSTRUCT_GET(s, i));
+        rb_hash_aset(h, key, RSTRUCT_GET_RAW(s, i));
     }
     return h;
 }
@@ -1149,12 +1149,12 @@ rb_struct_init_copy(VALUE copy, VALUE s)
     long i, len;
 
     if (!OBJ_INIT_COPY(copy, s)) return copy;
-    if (RSTRUCT_LEN(copy) != RSTRUCT_LEN(s)) {
+    if (RSTRUCT_LEN_RAW(copy) != RSTRUCT_LEN_RAW(s)) {
         rb_raise(rb_eTypeError, "struct size mismatch");
     }
 
-    for (i=0, len=RSTRUCT_LEN(copy); i<len; i++) {
-        RSTRUCT_SET(copy, i, RSTRUCT_GET(s, i));
+    for (i=0, len=RSTRUCT_LEN_RAW(copy); i<len; i++) {
+        RSTRUCT_SET_RAW(copy, i, RSTRUCT_GET_RAW(s, i));
     }
 
     return copy;
@@ -1177,7 +1177,7 @@ rb_struct_pos(VALUE s, VALUE *name)
     else {
         long len;
         i = NUM2LONG(idx);
-        len = RSTRUCT_LEN(s);
+        len = RSTRUCT_LEN_RAW(s);
         if (i < 0) {
             if (i + len < 0) {
                 *name = LONG2FIX(i);
@@ -1197,7 +1197,7 @@ static void
 invalid_struct_pos(VALUE s, VALUE idx)
 {
     if (FIXNUM_P(idx)) {
-        long i = FIX2INT(idx), len = RSTRUCT_LEN(s);
+        long i = FIX2INT(idx), len = RSTRUCT_LEN_RAW(s);
         if (i < 0) {
             rb_raise(rb_eIndexError, "offset %ld too small for struct(size:%ld)",
                      i, len);
@@ -1243,7 +1243,7 @@ rb_struct_aref(VALUE s, VALUE idx)
 {
     int i = rb_struct_pos(s, &idx);
     if (i < 0) invalid_struct_pos(s, idx);
-    return RSTRUCT_GET(s, i);
+    return RSTRUCT_GET_RAW(s, i);
 }
 
 /*
@@ -1282,7 +1282,7 @@ rb_struct_aset(VALUE s, VALUE idx, VALUE val)
     int i = rb_struct_pos(s, &idx);
     if (i < 0) invalid_struct_pos(s, idx);
     rb_struct_modify(s);
-    RSTRUCT_SET(s, i, val);
+    RSTRUCT_SET_RAW(s, i, val);
     return val;
 }
 
@@ -1300,7 +1300,7 @@ rb_struct_lookup_default(VALUE s, VALUE idx, VALUE notfound)
 {
     int i = rb_struct_pos(s, &idx);
     if (i < 0) return notfound;
-    return RSTRUCT_GET(s, i);
+    return RSTRUCT_GET_RAW(s, i);
 }
 
 static VALUE
@@ -1347,7 +1347,7 @@ struct_entry(VALUE s, long n)
 static VALUE
 rb_struct_values_at(int argc, VALUE *argv, VALUE s)
 {
-    return rb_get_values_at(s, RSTRUCT_LEN(s), argc, argv, struct_entry);
+    return rb_get_values_at(s, RSTRUCT_LEN_RAW(s), argc, argv, struct_entry);
 }
 
 /*
@@ -1377,9 +1377,9 @@ rb_struct_select(int argc, VALUE *argv, VALUE s)
     rb_check_arity(argc, 0, 0);
     RETURN_SIZED_ENUMERATOR(s, 0, 0, struct_enum_size);
     result = rb_ary_new();
-    for (i = 0; i < RSTRUCT_LEN(s); i++) {
-        if (RTEST(rb_yield(RSTRUCT_GET(s, i)))) {
-            rb_ary_push(result, RSTRUCT_GET(s, i));
+    for (i = 0; i < RSTRUCT_LEN_RAW(s); i++) {
+        if (RTEST(rb_yield(RSTRUCT_GET_RAW(s, i)))) {
+            rb_ary_push(result, RSTRUCT_GET_RAW(s, i));
         }
     }
 
@@ -1392,9 +1392,9 @@ recursive_equal(VALUE s, VALUE s2, int recur)
     long i, len;
 
     if (recur) return Qtrue; /* Subtle! */
-    len = RSTRUCT_LEN(s);
+    len = RSTRUCT_LEN_RAW(s);
     for (i=0; i<len; i++) {
-        if (!rb_equal(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i))) return Qfalse;
+        if (!rb_equal(RSTRUCT_GET_RAW(s, i), RSTRUCT_GET_RAW(s2, i))) return Qfalse;
     }
     return Qtrue;
 }
@@ -1426,7 +1426,7 @@ rb_struct_equal(VALUE s, VALUE s2)
     if (s == s2) return Qtrue;
     if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
     if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
-    if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
+    if (RSTRUCT_LEN_RAW(s) != RSTRUCT_LEN_RAW(s2)) {
         rb_bug("inconsistent struct"); /* should never happen */
     }
 
@@ -1460,9 +1460,9 @@ rb_struct_hash(VALUE s)
     VALUE n;
 
     h = rb_hash_start(rb_hash(rb_obj_class(s)));
-    len = RSTRUCT_LEN(s);
+    len = RSTRUCT_LEN_RAW(s);
     for (i = 0; i < len; i++) {
-        n = rb_hash(RSTRUCT_GET(s, i));
+        n = rb_hash(RSTRUCT_GET_RAW(s, i));
         h = rb_hash_uint(h, NUM2LONG(n));
     }
     h = rb_hash_end(h);
@@ -1475,9 +1475,9 @@ recursive_eql(VALUE s, VALUE s2, int recur)
     long i, len;
 
     if (recur) return Qtrue; /* Subtle! */
-    len = RSTRUCT_LEN(s);
+    len = RSTRUCT_LEN_RAW(s);
     for (i=0; i<len; i++) {
-        if (!rb_eql(RSTRUCT_GET(s, i), RSTRUCT_GET(s2, i))) return Qfalse;
+        if (!rb_eql(RSTRUCT_GET_RAW(s, i), RSTRUCT_GET_RAW(s2, i))) return Qfalse;
     }
     return Qtrue;
 }
@@ -1507,7 +1507,7 @@ rb_struct_eql(VALUE s, VALUE s2)
     if (s == s2) return Qtrue;
     if (!RB_TYPE_P(s2, T_STRUCT)) return Qfalse;
     if (rb_obj_class(s) != rb_obj_class(s2)) return Qfalse;
-    if (RSTRUCT_LEN(s) != RSTRUCT_LEN(s2)) {
+    if (RSTRUCT_LEN_RAW(s) != RSTRUCT_LEN_RAW(s2)) {
         rb_bug("inconsistent struct"); /* should never happen */
     }
 
@@ -1529,7 +1529,7 @@ rb_struct_eql(VALUE s, VALUE s2)
 VALUE
 rb_struct_size(VALUE s)
 {
-    return LONG2FIX(RSTRUCT_LEN(s));
+    return LONG2FIX(RSTRUCT_LEN_RAW(s));
 }
 
 /*
diff --git a/vm_insnhelper.c b/vm_insnhelper.c
index 2ad67461bb7694..9cb163e97f2d36 100644
--- a/vm_insnhelper.c
+++ b/vm_insnhelper.c
@@ -4764,7 +4764,7 @@ vm_call_opt_struct_aref0(rb_execution_context_t *ec, struct rb_calling_info *cal
     VM_ASSERT(vm_cc_cme(calling->cc)->def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_AREF);
 
     const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
-    return internal_RSTRUCT_GET(recv, off);
+    return RSTRUCT_GET_RAW(recv, off);
 }
 
 static VALUE
@@ -4789,7 +4789,7 @@ vm_call_opt_struct_aset0(rb_execution_context_t *ec, struct rb_calling_info *cal
     rb_check_frozen(recv);
 
     const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
-    internal_RSTRUCT_SET(recv, off, val);
+    RSTRUCT_SET_RAW(recv, off, val);
 
     return val;
 }

From 3363861a5af679e7027bdd744fc05d7a797ba33c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Heath=20Dutton=F0=9F=95=B4=EF=B8=8F?=
 <heathdutton@gmail.com>
Date: Sat, 10 Jan 2026 22:28:07 -0500
Subject: [PATCH 3/4] Remove RUBY_API_VERSION check in cxxanyargs.hpp

The version check used undefined macros, causing -Wundef warnings.
The conditional is no longer needed as Ruby is past version 3.1.
---
 include/ruby/backward/cxxanyargs.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/include/ruby/backward/cxxanyargs.hpp b/include/ruby/backward/cxxanyargs.hpp
index d37495dd942790..0ca2745c206969 100644
--- a/include/ruby/backward/cxxanyargs.hpp
+++ b/include/ruby/backward/cxxanyargs.hpp
@@ -510,9 +510,7 @@ struct driver {
          * this writing the  version is 2.8.  Let's warn this  later, some time
          * during 3.x.   Hopefully codes in  old (ANYARGS-ed) format  should be
          * less than now. */
-#if (RUBY_API_VERSION_MAJOR * 100 + RUBY_API_VERSION_MINOR) >= 301
         RUBY_CXX_DEPRECATED("use of ANYARGS is deprecated")
-#endif
         /// @copydoc define(VALUE klass, T mid, U func)
         /// @deprecated  Pass correctly typed function instead.
         static inline void

From a071078e907af99db737799410d713d5ec953eb7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Chris=20Hasi=C5=84ski?= <krzysztof.hasinski@gmail.com>
Date: Sun, 11 Jan 2026 03:45:44 +0100
Subject: [PATCH 4/4] pack.c: remove wasted allocation in BER integer packing

The 'w' format (BER compressed integer) was allocating an empty
string with rb_str_new(0, 0) then immediately overwriting it with
the correctly-sized allocation. Remove the wasted first allocation.

~50% improvement on BER pack benchmarks.
---
 pack.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pack.c b/pack.c
index 87a5c6787134c3..2ef826b0e2a17f 100644
--- a/pack.c
+++ b/pack.c
@@ -736,7 +736,7 @@ pack_pack(rb_execution_context_t *ec, VALUE ary, VALUE fmt, VALUE buffer)
 
           case 'w':		/* BER compressed integer  */
             while (len-- > 0) {
-                VALUE buf = rb_str_new(0, 0);
+                VALUE buf;
                 size_t numbytes;
                 int sign;
                 char *cp;