[pull] master from ruby:master

.github/workflows/macos.yml

@@ -158,6 +158,7 @@ jobs:
         env:
           RUBY_TESTOPTS: '-q --tty=no'
           TEST_BUNDLED_GEMS_ALLOW_FAILURES: ''
+          RUBY_DEBUG_TEST_NO_REMOTE: "1"
           PRECHECK_BUNDLED_GEMS: 'no'
           LAUNCHABLE_STDOUT: ${{ steps.launchable.outputs.stdout_report_path }}
           LAUNCHABLE_STDERR: ${{ steps.launchable.outputs.stderr_report_path }}

NEWS.md

@@ -29,6 +29,9 @@ Note: We're only listing outstanding class updates.
 
     * `Array#pack` accepts new formats `R` and `r` for unsigned and signed
       LEB128 encoded integers. [[Feature #21785]]
+    * `Array#pack` accepts new formats `x!` and `@!` to align the current
+      offset to a byte boundary or to the ABI alignment of another
+      directive. [[Feature #22185]]
 
 * ENV
 
@@ -61,6 +64,11 @@ Note: We're only listing outstanding class updates.
       ineffect inside its body, without affecting the original Proc.
       [[Feature #22097]]
 
+* Range
+
+    * `Range#clamp` is added. It returns a new `Range` instance whose
+      begin and end values are clamped to the given bounds. [[Feature #22175]]
+
 * Regexp
 
     * All instances of `Regexp` are now frozen, not just literals.
@@ -79,6 +87,9 @@ Note: We're only listing outstanding class updates.
     * `String#unpack` and `String#unpack1` accept a new format `^` that
       returns the current offset.  Useful when combined with variable
       width formats like LEB128. [[Feature #21796]]
+    * `String#unpack` and `String#unpack1` accept new formats `x!` and
+      `@!` to align the current offset to a byte boundary or to the ABI
+      alignment of another directive. [[Feature #22185]]
 
 * Symbol
 
@@ -239,6 +250,8 @@ A lot of work has gone into making Ractors more stable, performant, and usable.
 [Feature #21981]: https://bugs.ruby-lang.org/issues/21981
 [Feature #22137]: https://bugs.ruby-lang.org/issues/22137
 [Feature #22139]: https://bugs.ruby-lang.org/issues/22139
+[Feature #22175]: https://bugs.ruby-lang.org/issues/22175
+[Feature #22185]: https://bugs.ruby-lang.org/issues/22185
 [PR #17201]: https://github.com/ruby/ruby/pull/17201
 [RubyGems-v4.0.4]: https://github.com/rubygems/rubygems/releases/tag/v4.0.4
 [RubyGems-v4.0.5]: https://github.com/rubygems/rubygems/releases/tag/v4.0.5

bootstraptest/test_ractor.rb

@@ -656,6 +656,29 @@ def check obj1
   end
 }
 
+# move preserves aliasing inside the moved object graph
+assert_equal 'true', %q{
+  r = Ractor.new do
+    Ractor.receive
+  end
+
+  leaf = +"leaf"
+  moved = r.send([leaf, leaf], move: true).value
+  moved[0].equal?(moved[1])
+}
+
+# move handles cyclic references safely and preserves aliasing
+assert_equal 'true', %q{
+  r = Ractor.new do
+    Ractor.receive
+  end
+
+  a = []
+  a << a
+  moved = r.send(a, move: true).value
+  moved.equal?(moved[0])
+}
+
 # unshareable frozen objects should still be frozen in new ractor after move
 assert_equal 'true', %q{
   r = Ractor.new do
@@ -2668,3 +2691,27 @@ def foo(a:, b:, c:) = super(a: a, b: b, c: c)
     :ok  # platform without fork
   end
 }
+
+# A moved object's source is neutralized into a RactorMovedObject husk that
+# stays in its original (possibly larger) slot. It must be given a shape whose
+# slot size matches that slot, or a later compaction in the receiver trips the
+# slot_size == shape_slot_size invariant (RGENGC_CHECK_MODE) / corrupts the slot.
+assert_equal 'ok', %q{
+  r = Ractor.new do
+    while (o = Ractor.receive)
+      begin
+        GC.compact
+      rescue NotImplementedError
+        # no-op on platforms without GC.compact (e.g. MMTk)
+      end
+    end
+    :ok
+  end
+  500.times do
+    o = Object.new
+    12.times { |i| o.instance_variable_set("@i#{i}", i) }  # overflow to a larger slot
+    r.send(o, move: true)
+  end
+  r.send(nil)
+  r.value
+}

cygwin/GNUmakefile.in

@@ -16,7 +16,6 @@ ifeq ($(target_os),cygwin)
   DLL_BASE_NAME := $(LIBRUBY_SO:.dll=)
 else
   DLL_BASE_NAME := $(RUBY_SO_NAME)
-  DLLWRAP += -mno-cygwin
   VPATH := $(VPATH):$(srcdir)/win32
   ifneq ($(filter -flto%,$(LDFLAGS)),)
     miniruby$(EXEEXT): XLDFLAGS += -Wno-maybe-uninitialized

debug.c

@@ -52,7 +52,6 @@ const union {
     enum ruby_econv_flag_type   econv_flag_types;
     rb_econv_result_t           econv_result;
     enum ruby_preserved_encindex encoding_index;
-    enum ruby_robject_flags     robject_flags;
     enum ruby_rmodule_flags     rmodule_flags;
     enum ruby_rstring_flags     rstring_flags;
     enum ruby_rarray_flags      rarray_flags;

doc/language/packed_data.md

@@ -879,6 +879,32 @@ for one byte in the input or output string.
     "\x00\x00\x02".unpack("x4C") # Raises ArgumentError
     ```
 
+- `'x!'` - Align to the given byte boundary or directive alignment;
+  for packing, null fill if necessary.  With `buffer:` or `offset:`,
+  alignment is relative to the starting position:
+
+    ```ruby
+    [1, 2].pack("C x!4 C") # => "\x01\x00\x00\x00\x02"
+    [1, 2].pack("C x!i i") # Aligns to the native int alignment.
+    ```
+
+    For unpacking, skip forward to the aligned offset:
+
+    ```ruby
+    "\x01\x00\x00\x00\x02".unpack("C x!4 C") # => [1, 2]
+    ```
+
+- `'@!'` - Align to the given byte boundary or directive alignment
+  from the beginning of the output or input string:
+
+    ```ruby
+    buffer = +"z"
+    [1, 2].pack("C @!4 C", buffer: buffer)
+    buffer # => "z\x01\x00\x00\x02"
+
+    "z\x01\x00\x00\x02".unpack("C @!4 C", offset: 1) # => [1, 2]
+    ```
+
 - `'^'` - Only for unpacking; the current position:
 
     ```ruby

ext/objspace/objspace_dump.c

@@ -591,17 +591,23 @@ dump_object(VALUE obj, struct dump_config *dc)
         dump_append(dc, "\"");
         break;
 
-      case T_OBJECT:
-        if (!FL_TEST_RAW(obj, ROBJECT_HEAP)) {
+      case T_OBJECT: {
+        shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
+
+        if (rb_shape_embedded_p(shape_id)) {
             dump_append(dc, ", \"embedded\":true");
         }
 
         dump_append(dc, ", \"ivars\":");
-        dump_append_lu(dc, ROBJECT_FIELDS_COUNT(obj));
-        if (rb_obj_shape_complex_p(obj)) {
+        if (rb_shape_complex_p(shape_id)) {
+            dump_append_lu(dc, rb_st_table_size(rb_imemo_fields_complex_tbl(ROBJECT_FIELDS_OBJ(obj))));
             dump_append(dc, ", \"complex_shape\":true");
         }
+        else {
+            dump_append_lu(dc, RSHAPE_LEN(shape_id));
+        }
         break;
+      }
 
       case T_FILE:
         fptr = RFILE(obj)->fptr;