rubyduino 0.1.1

data/vendor/spinel/test/poly_int_bit_index.rb

@@ -0,0 +1,50 @@
+# `Integer#[N]` (bit-extraction) where the receiver was typed
+# poly via cascading inference. Used to fall through to the
+# SP_TAG_OBJ array dispatch in `emit_poly_builtin_dispatch`'s
+# `[]` branch, leaving the result at the nil/0 default — so
+# `int[i]` returned 0 for every i, and downstream
+# `pc[8] == tmp[8] ? a : b` style page-bit checks always took
+# the same-page branch.
+
+class Holder
+  # Mixed-type ivar writes widen @x to poly. Reads return sp_RbVal
+  # even when the runtime value is concretely int.
+  def initialize
+    @x = "init"
+    @x = 0b10110100  # 180 — actual value at test time
+  end
+
+  attr_reader :x
+
+  # Same-page check pattern: extract bit 8 from each poly-typed int.
+  def same_page?(a, b)
+    a[8] == b[8]
+  end
+end
+
+h = Holder.new
+v = h.x  # `v` is poly here
+
+# Static index, dynamic value. Without the fix, every output is 0.
+puts v[0]    # 0
+puts v[1]    # 0
+puts v[2]    # 1
+puts v[3]    # 0
+puts v[4]    # 1
+puts v[5]    # 1
+puts v[6]    # 0
+puts v[7]    # 1
+
+# Dynamic index. Same buggy fallthrough.
+i = 0
+while i < 4
+  puts v[i]
+  i += 1
+end
+
+# Page-bit check: `0x100 | x` flips bit 8 on/off so the comparison
+# meaningfully differs depending on input. With the bug both values
+# get bit-8 == 0 (default), the comparison is always true, and
+# branch-cycle counting collapses.
+puts h.same_page?(h.x, h.x | 0x100)   # false (bit 8 differs)
+puts h.same_page?(h.x, h.x | 0x10)    # true (bit 8 same — both 0)

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

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

data/vendor/spinel/test/poly_int_bitops_auto_unify.rb

@@ -0,0 +1,20 @@
+# Same operator-site auto-unbox, but for bit operators (`<<`,
+# `>>`, `&`, `|`, `^`). int recv + poly arg previously failed C
+# compile; the poly arg is now unboxed via .v.i.
+
+# Heterogeneous poly_array of [user-class-with-[], IntArray] —
+# the outer `arr[i]` dispatch returns poly, then `[j]` on the
+# poly returns poly (since spinel statically types `[]` as poly).
+class Bits
+  def [](i); [0xff, 0x0a, 0x10][i]; end
+end
+
+arr = [Bits.new, [0xff, 0x0a, 0x10]]
+
+# Each `arr[k][j]` is `int + poly` style: addr is int, the
+# heterogeneous dispatch result is statically poly.
+puts(1   << arr[1][1])     # 1 << 0x0a = 1024
+puts(0xf0 & arr[1][0])     # 0xf0 & 0xff = 0xf0 = 240
+puts(0x05 | arr[1][1])     # 0x05 | 0x0a = 0x0f = 15
+puts(0xff ^ arr[1][2])     # 0xff ^ 0x10 = 0xef = 239
+puts(arr[1][1] >> 1)       # 0x0a >> 1 = 5  (recv-poly + arg-int already routes to sp_poly_shr)

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

@@ -0,0 +1,5 @@
+1024
+240
+15
+239
+5

data/vendor/spinel/test/poly_is_a.rb

