rubyduino 0.1.1

data/vendor/spinel/test/poly_array_slot_literal.rb

@@ -0,0 +1,41 @@
+# `@arr = [a, b]` going into a poly_array slot used to compile the
+# rhs via `compile_array_literal`, which infers a typed storage
+# (ptr_array of one class for homogeneous obj literals, etc.) and
+# emits the matching `sp_PtrArray *`. The slot is `sp_PolyArray *`
+# (widened by writer-scan via heterogeneous `@arr[i] = v` writes
+# elsewhere in the class), so the resulting C contains a pointer-
+# type mismatch:
+#
+#   sp_PtrArray *_t1 = sp_PtrArray_new();
+#   sp_PtrArray_push(_t1, sp_Pad_new());
+#   self->iv_pads = _t1;          /* iv_pads is sp_PolyArray * */
+#
+# The default `-Wno-all` build accepts the cast silently and
+# coerces, but strict flags reject it as
+# `assignment to 'sp_PolyArray *' from incompatible pointer type
+# 'sp_PtrArray *'`. Even under `-Wno-all` the runtime is wrong:
+# `PolyArray_set` writes 16-byte sp_RbVal entries into 8-byte
+# PtrArray slots and silently corrupts adjacent memory.
+
+class Pad
+  def initialize(n)
+    @n = n
+    @arr = []
+    @arr << n
+  end
+  attr_reader :n
+end
+
+class Holder
+  def initialize
+    @pads = [Pad.new(10), Pad.new(20)]
+    @pads[0] = "x"   # heterogeneous []= → @pads widens to poly_array
+  end
+  attr_reader :pads
+
+  def count
+    @pads.length
+  end
+end
+
+puts Holder.new.count    # 2

data/vendor/spinel/test/poly_array_slot_sized_default.rb

@@ -0,0 +1,33 @@
+# `@arr = [nil] * N` going into a poly_array slot used to lower
+# the rhs via the default `*` codegen, which produces an sp_IntArray.
+# The slot is `sp_PolyArray *` (widened by writer-scan via
+# heterogeneous `@arr[i] = v` writes elsewhere in the class), so
+# the resulting C contains a pointer-type mismatch:
+#
+#   sp_IntArray *_t1 = sp_IntArray_new();
+#   ...
+#   self->iv_arr = _t1;          /* iv_arr is sp_PolyArray * */
+#
+# The default `-Wno-all` build silently coerces and the runtime
+# runs with garbage: subsequent `sp_PolyArray_set(@arr, ...)`
+# calls write 16-byte sp_RbVal entries into 8-byte IntArray slots,
+# corrupting adjacent memory and skewing `@arr.length`.
+#
+# An equivalent guard exists for ptr_array slots; this PR extends
+# it to poly_array slots (constructor + general InstanceVariable-
+# WriteNode paths) so the lowered storage matches the slot.
+
+class Holder
+  def initialize
+    @arr = [nil] * 3
+    @arr[0] = 42      # int
+    @arr[1] = "two"   # str — heterogeneous → @arr widens to poly_array
+  end
+  attr_reader :arr
+
+  def count
+    @arr.length
+  end
+end
+
+puts Holder.new.count   # 3

data/vendor/spinel/test/poly_box_int_array.rb

@@ -0,0 +1,13 @@
+# Built-in pointer types (IntArray, etc.) need to be boxable into a
+# poly value so they can flow through a parameter typed as poly.
+# Before this fix, `box_expr_to_poly` fell through to `sp_box_int(v)`
+# for anything that wasn't a recognized scalar / `obj_<Class>` —
+# passing a `sp_IntArray *` to `sp_box_int` (which wants `mrb_int`)
+# is a C type error, so the program simply didn't compile.
+
+def kind_of(a)
+  a.nil? ? "nil" : "something"
+end
+
+puts kind_of(Object.new)
+puts kind_of([1, 2, 3])

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

@@ -0,0 +1,2 @@
+something
+something

data/vendor/spinel/test/poly_dispatch_args_ret.rb

