rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/param_ptr_from_callee_slot.rb.expected

@@ -0,0 +1,6 @@
+3
+true
+false
+3
+3
+2

data/vendor/spinel/test/parser_long_ast_record.rb

@@ -0,0 +1,132 @@
+# Regression for spinel_parse text-AST records longer than 4096 bytes.
+#
+# The parser's array field emitter already builds a growable string, but
+# the final out_add formatting step used to clamp the emitted line to a
+# fixed stack buffer. This array has enough elements to force the
+# `A <id> elements ...` record past that old limit; truncating it drops
+# tail elements from the compiled program.
+
+xs = [
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+]
+
+puts xs.length
+puts xs[0]
+puts xs[1179]

data/vendor/spinel/test/parser_long_ast_record.rb.expected

@@ -0,0 +1,3 @@
+1180
+0
+0

data/vendor/spinel/test/pattern_match_as_and_guard.rb

@@ -0,0 +1,33 @@
+# Issues #884 #905: pattern-match `as` binding and `if` guard
+# clause both used to leave the matched LV undeclared, causing
+# C compile errors. Now both bind correctly: CapturePatternNode
+# binds the as-var to the scrutinee at body entry; IfNode-wrapped
+# pattern AND-folds the guard against the inner match.
+
+# #884: array pattern with `=> arr` capture
+case [1, 2, 3]
+in [1, *] => arr
+  puts arr.inspect
+end
+
+# #905: guard clause with bound variable
+case 10
+in n if n > 5
+  puts "big: " + n.to_s
+in n
+  puts "small: " + n.to_s
+end
+
+# #905: guard's else branch
+case 3
+in n if n > 5
+  puts "big: " + n.to_s
+in n
+  puts "small: " + n.to_s
+end
+
+# #884: object capture
+case 42
+in Integer => v
+  puts "int: " + v.to_s
+end

data/vendor/spinel/test/pattern_match_as_and_guard.rb.expected

@@ -0,0 +1,4 @@
+[1, 2, 3]
+big: 10
+small: 3
+int: 42

data/vendor/spinel/test/pattern_match_splat_rest.rb

@@ -0,0 +1,15 @@
+# Issue #844: array pattern with `*rest` splat target. The rest LV
+# needs to be declared in the surrounding scope; pre-fix it was
+# only handled at codegen-emit, leaving lv_rest undeclared.
+case [1, 2, 3]
+in [first, *rest]
+  puts "first=" + first.to_s
+  puts "rest=" + rest.inspect
+end
+
+# `Array(...)` with capture constant + rest
+case [10, 20, 30]
+in Array(head, *tail)
+  puts "head=" + head.to_s
+  puts "tail=" + tail.inspect
+end

data/vendor/spinel/test/pattern_match_splat_rest.rb.expected

@@ -0,0 +1,4 @@
+first=1
+rest=[2, 3]
+head=10
+tail=[20, 30]

data/vendor/spinel/test/pattern_pin.rb

@@ -0,0 +1,105 @@
+# Pattern matching: PinnedExpressionNode + PinnedVariableNode.
+#
+# Pin patterns match the scrutinee by `==` against the value of an
+# existing local / ivar / arbitrary expression -- they do not bind
+# new variables. Both prism node types (PinnedVariableNode for `^var`
+# and PinnedExpressionNode for `^(expr)`) are routed through the
+# shared `@nd_expression` slot so the codegen treats them uniformly.
+
+# --- Pin against int local
+x = 42
+case 42
+in ^x
+  puts "pin int match"
+in 0
+  puts "zero"
+end
+
+# --- Pin miss falls through to next arm / else
+y = 10
+case 42
+in ^y
+  puts "pin y match"
+else
+  puts "no pin y"
+end
+
+# --- Pin against string local
+s = "hello"
+case "hello"
+in ^s
+  puts "pin str match"
+end
+
+# Pin string miss
+t = "goodbye"
+case "hello"
+in ^t
+  puts "pin t"
+else
+  puts "no pin t"
+end
+
+# --- Pin against arbitrary expression `^(expr)`
+val = 7
+case 21
+in ^(val * 3)
+  puts "pin expr 21"
+else
+  puts "miss"
+end
+
+# Pin expression with method call
+def double(n)
+  n * 2
+end
+case 14
+in ^(double(7))
+  puts "pin call 14"
+end
+
+# --- Pin against symbol
+sym = :foo
+case :foo
+in ^sym
+  puts "pin sym match"
+end
+
+# Symbol miss
+case :bar
+in ^sym
+  puts "pin sym bar"
+else
+  puts "no sym bar"
+end
+
+# --- Pin works alongside literal arms in same case
+mode = :verbose
+case :verbose
+in :quiet
+  puts "q"
+in ^mode
+  puts "pin mode hit"
+in :other
+  puts "o"
+end
+
+# --- Pin against ivar
+class Box
+  def initialize(v)
+    @v = v
+  end
+
+  def matches(x)
+    case x
+    in ^@v
+      "ivar match"
+    else
+      "no match"
+    end
+  end
+end
+
+b = Box.new(99)
+puts b.matches(99)
+puts b.matches(100)