@@ -0,0 +1,47 @@
+# `<poly>.is_a?(Klass)` / `kind_of?` / `instance_of?` runtime
+# dispatch. Spinel previously fell through to user-class dispatch
+# only — the SP_TAG_INT / SP_TAG_STR / SP_TAG_FLT / SP_TAG_NIL /
+# SP_TAG_BOOL / SP_TAG_SYM / built-in Array / Hash / Range cases
+# were missing, so `is_a?(Integer)` against a poly slot always
+# returned false and downstream branches took the wrong arm. The
+# user-class dispatch also walked the wrong direction (recv->parent
+# instead of any-descendant->ancestor).
+#
+# Repro: a heterogeneous poly array yields each element back as
+# poly, then the type test routes it to the right branch. The
+# trailing Bar.new must select the `is_a?(Bar)` arm AND the
+# Foo.new before it must NOT match `is_a?(Bar)` (subclass-only).
+
+class Foo
+  def name; "foo"; end
+end
+class Bar < Foo
+  def name; "bar"; end
+end
+
+arr = [42, "hello", :sym, 1.5, nil, true, false, [1, 2], Foo.new, Bar.new]
+arr.each do |x|
+  if x.is_a?(Integer)
+    puts "Integer #{x}"
+  elsif x.is_a?(String)
+    puts "String #{x}"
+  elsif x.is_a?(Symbol)
+    puts "Symbol #{x.to_s}"
+  elsif x.is_a?(Float)
+    puts "Float"
+  elsif x.is_a?(NilClass)
+    puts "Nil"
+  elsif x.is_a?(TrueClass)
+    puts "True"
+  elsif x.is_a?(FalseClass)
+    puts "False"
+  elsif x.is_a?(Array)
+    puts "Array"
+  elsif x.is_a?(Bar)
+    puts "Bar"
+  elsif x.is_a?(Foo)
+    puts "Foo"
+  else
+    puts "?"
+  end
+end

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

@@ -0,0 +1,10 @@
+Integer 42
+String hello
+Symbol sym
+Float
+Nil
+True
+False
+Array
+Foo
+Bar

data/vendor/spinel/test/poly_keyed_hash_method_dedup.rb

@@ -0,0 +1,37 @@
+# Hash with Method-typed keys — the optcarrot @peeks/@pokes dedup
+# pattern. Two `obj.method(:foo)` calls produce distinct Method
+# instances but eql? as keys (same bound receiver + fn_ptr), so the
+# `@cache[k] ||= k` cache stores only one entry for them.
+
+class Cache
+  def initialize
+    @h = {}
+  end
+  def add(k)
+    @h[k] ||= k
+  end
+  def has?(k)
+    !@h[k].nil?
+  end
+  def size
+    @h.size
+  end
+end
+
+class M
+  def self.foo; end
+  def self.bar; end
+end
+
+c = Cache.new
+m1 = M.method(:foo)
+c.add(m1)
+puts c.has?(m1)             # true (same instance round-trips)
+puts c.has?(M.method(:bar)) # false (different fn_ptr)
+
+# Two distinct Method instances for the same (receiver, fn_ptr)
+# hash and eql? identically, so the cache stays at size 1.
+c.add(M.method(:foo))
+puts c.size                 # 1
+puts c.has?(M.method(:foo)) # true via eql? (m1 returned for the
+                            # query Method instance)

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

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

data/vendor/spinel/test/poly_keyed_hash_pipeline.rb

@@ -0,0 +1,40 @@
+# Heterogeneous-key Hash through the full reassign-and-store pipeline.
+# Mirrors optcarrot's CPU#add_mappings(addr, peek, poke):
+#   peek = @peeks[peek] ||= peek
+# where peek can be either a Method or a non-Method object — the param
+# slot widens to poly so the `||=` lookup result flows back into the
+# same local without unboxing.
+
+class Pipeline
+  def initialize
+    @peeks = {}
+    @stored = []
+  end
+  # `item` widens to poly across the call sites below (Method,
+  # IntArray) so the param is sp_RbVal — the dedup reassignment
+  # `item = @peeks[item] ||= item` works without re-typing the slot.
+  def add(item)
+    item = @peeks[item] ||= item
+    @stored.push(item)
+  end
+  def cache_size
+    @peeks.size
+  end
+  def stored_count
+    @stored.length
+  end
+end
+
+class Source
+  def self.read; 42; end
+end
+
+p = Pipeline.new
+m = Source.method(:read)
+arr = [1, 2, 3]
+p.add(m)              # cache: {m => m}
+p.add(arr)            # cache: {m => m, arr => arr}
+p.add(Source.method(:read))   # eql? to m → cache stays size 2
+p.add(arr)            # identity hit → size still 2
+puts p.cache_size     # 2
+puts p.stored_count   # 4 (every call appends)

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

@@ -0,0 +1,2 @@
+2
+4

data/vendor/spinel/test/poly_method_args.rb