@@ -0,0 +1,45 @@
+# Regression test for polymorphic return flow:
+# a method returning different class instances from branches.
+
+class A
+  def read(v)
+    v + 1
+  end
+end
+
+class B
+  def read(v)
+    v + 2
+  end
+end
+
+class Builder
+  def make(flag)
+    if flag == 0
+      A.new
+    else
+      B.new
+    end
+  end
+
+  def make_with_return(flag)
+    if flag == 0
+      return A.new
+    end
+    return B.new
+  end
+end
+
+b = Builder.new
+
+obj0 = b.make(0)
+puts obj0.read(41)
+
+obj1 = b.make(1)
+puts obj1.read(41)
+
+ret0 = b.make_with_return(0)
+puts ret0.read(41)
+
+ret1 = b.make_with_return(1)
+puts ret1.read(41)

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

@@ -0,0 +1,4 @@
+42
+43
+42
+43

data/vendor/spinel/test/poly_dispatch_arity_padding.rb

@@ -0,0 +1,36 @@
+# Poly dispatch over user classes whose `m` definitions have
+# different arities — Switch#toggle takes 0 args; Knob#toggle takes
+# one positional default. Without per-arm padding, the C compiler
+# rejects the dispatch table with "too few arguments to function
+# 'sp_Knob_toggle'" (the dispatch arms have one fixed call shape
+# but the candidate methods have different arities).
+
+class Switch
+  def initialize
+    @v = 1
+  end
+  def toggle
+    @v = 0
+  end
+  attr_reader :v
+end
+
+class Knob
+  def toggle(soft = true)
+    0
+  end
+end
+
+class Box
+  def initialize
+    @items = [Switch.new, Switch.new]   # poly-typed; .toggle dispatch
+                                        # over every class with `toggle`
+  end
+  attr_reader :items
+end
+
+b = Box.new
+b.items[0].toggle
+b.items[1].toggle
+puts b.items[0].v   # 0
+puts b.items[1].v   # 0

data/vendor/spinel/test/poly_dispatch_arity_truncate.rb

@@ -0,0 +1,45 @@
+# Poly-dispatch arms must match each candidate method's *fixed* C
+# arity. The padding side (target takes more params than the call
+# supplied — defaults fill the extras) was already in place. The
+# truncate side is the complement: when a candidate class's method
+# accepts *fewer* params than the call supplied, that arm has to
+# drop the surplus to compile, even though the runtime cls_id check
+# would skip it for a non-matching receiver.
+
+class Heater
+  def initialize
+    @v = 0
+  end
+  def write(addr, data)
+    @v = addr + data
+  end
+  attr_reader :v
+end
+
+class Buzzer
+  def initialize
+    @v = 0
+  end
+  def write(addr)        # one fewer arg than Heater#write
+    @v = addr
+  end
+  attr_reader :v
+end
+
+class Box
+  def initialize
+    @poly = nil
+    @poly = "x"
+    @poly = Heater.new   # widen to poly via heterogeneous writes
+  end
+
+  attr_reader :poly
+
+  def call_write(addr, data)
+    @poly.write(addr, data)   # poly recv → arms over Heater + Buzzer
+  end
+end
+
+b = Box.new
+b.call_write(7, 5)
+puts b.poly.v   # 12  (Heater: addr + data)

data/vendor/spinel/test/poly_dispatch_attr_reader.rb

@@ -0,0 +1,44 @@
+# Issue #119: an attr_reader-defined accessor on a polymorphic
+# receiver was lost — the cls_id-keyed dispatcher in
+# `compile_poly_method_call` only walked `@cls_meth_names` and never
+# checked `@cls_attr_readers`, so the if-cascade emitted an empty
+# body and the result temp stayed at its `0` default. The same shape
+# with an explicit `def v; @v; end` worked fine.
+#
+# Fix: poly_dispatch_return_type now also unions ivar types from
+# each class's attr_readers, and the cls_id-keyed cascade emits a
+# `_t = ((sp_<C> *)recv.v.p)->iv_<name>` branch for classes that
+# only declare the accessor as an attr_reader.
+
+class C
+  def initialize(v); @v = v; end
+  attr_reader :v
+end
+
+class D
+  def initialize(v); @v = v; end
+  attr_reader :v
+end
+
+# Same return type per class (string) — result temp stays
+# `const char *`, no boxing.
+def make(flag)
+  flag ? C.new("c-val") : D.new("d-val")
+end
+
+puts make(true).v
+puts make(false).v
+
+# Mixing an explicit `def v` on one class with attr_reader on
+# others. The dispatcher must cover both shapes.
+class F
+  def initialize(v); @v = v; end
+  def v; @v; end
+end
+
+def mix(flag)
+  flag ? C.new("from-attr") : F.new("from-def")
+end
+
+puts mix(true).v
+puts mix(false).v

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