data/vendor/spinel/test/pattern_pin.rb.expected

@@ -0,0 +1,11 @@
+pin int match
+no pin y
+pin str match
+no pin t
+pin expr 21
+pin call 14
+pin sym match
+no sym bar
+pin mode hit
+ivar match
+no match

data/vendor/spinel/test/poly_arg_int_keyed_hash.rb

@@ -0,0 +1,42 @@
+# `if status.is_a?(Integer)` inside a method where status is
+# poly-typed (the method's caller-union widened it). The then-arm
+# uses status as the key into an Int-keyed hash. Pre-fix the
+# IntStrHash dispatch (`[]`, has_key?, fetch) compiled the key
+# arg via compile_arg0 / compile_expr without unboxing the poly
+# value, and the C call passed sp_RbVal to a mrb_int param,
+# tripping the C compile with int-from-pointer.
+#
+# IntStrHash's three key-receiving arms now route through
+# compile_arg0_as_int (or explicit `.v.i` unbox in fetch), which
+# detects a poly arg and emits `(arg).v.i`. At runtime the is_a?
+# guard ensures the tag is SP_TAG_INT so the unbox reads the
+# intended integer value; with no guard the unbox would still
+# compile but look up a meaningless key (no crash — union
+# type-pun is defined, just non-meaningful).
+#
+# The broader is_a? narrowing for other Int-context use sites
+# (method call args expecting mrb_int, arithmetic ops, etc.)
+# remains a separate concern.
+
+def lookup(status)
+  table = { 200 => "OK", 404 => "NotFound" }
+  if status.is_a?(Integer)
+    return table.fetch(status, "x")
+  end
+  "no"
+end
+
+puts lookup(200)
+puts lookup(404)
+puts lookup("nope")
+
+def has_status?(status)
+  table = { 200 => "OK" }
+  if status.is_a?(Integer)
+    return table.has_key?(status)
+  end
+  false
+end
+
+puts has_status?(200)
+puts has_status?("nope")

data/vendor/spinel/test/poly_arg_int_keyed_hash.rb.expected

@@ -0,0 +1,5 @@
+OK
+NotFound
+no
+true
+false

data/vendor/spinel/test/poly_arg_to_typed_method_param.rb

@@ -0,0 +1,28 @@
+# Sibling to #438. A poly local guarded by `is_a?(String)` passed
+# as a positional arg to a top-level typed-param method: the call
+# site unboxes via `(lv_v).v.s` so the const-char* parameter
+# type-checks. Same shape for Integer / Float narrows.
+
+def helper_s(s)
+  s.length
+end
+
+def encode(v)
+  return helper_s(v) if v.is_a?(String)
+  -1
+end
+
+puts encode("hello")
+puts encode(42)
+
+def helper_i(i)
+  i * 2
+end
+
+def double_if_int(v)
+  return helper_i(v) if v.is_a?(Integer)
+  0
+end
+
+puts double_if_int(7)
+puts double_if_int("nope")

data/vendor/spinel/test/poly_arg_to_typed_method_param.rb.expected

@@ -0,0 +1,4 @@
+5
+-1
+14
+0

data/vendor/spinel/test/poly_array_assoc.rb

@@ -0,0 +1,9 @@
+# Array#assoc / #rassoc on poly_array. Each element is itself a
+# sub-array; assoc(key) returns the sub-array whose first element
+# matches key, rassoc(val) matches against the second element.
+
+data = [[1, "one"], [2, "two"], [3, "three"]]
+puts data.assoc(2).inspect
+puts data.rassoc("three").inspect
+# Miss → nil.
+puts data.assoc(99).inspect

data/vendor/spinel/test/poly_array_compact.rb