@@ -0,0 +1,23 @@
+# Polymorphic method dispatch must pass arguments through to the
+# selected class's method. Before this fix, `compile_poly_method_call`
+# emitted `sp_<Class>_<method>((sp_<Class> *)recv.v.p)` with no
+# argument list — the call-site arguments were dropped on the floor.
+
+class Doubler
+  def call(x)
+    x * 2
+  end
+end
+
+class Tripler
+  def call(x)
+    x * 3
+  end
+end
+
+def apply(a, x)
+  a.call(x)
+end
+
+puts apply(Doubler.new, 5)
+puts apply(Tripler.new, 5)

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

@@ -0,0 +1,2 @@
+10
+15

data/vendor/spinel/test/poly_method_mixed_return.rb

@@ -0,0 +1,23 @@
+# Poly dispatch where user classes disagree on the method's return
+# type. `Foo#name` returns int, `Bar#name` returns string. The result
+# of `a.name` is genuinely polymorphic — the dispatcher must use
+# sp_RbVal as the result type and box each branch's return value.
+
+class Foo
+  def name
+    42
+  end
+end
+
+class Bar
+  def name
+    "bar"
+  end
+end
+
+def show(a)
+  a.name
+end
+
+puts show(Foo.new)
+puts show(Bar.new)

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

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

data/vendor/spinel/test/poly_or_returns_value.rb

@@ -0,0 +1,13 @@
+def pick(a, b)
+  a || b
+end
+
+puts pick(nil, "fallback")
+puts pick("actual", "fallback")
+
+def pick_int(a, b)
+  a || b
+end
+
+puts pick_int(0, 5)
+puts(nil || "direct")

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

@@ -0,0 +1,4 @@
+fallback
+actual
+0
+direct

data/vendor/spinel/test/poly_recv_aref_box_arm.rb

@@ -0,0 +1,41 @@
+# Issue #351: sister-to-#341. After #341 widened the per-class
+# `def [](k)` parameter to `sp_RbVal` (poly) when callers pass
+# heterogeneous key types, compile_poly_method_call's per-class
+# dispatch arm passed the raw call-site value (`const char *`,
+# `mrb_int`, ...) directly to the `sp_RbVal` parameter — gcc
+# errored `incompatible type for argument 2 of 'sp_<C>__aref'`.
+#
+# Fix: at the per-arm emit, when the arm's ptype is `poly` (base
+# type) but the call-site arg's type is concrete, wrap the arg
+# expression in `box_value_to_poly(arg_type, val)` so the
+# call-site value reaches the slot pre-boxed.
+#
+# Surfaced via Roundhouse's view-helper shape:
+# `def field_for(model, field); model[field]; end` where model is
+# poly{Article, Comment, HWIA, Parameters} and field is Symbol.
+
+class A
+  def [](k)
+    "from-A"
+  end
+end
+
+class B
+  def [](k)
+    "from-B"
+  end
+end
+
+# Two callers with different key types — forces the union to
+# widen sp_<C>__aref's lv_k to sp_RbVal across A and B.
+def lookup_str(receiver, key)
+  receiver[key]
+end
+puts lookup_str(A.new, "alpha")
+puts lookup_str(B.new, "beta")
+
+def lookup_sym(receiver, key)
+  receiver[key]
+end
+puts lookup_sym(A.new, :alpha)
+puts lookup_sym(B.new, :beta)

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

@@ -0,0 +1,4 @@
+from-A
+from-B
+from-A
+from-B

data/vendor/spinel/test/poly_recv_aref_str_key.rb

@@ -0,0 +1,42 @@
+# Issue #341: user-defined `def [](k)` got its parameter type
+# inferred as `mrb_int` regardless of caller arg types. When the
+# receiver was poly (e.g. a method param widened to accept multiple
+# user classes) and callers passed a String key, the per-class
+# arms emitted by compile_poly_method_call called each class's
+# C function with `const char *` arg → Wint-conversion error
+# under -Werror, or hard incompatible-pointer error.
+#
+# A second symptom: the SP_TAG_INT branch of compile_poly_method_call
+# emitted `(recv.v.i >> key) & 1` unconditionally, which is invalid
+# C when `key` isn't an int. The same shape applies to the built-in
+# array dispatches in emit_poly_builtin_dispatch (sp_IntArray_get
+# etc. all expect `mrb_int` keys).
+#
+# Fix:
+#   1. scan_new_calls' receiver-method widening adds a poly arm:
+#      walk every user class that defines `mname` and unify each
+#      class's ptypes with the call site's arg types.
+#   2. compile_poly_method_call gates the int-bit-extract emit on
+#      arg type being int or poly.
+#   3. emit_poly_builtin_dispatch's `[]` block also gates on int/poly
+#      key — for non-int keys the built-in arms are unreachable and
+#      emitting them produces the same Wint-conversion warnings.
+
+class A
+  def [](k)
+    "from-A:" + k
+  end
+end
+
+class B
+  def [](k)
+    "from-B:" + k
+  end
+end
+
+def lookup(receiver, key)
+  receiver[key]
+end
+
+puts lookup(A.new, "alpha")
+puts lookup(B.new, "beta")

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