@@ -0,0 +1,4 @@
+c-val
+d-val
+from-attr
+from-def

data/vendor/spinel/test/poly_dispatch_builtin.rb

@@ -0,0 +1,16 @@
+# Polymorphic dispatch over a parameter typed `poly` should pick the
+# right `[]` based on the runtime type — a user class's `def [](x)`
+# for Foo.new, sp_IntArray_get for an Array literal.
+
+class Foo
+  def [](x)
+    42
+  end
+end
+
+def read0(a)
+  a[0]
+end
+
+puts read0(Foo.new)
+puts read0([100, 200, 300])

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

@@ -0,0 +1,2 @@
+42
+100

data/vendor/spinel/test/poly_dispatch_builtin_all.rb

@@ -0,0 +1,34 @@
+# Issue #78: poly dispatch and runtime helpers reaching all built-in
+# array types (not just IntArray). When a `poly` slot can hold any of
+# Int/Float/Str/Sym arrays plus user-class instances, dispatch on
+# `length` / `size` must pick the right helper per cls_id; `puts` /
+# `to_s` over a poly value must inspect the array, not print a raw
+# pointer.
+
+# A `length` poly dispatch — every built-in array type contributes a
+# branch returning mrb_int.
+def lenof(a)
+  a.length
+end
+
+class Box
+  def length; 99; end
+end
+
+puts lenof([1, 2, 3])         # 3   (IntArray)
+puts lenof([1.0, 2.0, 3.0])   # 3   (FloatArray)
+puts lenof(["a", "b", "c"])   # 3   (StrArray)
+puts lenof([:x, :y])          # 2   (SymArray)
+puts lenof(Box.new)           # 99  (user-class branch)
+
+# sp_poly_puts / sp_poly_to_s handle every built-in array tag: a poly
+# value carrying e.g. a FloatArray now prints via sp_FloatArray_inspect
+# instead of the raw-pointer fallback. The reach of the param-widening
+# inference (calling `show` with several built-in array types in turn)
+# is a separate concern; this test only verifies that the runtime
+# helpers route correctly when the poly already holds an array.
+mixed = [1, 2.0, "x"]   # forces poly_array; each element via sp_poly_puts
+mixed.each { |e| p e }
+# 1
+# 2.0
+# "x"

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

@@ -0,0 +1,8 @@
+3
+3
+3
+2
+99
+1
+2.0
+"x"

data/vendor/spinel/test/poly_dispatch_ptr_array.rb

@@ -0,0 +1,57 @@
+# Polymorphic `[]` and `length` dispatch must reach a PtrArray
+# receiver. Pre-fix, two things were wrong:
+#
+# 1. `emit_poly_builtin_dispatch` had no SP_BUILTIN_PTR_ARRAY branch
+#    for `[]` (the in-source comment said "Defer (the issue notes
+#    this is more involved)"). The dispatch result silently stayed at
+#    its default 0 / NULL when the runtime tag was a PtrArray.
+#
+# 2. `box_expr_to_poly` checked `is_obj_type` *before*
+#    `is_ptr_array_type`. Both predicates fire on `obj_Foo_ptr_array`
+#    (it starts with `obj_` AND ends with `_ptr_array`), so the
+#    is_obj_type branch ran first and emitted
+#    `sp_box_obj(p, find_class_idx("Foo_ptr_array"))`
+#    = `sp_box_obj(p, -1)`. -1 happens to equal SP_BUILTIN_INT_ARRAY,
+#    so the runtime cls_id mis-tagged a PtrArray as an IntArray.
+#    Subsequent dispatch then fell into the IntArray branch and read
+#    garbage out of the PtrArray's layout.
+#
+# `lenof([Foo.new(1), Foo.new(2)])` previously printed 16 (a bogus
+# byte interpreted as IntArray length); now it prints 2.
+
+class Foo
+  def initialize(n)
+    @n = n
+  end
+  attr_reader :n
+end
+
+class Bar
+  def length
+    99
+  end
+
+  def [](_)
+    77
+  end
+end
+
+def lenof(a)
+  a.length
+end
+
+def first(a)
+  a[0]
+end
+
+# `length` over mixed call sites — IntArray, PtrArray<Foo>, and a
+# user class. The PtrArray branch is the new one for this PR.
+puts lenof([1, 2, 3])                  # 3
+puts lenof([Foo.new(1), Foo.new(2)])   # 2
+puts lenof(Bar.new)                    # 99
+
+# `[]` over the same shapes.
+puts first([10, 20, 30])               # 10
+foo = first([Foo.new(42)])
+puts foo.n                             # 42
+puts first(Bar.new)                    # 77

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