@@ -0,0 +1,15 @@
+# Issue #725. `Array#compact` on a poly_array (heterogeneous elements
+# with possible nils) used to fall through to an unresolved-call
+# warning and then segfault when the caller read the result as a
+# poly_array pointer. The runtime gets sp_PolyArray_compact (drops
+# SP_TAG_NIL elements) + a codegen arm so `arr.compact` returns a
+# fresh poly_array.
+
+puts [1, nil, 2, nil, 3].compact.inspect
+
+# Heterogeneous (mix of int + string + nil) still works.
+a = [1, nil, "two", nil, :three, nil]
+puts a.compact.inspect
+
+# No-nil array passes through unchanged.
+puts [1, 2, 3].compact.inspect

data/vendor/spinel/test/poly_array_compact.rb.expected

@@ -0,0 +1,3 @@
+[1, 2, 3]
+[1, "two", :three]
+[1, 2, 3]

data/vendor/spinel/test/poly_array_compact_bang.rb

@@ -0,0 +1,17 @@
+# Array#compact! on poly_array mutates in place — shift non-nil
+# elements to the front, truncate. Returns the receiver (CRuby
+# returns nil when nothing was removed; the subset always returns
+# self since the typed array can't carry that signal).
+a = [1, nil, 2, nil, 3]
+a.compact!
+puts a.inspect
+
+# Mixed types with nils interleaved
+b = ["a", nil, :sym, nil, 42]
+b.compact!
+puts b.inspect
+
+# Already nil-free
+c = [1, "two", :three]
+c.compact!
+puts c.inspect

data/vendor/spinel/test/poly_array_compact_bang.rb.expected

@@ -0,0 +1,3 @@
+[1, 2, 3]
+["a", :sym, 42]
+[1, "two", :three]

data/vendor/spinel/test/poly_array_dup.rb

@@ -0,0 +1,52 @@
+# Issue #427. `Array#dup` on a polymorphic-element array
+# (`poly_array`) emitted the standard `cannot resolve call to
+# 'dup' on poly_array` warning AND segfaulted at runtime
+# (exit 139 / SIGSEGV). The combination of warning + crash
+# suggested partial wiring -- emit produced something but it
+# dereferenced wrong memory.
+#
+# Root cause: spinel_codegen.rb's `compile_array_method_expr`
+# had a poly_array arm but only with `length` / `[]` / `push` /
+# `clear`. `.dup` fell through to the unresolved-warning path
+# which emits `0` for the dispatch -- when the caller used that
+# `0` as `sp_PolyArray *`, the next access dereferenced NULL.
+#
+# Fix: add `.dup` / `.to_a` -> sp_PolyArray_dup (already in
+# lib/sp_runtime.h, was just unhooked) and a few sibling arms
+# (`empty?`, `first`, `last`) that the natural shape of "manage
+# a poly_array as a normal Array" needs.
+#
+# Coverage:
+#   - dup: shallow copy preserves the element variant (length
+#     equal, types preserved).
+#   - to_a: alias for dup on Array.
+#   - empty?: edge case (zero-length poly_array).
+#   - first / last: integer-key access on a poly recv that the
+#     existing `[]` arm already handled but the named-method
+#     forms didn't.
+
+a = [1, "two", :three]
+b = a.dup
+puts b.length                  # 3
+
+# Element variants preserved across dup.
+c = a.to_a
+puts c.length                  # 3
+
+# empty? on poly_array.
+empty = [1, "x"]
+puts empty.empty? ? "yes" : "no"   # no
+
+empty2 = [1, "x"]
+empty2.clear
+puts empty2.empty? ? "yes" : "no"  # yes
+
+# first / last on poly_array.
+arr = [1, "two", :three]
+# Ruby's `first` on Array of mixed types returns the first elem;
+# spinel boxes it as sp_RbVal. We don't assert exact value (the
+# poly representation isn't easily printable here); just that
+# the call doesn't crash.
+arr.first
+arr.last
+puts "ok"                          # ok

data/vendor/spinel/test/poly_array_dup.rb.expected

@@ -0,0 +1,5 @@
+3
+3
+no
+yes
+ok

data/vendor/spinel/test/poly_array_flatten.rb

@@ -0,0 +1,17 @@
+# Issue #739. Array#flatten on poly_array (deep nested) and on the
+# typed-array-of-int_array shape (uniform `[[a,b],[c,d]]` form).
+# Both used to fall through to the unresolved-call warning and
+# then segfault.
+
+# Deep recursive nesting -- poly_array recv. The runtime walker
+# recurses into IntArray / StrArray / PolyArray elements.
+puts [[1, [2, [3]]]].flatten.inspect
+
+# Heterogeneous mix of scalar + array elements.
+puts [1, "two", [3, [:four, 5.0]]].flatten.inspect
+
+# Uniform [[int...]] (typed-array-of-int_array) flattens to int_array.
+puts [[1, 2], [3, 4], [5]].flatten.inspect
+
+# Empty poly_array.
+puts [].flatten.inspect

