Enumerator: Yielder#yield returns nil; Yielder inherits Object (fixes #905) (#907)

Two bugs made `r = []; Enumerator.new { |y| r << y.yield(1) }.to_a; p r`
abort the process (non-unwinding panic in `Value::as_array`):

1. The generator driver `generator_yield_values` resumed the fiber with the
   `yielder` on *every* activation. The yielder is only the block parameter
   on the first (Created) activation; on later resumes that value becomes
   the return value of the `y.yield(...)` that suspended, so `Yielder#yield`
   returned the Yielder itself instead of nil (CRuby returns nil for
   each/to_a). That leaked a Yielder into user data. Resume with `Value::nil()`.

2. `Enumerator::Yielder` was defined as a subclass of `Array`, but a yielder
   is a plain OBJECT-typed RValue. Inherited `Array#inspect` (etc.) then ran
   `Value::as_array` on a non-array and hit the assertion, aborting the
   process the moment such a leaked Yielder was inspected. Make `Yielder`
   inherit `Object`, as in CRuby (`Enumerator::Yielder.superclass == Object`);
   its `<<` / `yield` are defined directly.

With both fixes the repro prints `[nil]` and `Yielder#yield` returns nil,
matching CRuby. core/enumerator/new_spec no longer crashes and its
`#yield returns nil` example passes, so its spec/tags entry is removed.
Full lib suite: 1828 passed.


Claude-Session: https://claude.ai/code/session_01XpzdoFu46d2ChJpSzeWsNK

Co-authored-by: Claude <noreply@anthropic.com>

Author: sisshiki1969

doc/ruby_spec_skip_tags.md

@@ -186,30 +186,33 @@ Mutex/Queue/Thread の状態）を残し、*後続*ファイルをハングさ
   crash/hang の原因は *特定の1〜数 example* に限られることを突き止め、その example
   だけを `fails:` タグで除外すれば残りは完走することを確認したため、すべて tags へ
   移行した。
-- `spec/tags/`: **11 ファイル**。各ファイルで crash/hang する example のみ除外:
+- `spec/tags/`: **10 ファイル**。各ファイルで crash/hang する example のみ除外:
   - I/O 系ブロッキング（tag 適用で fast-path 完走）: `core/argf/read`
     （`/dev/zero` 無限読み）、`core/argf/readlines`、`core/io/copy_stream`、
     `core/io/select`（2件）、`library/socket/socket/{tcp,udp}_server_loop`、
     `library/expect/expect`（`IO#expect` がブロックする4件のみ。閉じた IO / EOF の
     2件は即返るので除外しない）。
-  - CRASH / プロセス死（1 example ずつ）:
-    - `core/enumerator/new` — `Enumerator.new when passed a block #yield returns nil`。
-      `Yielder#yield` の戻り値を使うと `Value::as_array`（`value.rs:2272`）で非巻き
-      戻し panic → プロセス abort。**本体バグ（issue #905）**。tag は暫定回避で、
-      根治すれば tag を外して13 example を復帰できる。
-    - `core/exception/{signal_exception,signm,signo}` —
-      `Process.kill(:TERM, Process.pid)` を実行する example。monoruby は SIGTERM を
-      rescue 可能な `SignalException` に変換しないためプロセスが終了する。
-      `signal_exception` は他15 example が復帰。`signm`/`signo` は example が1件だけ
-      なので実効は skip と同じ（tag で統一）。
+  - プロセス死（1 example ずつ）: `core/exception/{signal_exception,signm,signo}` —
+    `Process.kill(:TERM, Process.pid)` を実行する example。monoruby は SIGTERM を
+    rescue 可能な `SignalException` に変換しないためプロセスが終了する。
+    `signal_exception` は他15 example が復帰。`signm`/`signo` は example が1件だけ
+    なので実効は skip と同じ（tag で統一）。
+  - （`core/enumerator/new` は issue #905 の `as_array` panic を根治したため tag を
+    撤去。`#yield returns nil` は現在 pass する。）
   - CI 側で tags のコピー先を `spec/tags/ruby/` に修正済み（上部「更新」参照）なので
     `mspec ci` がタグを読み、crash/hang する example だけ除外して fast-path が完走する。
   - `library/cgi/unescapeURIComponent` は報告にあったが実際はハングしない
     （約0.35秒）ので対象外。
 
 ## フォローアップ
 