@@ -0,0 +1,2 @@
+from-A:alpha
+from-B:beta

data/vendor/spinel/test/poly_recv_bracket_assign.rb

@@ -0,0 +1,31 @@
+# `compile_bracket_assign` had no `rt == "poly"` branch. When an
+# ivar slot widens to plain `poly` (sp_RbVal — wider than
+# poly_array, set by `finalize_ivar_heterogeneity` because of
+# multiple distinct non-array writes), `@arr[i] = v` falls through
+# every typed branch and emits *nothing* — the assignment silently
+# drops from generated C.
+#
+# Trigger: @arr is observed as int_array (`[nil] * N`) AND as a
+# scalar (string, int) — finalize collapses to plain `poly`. Then
+# `@arr[i] = v` should still write to the underlying storage, but
+# without the poly arm spinel emits zero code for the assignment.
+
+class C
+  def init_arr(n)
+    @arr = [nil] * n      # int_array observation
+    @arr[0] = 100
+  end
+  def init_str
+    @arr = "scalar"       # string observation — widens slot to poly
+  end
+  def init_int
+    @arr = 42             # int observation
+  end
+  def at(i)
+    @arr[i]
+  end
+end
+
+c = C.new
+c.init_arr(3)
+puts c.at(0)              # post-write: 100 (master: 0 — write dropped)

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

@@ -0,0 +1 @@
+100

data/vendor/spinel/test/poly_recv_each.rb

@@ -0,0 +1,35 @@
+# `<poly>.each` runtime dispatch on cls_id. The compile_each_block
+# handler previously bailed when the receiver type was `poly` (no
+# matching `if rt == "..."` branch), so a method body that ends in
+# `iterable.each do |a| ... end` over a poly slot silently dropped
+# the iteration.
+#
+# Repro: an ivar `@store` widened to poly via two distinct array
+# shapes (an int_array and a poly_array) is iterated via `.each`.
+# Spinel previously emitted no loop at all — the body never ran.
+# The block param `a` is delivered as sp_RbVal (the widest fit
+# across the cls_id arms).
+
+class C
+  def store_int_array
+    @store = [10, 20, 30]
+  end
+  def store_poly_array
+    @store = [nil] * 3
+    @store[0] = "a"
+    @store[1] = "b"
+    @store[2] = "c"
+  end
+  def visit
+    @store.each do |x|
+      puts x.to_s
+    end
+  end
+end
+
+c = C.new
+c.store_int_array
+c.visit
+puts "---"
+c.store_poly_array
+c.visit

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

@@ -0,0 +1,7 @@
+10
+20
+30
+---
+a
+b
+c

data/vendor/spinel/test/poly_return_value_class.rb