@@ -0,0 +1,6 @@
+3
+2
+99
+10
+42
+77

data/vendor/spinel/test/poly_equality_mixed_sites.rb

@@ -0,0 +1,40 @@
+def same(a, b)
+  a == b
+end
+
+puts same(1, 1)
+puts same("x", "x")
+puts same(1, 1.0)
+
+def less_or_equal(a, b)
+  a <= b
+end
+
+puts less_or_equal(1, 2.0)
+begin
+  puts less_or_equal(1, "x")
+rescue
+  puts false
+end
+begin
+  puts less_or_equal(false, true)
+rescue
+  puts false
+end
+begin
+  puts less_or_equal(nil, nil)
+rescue
+  puts false
+end
+
+def maybe_string(flag)
+  if flag
+    "actual"
+  else
+    nil
+  end
+end
+
+puts same(maybe_string(false), nil)
+puts same(maybe_string(true), nil)
+puts same(maybe_string(false), "")

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

@@ -0,0 +1,10 @@
+true
+true
+true
+true
+false
+false
+false
+true
+false
+false

data/vendor/spinel/test/poly_gc.rb

@@ -0,0 +1,39 @@
+class Trash
+  def initialize(n)
+    @n = n
+    @s = "padding payload " * 64
+  end
+end
+
+class Holder
+  def initialize(value)
+    @value = value
+  end
+
+  attr_reader :value
+end
+
+def make_poly_array
+  value = "array-" + 123.to_s
+  [value, 1]
+end
+
+def make_holder
+  value = "ivar-" + 456.to_s
+  Holder.new(value)
+end
+
+values = make_poly_array
+holder = make_holder
+Holder.new(1)
+
+junk = []
+i = 0
+while i < 5000
+  junk << Trash.new(i)
+  i = i + 1
+end
+
+puts junk.length
+puts values[0]
+puts holder.value

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

@@ -0,0 +1,3 @@
+5000
+array-123
+ivar-456

data/vendor/spinel/test/poly_hash_literal_from_ivar.rb

@@ -0,0 +1,47 @@
+# Issue #287: a method that returns `{ key: @x, ... }` had its
+# inferred return type frozen at the first scan, before #247 widened
+# the ivar slot to poly via a sibling-writer disagreement. The hash
+# literal then emitted as `sp_StrIntHash *` (int-valued) and tried
+# to insert the now-poly ivar value at C compile time.
+#
+# Fix: extend `infer_hash_val_type`'s all_same branch to handle
+# `first_vt == "poly"` — sym/str-keyed poly hashes get the same
+# *_poly_hash storage as the mixed-types `else` branch.
+
+class C
+  def initialize
+    @x = 0
+  end
+  def write_str(s)
+    @x = s
+  end
+  def hash_of_x
+    { key: @x }
+  end
+end
+
+c = C.new
+c.write_str("hello")
+puts c.hash_of_x.size       # 1
+puts c.hash_of_x.has_key?(:key)  # true
+
+# Multiple sym-keyed entries, all flowing from poly ivars.
+class D
+  def initialize
+    @a = 0
+    @b = 0
+  end
+  def write(sa, sb)
+    @a = sa
+    @b = sb
+  end
+  def attrs
+    { a: @a, b: @b }
+  end
+end
+
+d = D.new
+d.write("alpha", "beta")
+puts d.attrs.size           # 2
+puts d.attrs.has_key?(:a)   # true
+puts d.attrs.has_key?(:c)   # false

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

@@ -0,0 +1,5 @@
+1
+true
+2
+true
+false

data/vendor/spinel/test/poly_hash_with_range.rb