-- **`core/enumerator/new` の `as_array` panic**（issue #905）を根治し、tag を外す。
+- ~~**`core/enumerator/new` の `as_array` panic**（issue #905）~~ — **修正済み**。
+  真因は2点: (1) generator の駆動（`generator_yield_values`）が resume 時にも
+  `yielder` を渡していたため `Yielder#yield` が nil ではなく Yielder 自身を返し、
+  ユーザ側（`r << y.yield(1)`）へ Yielder が漏れていた。(2) `Yielder` が `Array` の
+  サブクラスで、継承した `Array#inspect` 等が非配列の Yielder に `Value::as_array`
+  を実行して非巻き戻し panic → abort。resume 値を `nil` にし、`Yielder` の親クラスを
+  `Object` に変更（CRuby 準拠）。tag は撤去し `#yield returns nil` は pass する。
 - **SIGTERM → `SignalException` 変換**（signal handling の実装）を入れれば
   `signal_exception`/`signm`/`signo` の該当 example と tag を外せる。
 - ~~**`core/io` の fd 二重クローズ crash**~~ — **修正済み**。原因は

monoruby/src/builtins/enumerator.rs

@@ -29,8 +29,13 @@ pub(super) fn init(globals: &mut Globals) {
     globals.define_builtin_func(ENUMERATOR_CLASS, "rewind", rewind, 0);
     globals.define_builtin_funcs(ENUMERATOR_CLASS, "size", &["length"], enumerator_size, 0);
 
-    let array_class = globals[ARRAY_CLASS].get_module();
-    let yielder = globals.define_class("Yielder", array_class, ENUMERATOR_CLASS);
+    // `Enumerator::Yielder` inherits from `Object` (as in CRuby), NOT `Array`.
+    // The yielder object is a plain OBJECT-typed RValue; inheriting `Array`
+    // meant inherited methods like `Array#inspect` ran `Value::as_array` on a
+    // non-array and aborted the process (e.g. `p` on a value that had leaked a
+    // Yielder). Its `<<` / `yield` are defined directly below.
+    let object_class = globals[OBJECT_CLASS].get_module();
+    let yielder = globals.define_class("Yielder", object_class, ENUMERATOR_CLASS);
     unsafe { YIELDER_INIT.call_once(|| YIELDER = Some(yielder)) }
     globals.define_builtin_func(yielder.id(), "<<", yielder_push, 1);
     globals.define_builtin_func_rest(yielder.id(), "yield", yielder_yield);
@@ -461,6 +466,34 @@ mod tests {
         );
     }
 
+    #[test]
+    fn yielder_yield_returns_nil() {
+        // Issue #905: `Yielder#yield` must return nil (the value fed back on
+        // resume), not the Yielder itself. Previously the generator driver
+        // resumed the fiber with the yielder, so `y.yield(x)` returned the
+        // Yielder; capturing it (`r << y.yield(1)`) leaked a Yielder into user
+        // data, and inspecting it aborted the process (Array#inspect ->
+        // Value::as_array on a non-array Yielder).
+        run_test(
+            r##"
+            r = []
+            Enumerator.new { |y| r << y.yield(1) }.to_a
+            r
+            "##,
+        );
+        run_test("Enumerator.new { |y| y.yield(1) }.first; :ok");
+        // Yielder is an Object subclass (as in CRuby), and inspecting one no
+        // longer crashes.
+        run_test("Enumerator::Yielder.superclass.to_s");
+        run_test(
+            r##"
+            y = nil
+            Enumerator.new { |yy| y = yy; yy.yield 1 }.first
+            [y.class.to_s, y.is_a?(Enumerator::Yielder)]
+            "##,
+        );
+    }
+
     #[test]
     fn enumerator_with_object() {
         run_tests(&[

monoruby/src/value/rvalue/fiber.rs

@@ -129,8 +129,15 @@ impl Fiber {
         yielder: Value,
     ) -> Result<Value> {
         match self.state() {
+            // First activation: the yielder is the block parameter (`|y|`).
             FiberState::Created => self.invoke_fiber(vm, globals, &[yielder]),
-            FiberState::Suspended => self.resume_fiber(vm, yielder),
+            // Subsequent resumes: this value becomes the return value of the
+            // `y.yield(...)` that suspended the generator. For `each`/`to_a`
+            // nothing is fed back, so it must be `nil` (CRuby's `Yielder#yield`
+            // returns nil) — NOT the yielder itself, which previously leaked a
+            // `Yielder` into user code (e.g. `r << y.yield(1)`) and then
+            // aborted the process when that value was inspected.
+            FiberState::Suspended => self.resume_fiber(vm, Value::nil()),
             FiberState::Terminated => Err(MonorubyErr::stopiterationerr(
                 "iteration reached an end".to_string(),
             )),