@@ -0,0 +1,66 @@
+# Issue #118: a method that returns instances of two or more value-
+# type-eligible classes per branch used to crash the C compile. Both
+# A and B detected as value-type (no attr_writer / no mutator) →
+# `sp_A_new(...)` / `sp_B_new(...)` returned the struct by value →
+# `sp_box_obj(struct, ci)` tried to put a struct into `sp_RbVal.v.p`
+# (`void *`), and the unboxing dispatch passed `void *` to a method
+# taking its receiver by value.
+#
+# Fix: detect_poly_returned_types collects every class constructed
+# inside a poly-returning method and excludes those classes from the
+# value-type optimization, so they stay heap-allocated and the
+# existing poly-return / sp_RbVal plumbing handles them as pointers.
+
+class A
+  def initialize(v); @v = v; end
+  def label; "A:" + @v; end
+end
+
+class B
+  def initialize(v); @v = v; end
+  def label; "B:" + @v; end
+end
+
+def pick(flag)
+  if flag
+    A.new("yes")
+  else
+    B.new("no")
+  end
+end
+
+puts pick(true).label    # A:yes
+puts pick(false).label   # B:no
+
+# A `case`/`when` poly return — same shape, different control flow.
+def by_kind(k)
+  case k
+  when 0 then A.new("zero")
+  when 1 then B.new("one")
+  else        A.new("many")
+  end
+end
+
+puts by_kind(0).label    # A:zero
+puts by_kind(1).label    # B:one
+puts by_kind(9).label    # A:many
+
+# Method invocation that returns a different type per class — the
+# poly receiver dispatches through the cls_id table generated for
+# explicit `def`-defined methods on each class.
+class P
+  def initialize(n); @n = n; end
+  def double; @n * 2; end
+end
+
+class Q
+  def initialize(n); @n = n; end
+  def double; @n + 100; end
+end
+
+def numeric(flag)
+  flag ? P.new(7) : Q.new(7)
+end
+
+puts numeric(true).double    # 14
+puts numeric(false).double   # 107

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

@@ -0,0 +1,7 @@
+A:yes
+B:no
+A:zero
+B:one
+A:many
+14
+107

data/vendor/spinel/test/poly_self_deref.rb

@@ -0,0 +1,28 @@
+# Polymorphic dispatch where the called method dereferences `self`.
+# `cls_id` used to share memory with `v.p` inside the sp_RbVal union,
+# so writing cls_id after v.p clobbered the low 32 bits of the pointer.
+# Methods that touch instance fields then crashed (SIGSEGV).
+# Methods that did not touch self happened to work, masking the bug.
+
+class C
+  attr_accessor :n
+  def initialize(n)
+    @n = n
+  end
+  def name
+    @n.to_s
+  end
+end
+
+class D
+  def name
+    "other"
+  end
+end
+
+def show(o)
+  o.name
+end
+
+puts show(C.new(42))
+puts show(D.new)

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

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

data/vendor/spinel/test/poly_shl_array_push_dispatch.rb

@@ -0,0 +1,35 @@
+# `<<` on a poly recv used to always lower to sp_poly_shl, which
+# was Integer-bit-shift only. An IntArray boxed into a poly slot
+# (e.g. an ivar that the type-inference passes widened to poly
+# because it received both nil and an array) had its `<<` push
+# silently turn into a bit-shift of the encoded pointer/length,
+# dropping the rhs.
+#
+# After the fix, sp_poly_shl dispatches by recv cls_id and invokes
+# the matching Array#<< push. Falls through to bit-shift only when
+# the recv is a non-array (genuine Integer<<int).
+
+class C
+  def initialize
+    # `nil` then concrete-array writes widen @v to poly (Issue #130
+    # "definite int/nil + obj → poly"). Once poly, the runtime
+    # carries cls_id INT_ARRAY at access time.
+    @v = nil
+    @v = [10, 20, 30]
+  end
+  def push(x); @v << x; end
+  def length; @v.length; end
+  def get(i); @v[i]; end
+end
+
+c = C.new
+c.push(99)
+c.push(88)
+puts c.length         # 5
+puts c.get(0)         # 10
+puts c.get(3)         # 99
+puts c.get(4)         # 88
+
+# Bit-shift on genuine Integer recv still works (the fall-through).
+x = 1
+puts x << 3           # 8

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

@@ -0,0 +1,5 @@
+5
+10
+99
+88
+8

data/vendor/spinel/test/poly_slice_assign.rb

@@ -0,0 +1,26 @@
+# `compile_slice_assign` had no `rt == "poly"` arm; the
+# fall-through used arg[1] (the slice length) as the assignment
+# value and silently dropped the rhs entirely.
+#
+# Trigger: `arr[i, n] = src` where arr's slot type is plain poly
+# (widened via heterogeneous writes).
+
+class C
+  def init_arr
+    @arr = [10, 20, 30, 40, 50]
+  end
+  def init_str
+    @arr = "scalar"     # widens slot to poly
+  end
+  def replace
+    @arr[1, 2] = [99, 88]
+  end
+  def at(i); @arr[i]; end
+end
+
+c = C.new
+c.init_arr
+c.replace
+puts c.at(0)
+puts c.at(1)
+puts c.at(2)

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

@@ -0,0 +1,3 @@
+10
+99
+88