data/vendor/spinel/test/poly_array_flatten.rb.expected

@@ -0,0 +1,4 @@
+[1, 2, 3]
+[1, "two", 3, :four, 5.0]
+[1, 2, 3, 4, 5]
+[]

data/vendor/spinel/test/poly_attr_reader_box_dispatch.expected

@@ -0,0 +1 @@
+alice

data/vendor/spinel/test/poly_attr_reader_box_dispatch.rb

@@ -0,0 +1,35 @@
+# #700 shape A: when a poly-widened setter receives an attr_reader
+# value from an int-typed LV (where codegen's
+# compile_int_class_fallback_expr picks the first class with the
+# attr_reader to emit `((sp_C *)lv)->iv_X`), the boxer dispatch
+# was picking sp_box_int on a `const char *` value.
+
+class Comment
+  attr_accessor :commenter
+
+  def []=(field, value)
+    case field
+    when :commenter then @commenter = value
+    when :other then @other = value
+    end
+  end
+end
+
+class CommentRow
+  attr_reader :commenter
+  def initialize(c); @commenter = c; end
+end
+
+# Widen Comment's @commenter to sp_RbVal via case-narrow union with int.
+seed = Comment.new
+seed[:other] = 42
+seed[:commenter] = "x"
+
+def update_from_row(c, p)
+  c.commenter = p.commenter
+end
+
+c = Comment.new
+row = CommentRow.new("alice")
+update_from_row(c, row)
+puts c.commenter

data/vendor/spinel/test/poly_attr_writer.rb

@@ -0,0 +1,95 @@
+# Regression: a setter call (`obj.x = val`) on a parameter typed as
+# a class union must execute the assignment. Previously the dispatch
+# loop emitted no arms for attr_writer setters on poly receivers and
+# silently dropped the store.
+#
+# Three subcases:
+#  1. Single class with `x`, second class without -- the union case
+#     where the dispatch arm is "skipped silently."
+#  2. Two classes share an ivar name; same value type. Verifies
+#     both arms emit and the result temp's C type fits the slot.
+#  3. Two classes share an ivar name; differing value types
+#     (string vs int). Forces the new arm to box the rhs poly-style
+#     for one cls_id and unbox for the other.
+#
+# Verifying via the *side effect* (the ivar's value) rather than the
+# setter expression's return value -- propagating setter returns
+# through the dispatch into the enclosing function's return is a
+# separate concern that this PR doesn't try to fix.
+
+# --- 1. Single class (the no-op repro) ---------------------------------
+
+class Foo
+  attr_accessor :x
+  def initialize; @x = 0; end
+end
+
+class Bar
+  # No `x`; coexists only to widen `obj` to a class union.
+end
+
+def set_x(obj, v)
+  obj.x = v
+end
+
+foo = Foo.new
+bar = Bar.new
+set_x(foo, 42)
+set_x(bar, 99) rescue nil
+
+puts foo.x
+
+
+# --- 2. Two classes share `body` (string in both) ---------------------
+
+class Req
+  attr_accessor :body
+  def initialize; @body = ""; end
+end
+
+class Res
+  attr_accessor :body
+  def initialize; @body = ""; end
+end
+
+def set_body(o, b)
+  o.body = b
+end
+
+req = Req.new
+res = Res.new
+set_body(req, "REQ")
+set_body(res, "RES")
+
+puts req.body
+puts res.body
+
+
+# --- 3. Two classes share `slot` with *different* value types ---------
+# Pre-fix poly_dispatch_return_type returned "int" for any setter
+# whose name didn't appear as an explicit method, so the result temp
+# was mrb_int and the string arm's `tmp = lv` mismatched. The new
+# arm now also unboxes the rhs to the slot's concrete type when
+# the function param widened to poly.
+
+class IBox
+  attr_accessor :slot
+  def initialize; @slot = 0; end
+end
+
+class SBox
+  attr_accessor :slot
+  def initialize; @slot = ""; end
+end
+
+def set_slot(o, v)
+  o.slot = v
+end
+
+ibox = IBox.new
+sbox = SBox.new
+set_slot(ibox, 7)
+set_slot(sbox, "hello")
+
+puts ibox.slot
+puts sbox.slot

data/vendor/spinel/test/poly_attr_writer.rb.expected

@@ -0,0 +1,5 @@
+42
+REQ
+RES
+7
+hello