@@ -0,0 +1,36 @@
+# Range crossing into a poly container: a hash literal mixing
+# Integer values with Range values used to fall through
+# `box_non_nullable_value_to_poly`'s default branch and emit
+# `sp_box_int(sp_range_new(...))`, which the C compiler rejects
+# (sp_Range is 16 bytes; sp_RbVal's union is 8). Same shape for
+# heterogeneous poly arrays.
+#
+# Fix: heap-allocate the Range and box the pointer through a new
+# SP_BUILTIN_RANGE cls_id (sp_box_range copies the stack range
+# onto the GC heap before returning the boxed sp_RbVal).
+
+# Hash form (the canonical Rails strong-status shape from the issue).
+STATUS_SYMBOLS = {
+  success:    200..299,
+  redirect:   300..399,
+  missing:    404,
+  not_found:  404,
+  error:      500..599,
+  ok:         200,
+  created:    201,
+  no_content: 204,
+}
+
+puts STATUS_SYMBOLS[:success]    # 200..299
+puts STATUS_SYMBOLS[:ok]         # 200
+puts STATUS_SYMBOLS[:created]    # 201
+puts STATUS_SYMBOLS[:error]      # 500..599
+puts STATUS_SYMBOLS[:not_found]  # 404
+
+# Array form — same fundamental issue (Range crosses into poly slot).
+arr = [200..299, 200, 300..399, 404]
+puts arr.length                  # 4
+puts arr[0]                      # 200..299
+puts arr[1]                      # 200
+puts arr[2]                      # 300..399
+puts arr[3]                      # 404

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

@@ -0,0 +1,10 @@
+200..299
+200
+201
+500..599
+404
+4
+200..299
+200
+300..399
+404

data/vendor/spinel/test/poly_hash_with_time.rb

@@ -0,0 +1,32 @@
+# Same heap-box pattern as Range applied to Time. sp_Time is wider
+# than sp_RbVal's union (8 bytes), so a Time value in a poly slot
+# (heterogeneous hash / array) used to fall through
+# `box_non_nullable_value_to_poly`'s default and emit
+# `sp_box_int(sp_time_at_int(...))` — which C rejected.
+#
+# The fix introduces SP_BUILTIN_TIME and `sp_box_time` (heap copies
+# the stack Time and boxes through SP_TAG_OBJ). The companion
+# `sp_Time_inspect` is timezone-dependent in the runtime (UTC) so
+# we don't compare the printed Time bodies here — the regression
+# is about the boxing path compiling and the int sibling values
+# round-tripping cleanly.
+
+H = {
+  start: Time.at(0),
+  middle: Time.at(1234567890),
+  count: 42,
+  limit: 100,
+}
+
+puts H[:count]                # 42
+puts H[:limit]                # 100
+puts H.length                 # 4
+puts H.has_key?(:start)       # true
+puts H.has_key?(:missing)     # false
+
+# Mixed poly array: Time + Int — verify the int slots still
+# round-trip and the Time slots don't break the array shape.
+arr = [Time.at(0), 100, Time.at(1234567890), 200]
+puts arr.length               # 4
+puts arr[1]                   # 100
+puts arr[3]                   # 200

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

@@ -0,0 +1,8 @@
+42
+100
+4
+true
+false
+4
+100
+200

data/vendor/spinel/test/poly_int_arith_auto_unify.rb

@@ -0,0 +1,26 @@
+# Auto-unify int receiver + poly argument in arithmetic. Common
+# case: `addr + arr[i][j]` where the inner dispatch is a
+# heterogeneous user-class+IntArray array — both arms genuinely
+# return int at runtime, but spinel statically types `[]`
+# dispatch as poly. Spinel previously emitted `(addr +
+# <sp_RbVal>)` and the C compile failed (`invalid operands to
+# binary + (have 'mrb_int' and 'sp_RbVal')`). The operator-site
+# fall-through now unboxes the poly arg via .v.i, mirroring PR
+# #347's LV-write semantics.
+
+# Class that defines `[]` returning int — when stored alongside an
+# IntArray in a poly_array, the outer `[]` dispatch returns poly.
+class Lookup
+  def [](i); i * 10 + 1; end
+end
+
+arr = [Lookup.new, [100, 200, 300]]
+
+# arr[i] is poly (Lookup or IntArray), then `[j]` dispatches —
+# every runtime arm returns int, but the static return type is
+# poly. So `addr + arr[1][0]` is `int + poly` at codegen time.
+addr = 7
+puts(addr + arr[1][0])  # 7 + 100 = 107
+puts(addr - arr[0][2])  # 7 - 21  = -14
+puts(addr * arr[1][1])  # 7 * 200 = 1400
+puts(arr[1][2] / 3)     # 300 / 3 = 100  (recv-poly + arg-int already worked via sp_poly_div, included for coverage)

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

@@ -0,0 +1,4 @@
+107
+-14
+1400
+100