rubyduino 0.1.1

data/vendor/spinel/test/multi_assign_ivar.rb

@@ -0,0 +1,33 @@
+class A
+  attr_reader :x
+  def initialize; @x = 11; end
+end
+class B
+  attr_reader :y
+  def initialize; @y = 22; end
+end
+class C
+  attr_reader :z
+  def initialize; @z = 33; end
+end
+
+class Driver
+  def self.load
+    a = A.new
+    b = B.new
+    c = C.new
+    return a, b, c
+  end
+end
+
+class Holder
+  def initialize
+    @a, @b, @c = Driver.load
+  end
+  def show
+    puts "a.x=#{@a.x} b.y=#{@b.y} c.z=#{@c.z}"
+  end
+end
+
+h = Holder.new
+h.show

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

@@ -0,0 +1 @@
+a.x=11 b.y=22 c.z=33

data/vendor/spinel/test/multi_return.rb

@@ -0,0 +1,35 @@
+def divmod(a, b)
+  [a / b, a % b]
+end
+
+q, r = divmod(17, 5)
+puts q  # 3
+puts r  # 2
+
+# Swap
+x = 10
+y = 20
+x, y = y, x
+puts x  # 20
+puts y  # 10
+
+# From array literal
+a, b, c = [100, 200, 300]
+puts a  # 100
+puts b  # 200
+puts c  # 300
+
+# Multiple return values used in expressions
+def minmax(a, b)
+  if a < b
+    [a, b]
+  else
+    [b, a]
+  end
+end
+
+lo, hi = minmax(42, 7)
+puts lo  # 7
+puts hi  # 42
+
+puts "done"

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

@@ -0,0 +1,10 @@
+3
+2
+20
+10
+100
+200
+300
+7
+42
+done

data/vendor/spinel/test/multi_return_bare.rb

@@ -0,0 +1,77 @@
+# `return a, b` materializes as a fixed-arity tuple struct, preserving
+# heterogeneous element types unboxed.
+
+class C
+  def initialize
+    @x = 1
+    @y = 2
+    @z = 3
+    @s1 = "hi"
+    @s2 = "lo"
+    @f1 = 1.5
+    @f2 = 2.5
+  end
+
+  def two_ints
+    return @x, @y
+  end
+
+  def three_ints
+    return @x, @y, @z
+  end
+
+  def two_strs
+    return @s1, @s2
+  end
+
+  def two_floats
+    return @f1, @f2
+  end
+
+  # Heterogeneous: int + string (no boxing — fields keep concrete types).
+  def int_and_str
+    return @x, @s1
+  end
+
+  # Heterogeneous: int + float + string.
+  def three_mixed
+    return @x, @f1, @s1
+  end
+
+  def consume
+    a, b = two_ints
+    a + b
+  end
+end
+
+c = C.new
+
+a, b = c.two_ints
+puts a            # 1
+puts b            # 2
+
+a, b, d = c.three_ints
+puts a            # 1
+puts b            # 2
+puts d            # 3
+
+s1, s2 = c.two_strs
+puts s1           # hi
+puts s2           # lo
+
+f1, f2 = c.two_floats
+puts f1           # 1.5
+puts f2           # 2.5
+
+i, s = c.int_and_str
+puts i            # 1
+puts s            # hi
+
+i, f, s = c.three_mixed
+puts i            # 1
+puts f            # 1.5
+puts s            # hi
+
+puts c.consume    # 3
+
+puts "done"

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

@@ -0,0 +1,16 @@
+1
+2
+1
+2
+3
+hi
+lo
+1.5
+2.5
+1
+hi
+1
+1.5
+hi
+3
+done

data/vendor/spinel/test/multi_write_const.rb

@@ -0,0 +1,36 @@
+# Multi-write to constants — `A, B, C = expr` — used to silently
+# drop the targets because the parser emitted ConstantTargetNode as
+# `UnknownNode_43` and the codegen had no MultiWriteNode branch in
+# the constant-collection passes. Subsequent reads of A/B/C compiled
+# to undefined-identifier errors.
+#
+# Two RHS shapes are exercised: a literal ArrayNode (split element
+# by element at emit time) and a call returning int_array (evaluated
+# once into a temp, then sp_IntArray_get for each target).
+
+class C
+  N1, N2, N3 = [10, 20, 30]
+end
+
+puts C::N1
+puts C::N2
+puts C::N3
+
+class D
+  ARR = [100, 200, 300, 400]
+  M1, M2, M3, M4 = ARR
+end
+
+puts D::M1
+puts D::M2
+puts D::M3
+puts D::M4
+
+# RHS with a block — the block param introduces a local that
+# must be declared in main() (or the enclosing scope) so the
+# emitted `lv_<bp>` reference resolves. Single-const init already
+# scans @const_expr_ids; the multi-write form needs the same scan
+# over @multi_const_inits.
+P, Q = [1, 2].map { |n| n * 10 }
+puts P
+puts Q

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

@@ -0,0 +1,9 @@
+10
+20
+30
+100
+200
+300
+400
+10
+20

data/vendor/spinel/test/multi_write_from_poly_recv.rb

@@ -0,0 +1,34 @@
+# Multi-write `a, b = rhs` where rhs's static type is `poly` (an
+# sp_RbVal that carries a poly_array at runtime).  Pre-fix:
+# `multi_write_target_type` fell through to the default `int` for
+# rt == "poly", so `a` / `b` were declared as mrb_int and the
+# emit-side dispatch (which DOES handle `val_t_local == "poly"` by
+# unboxing to sp_PolyArray*) wrote `(sp_PolyArray_get(...)).v.i`,
+# truncating the poly elements to garbage ints.
+
+class C
+  def setup
+    @h = {}
+    [0, 1].each do |bank|
+      [0, 1].each do |idx|
+        # Outermost ||= produces a poly_poly_hash slot, then a
+        # poly_array of poly_arrays of two-tuples — same shape as
+        # optcarrot's @lut_update.
+        (((@h[bank] ||= [])[idx] ||= [nil, nil])[0] ||= []) << [idx * 10 + bank, idx + bank]
+      end
+    end
+  end
+
+  def name_lut_size(bank, idx)
+    # Multi-write whose RHS infers to `poly`: @h[bank][idx] indexes
+    # into poly_poly_hash (returns poly), then into the unboxed
+    # poly_array (returns poly).
+    name_lut_update, _attr_lut_update = @h[bank][idx]
+    name_lut_update.length
+  end
+end
+
+c = C.new
+c.setup
+# bank=1 / idx=0 yields a 1-element list (one push at this slot).
+puts c.name_lut_size(1, 0)

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

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

data/vendor/spinel/test/multi_write_ivar.rb

@@ -0,0 +1,34 @@
+# `@a, @b = expr1, expr2` (multi-write to ivars) was not picked up by
+# `scan_ivars`, so the ivars were never registered and the struct
+# came out missing them. The emit-time path in compile_stmt already
+# handled InstanceVariableTargetNode; the gap was only in the
+# collection pass.
+
+class Inner
+  def initialize(x); @x = x; end
+  attr_reader :x
+end
+
+class HasObjects
+  def initialize
+    @left, @right = Inner.new(7), Inner.new(8)
+  end
+  def sum
+    @left.x + @right.x
+  end
+end
+
+class Holder
+  def initialize
+    @a, @b = 1, 2
+  end
+  attr_reader :a, :b
+  def has_obj
+    HasObjects.new.sum
+  end
+end
+
+h = Holder.new
+puts h.a
+puts h.b
+puts h.has_obj

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

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

data/vendor/spinel/test/multi_write_ivar_const_from_array_rhs.rb

@@ -0,0 +1,53 @@
+# `compile_multi_write`'s int_array-returning RHS branch (RHS is a
+# non-literal expression that evaluates to an array, e.g.
+# `.map { ... }`, a method call) only emitted assignments for
+# `LocalVariableTargetNode` targets — `InstanceVariableTargetNode`
+# and `ConstantTargetNode` targets were silently dropped. The C
+# code compiled fine, but the ivars / constants stayed at their
+# default values.
+#
+# Repro: `@a, @b = [10, 20].map { |x| x + 1 }` where the targets
+# are ivars. Master emitted neither write, so c.a / c.b returned 0.
+#
+# (Constant-target coverage requires the multi-write-to-constants
+# parser support, which lives in a sibling PR; the InstanceVariable
+# fix here is independent and lands first.)
+
+# (1) ivar targets, RHS is .map
+class C1
+  def initialize
+    @a, @b = [10, 20].map { |x| x + 1 }
+  end
+  attr_reader :a, :b
+end
+c = C1.new
+puts c.a              # 11
+puts c.b              # 21
+
+# (2) mixed: local + ivar from one int_array RHS.
+class C2
+  def initialize
+    local, @i = [1, 2].map { |x| x * 10 }
+    @captured_local = local
+  end
+  attr_reader :i, :captured_local
+end
+c2 = C2.new
+puts c2.captured_local  # 10
+puts c2.i               # 20
+
+# (3) ivar targets where the RHS is a top-level method returning
+# a fresh array. The intervening method-boundary forces the
+# `sp_IntArray *` rhs path (RHS is not a literal ArrayNode).
+def make_pair
+  [7, 8]
+end
+class C3
+  attr_reader :x, :y
+  def initialize
+    @x, @y = make_pair
+  end
+end
+c3 = C3.new
+puts c3.x   # 7
+puts c3.y   # 8

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

@@ -0,0 +1,6 @@
+11
+21
+10
+20
+7
+8

data/vendor/spinel/test/multi_write_ivar_widening.rb

@@ -0,0 +1,10 @@
+class Pair
+  def initialize(a, b)
+    @x, @y = [a, b]
+  end
+  attr_reader :x, :y
+end
+
+p = Pair.new("hello", "world")
+puts p.x
+puts p.y

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

@@ -0,0 +1,2 @@
+hello
+world

data/vendor/spinel/test/multi_write_map_block.rb

@@ -0,0 +1,31 @@
+# `A, B = arr.map { block }` is destructuring assignment where
+# each LHS target receives one element of the mapped array.
+# Two related codegen pieces need to land together:
+#
+# 1. Type inference for the target slot. When the block returns a
+#    typed array (e.g. int_array), the target must be typed
+#    accordingly. Without the fix, the outer `infer_type` collapses
+#    array-of-array to the int_array placeholder and every target
+#    comes out as int.
+#
+# 2. Code emission for constant targets when the RHS evaluates to
+#    a ptr_array. Without the fix, the multi-write codegen had
+#    branches for ArrayNode literal RHS and int_array RHS but no
+#    ptr_array branch — every constant target stayed unset.
+
+class C
+  # Outer map produces a ptr_array (each element is an int_array
+  # produced by the inner map).
+  P, Q = [3, 5].map { |n| (0...n).to_a }
+end
+
+# Without the inference fix, P and Q would be typed `int` and the
+# `.length` / `[]` calls below wouldn't compile against the real
+# `sp_IntArray *` values stored in them.
+puts C::P.length   # 3
+puts C::P[0]       # 0
+puts C::P[1]       # 1
+puts C::P[2]       # 2
+puts C::Q.length   # 5
+puts C::Q[3]       # 3
+puts C::Q[4]       # 4

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

@@ -0,0 +1,7 @@
+3
+0
+1
+2
+5
+3
+4

data/vendor/spinel/test/multi_write_setter.rb

@@ -0,0 +1,28 @@
+# `a, b, c.x = expr` where one target is a setter call (`c.x =`)
+# parses to a CallTargetNode in the targets list. Without parser
+# support for CallTargetNode the setter target was silently dropped.
+
+class Box
+  def initialize; @v = 0; end
+  attr_accessor :v
+end
+
+class Holder
+  def initialize
+    @a = 0
+    @b = 0
+    @c = Box.new
+  end
+  def fill
+    @a, @b, @c.v = [11, 22, 33]
+  end
+  def show
+    puts @a
+    puts @b
+    puts @c.v
+  end
+end
+
+h = Holder.new
+h.fill
+h.show

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

@@ -0,0 +1,3 @@
+11
+22
+33

data/vendor/spinel/test/multi_write_typed_array_dispatch.rb

@@ -0,0 +1,44 @@
+# Regression: `a, b = self.method(...)` where `method` returns a typed
+# array other than int_array. compile_multi_write previously emitted
+# `sp_IntArray *tmp = call(); sp_IntArray_get(tmp, k)` for every
+# array-returning RHS that wasn't poly_array / poly. A method
+# returning e.g. obj_<C>_ptr_array therefore type-mismatched at the
+# C-temp declaration and dispatched the wrong getter.
+#
+# Each shape below has the call return a typed array and destructures
+# with two locals; the values must round-trip cleanly.
+
+class Mat
+  attr_accessor :v
+  def initialize(v); @v = v; end
+end
+
+class N
+  def two_mats
+    [Mat.new(11), Mat.new(22)]
+  end
+  def two_floats
+    [1.5, 2.5]
+  end
+  def two_strs
+    ["a", "b"]
+  end
+
+  def go_mats
+    a, b = self.two_mats
+    a.v + b.v
+  end
+  def go_floats
+    a, b = self.two_floats
+    a + b
+  end
+  def go_strs
+    a, b = self.two_strs
+    a + b
+  end
+end
+
+n = N.new
+puts n.go_mats     # 33
+puts n.go_floats   # 4.0
+puts n.go_strs     # "ab"

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

@@ -0,0 +1,3 @@
+33
+4.0
+ab

data/vendor/spinel/test/nested_class_in_class.rb

@@ -0,0 +1,38 @@
+# Nested class definition inside another class.
+# Spinel has no namespace table; bare class names must be unique, so
+# `class A; class B; ... end; end` registers `B` at top level the same
+# way `module M; class B; ... end; end` does.
+
+class A
+  class B
+    def initialize(x)
+      @x = x
+    end
+    attr_reader :x
+  end
+
+  def make_b(x)
+    B.new(x)
+  end
+end
+
+# Direct construction via the path
+b = A::B.new(7)
+puts b.x
+
+# Construction via the outer class
+b2 = A.new.make_b(42)
+puts b2.x
+
+# A nested class with its own nested class
+class Outer
+  class Mid
+    class Inner
+      def hello
+        "hi"
+      end
+    end
+  end
+end
+
+puts Outer::Mid::Inner.new.hello

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

@@ -0,0 +1,3 @@
+7
+42
+hi

data/vendor/spinel/test/nested_class_module_const_resolution.rb

@@ -0,0 +1,38 @@
+# When a class lives inside a module and another class in the same
+# module is referenced via a bare name from one of its method bodies,
+# the inferred type of the resulting ivar/local must carry the same
+# namespace prefix that the class is registered under. Otherwise
+# `c_type` falls back to the short name and the C code references an
+# undeclared `sp_Foo *` that does not match the `sp_M_Foo *` typedef.
+#
+# Pre-fix, `Inner.new` inside `Outer#initialize` was scanned with no
+# lexical scope set on the compiler, so `Inner` resolved to bare and
+# the ivar got recorded as `obj_Inner` while the actual class is
+# registered under `sp_M_Inner`. The struct field declaration would
+# then read `sp_Inner * iv_inner` and the C compiler would reject it
+# with `unknown type name 'sp_Inner'`.
+
+module M
+  class Inner
+    def initialize(x)
+      @x = x
+    end
+    attr_reader :x
+  end
+
+  class Outer
+    def initialize
+      @inner = Inner.new(10)
+    end
+    def via_ivar
+      @inner.x
+    end
+    def via_local
+      tmp = Inner.new(20)
+      tmp.x
+    end
+  end
+end
+
+puts M::Outer.new.via_ivar
+puts M::Outer.new.via_local

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

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

data/vendor/spinel/test/nil_ivar.rb

@@ -0,0 +1,44 @@
+# Test: nil-initialized ivar type inference
+# When @left/@right are initialized to nil and later assigned Node objects,
+# the compiler should infer them as OBJECT(Node), not NIL.
+
+class Node
+  attr_accessor :left, :right, :val
+  def initialize(v)
+    @val = v
+    @left = nil
+    @right = nil
+  end
+end
+
+class Tree
+  attr_accessor :root
+  def initialize
+    @root = nil
+  end
+  def set_root(n)
+    @root = n
+  end
+end
+
+def make_node(depth)
+  n = Node.new(depth)
+  if depth > 0
+    child_l = make_node(depth - 1)
+    child_r = make_node(depth - 1)
+    n.left = child_l
+    n.right = child_r
+  end
+  n
+end
+
+tree = make_node(10)
+puts tree.val
+puts tree.left.val
+puts tree.right.val
+
+t = Tree.new
+t.set_root(tree)
+puts t.root.val
+
+puts "done"

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

@@ -0,0 +1,5 @@
+10
+9
+9
+10
+done

data/vendor/spinel/test/no_attr_write_shortcut_complex.rb

@@ -0,0 +1,33 @@
+# `def x=(v); @x = v * 2; end` looks like an attr_writer at first glance
+# (single InstanceVariableWriteNode body) but the assignment value is a
+# computation, not a bare param reference — `is_simple_writer_method`
+# must not classify it as auto-attr_writer.
+#
+# Without that fix, the method gets auto-registered in @cls_attr_writers,
+# `cls_has_attr_writer(C, "doubled")` returns true, and the call site
+# short-circuits `c.doubled = 5` to `c->iv_doubled = 5` — bypassing the
+# `* 2` entirely. Ruby would print 10; pre-fix Spinel printed 5.
+
+class C
+  def initialize
+    @doubled = 0
+  end
+
+  def doubled=(v)
+    @doubled = v * 2
+  end
+
+  def get_doubled
+    @doubled
+  end
+end
+
+c = C.new
+
+c.doubled = 5
+puts c.get_doubled    # 10  (5 * 2)
+
+c.doubled = -7
+puts c.get_doubled    # -14
+
+puts "done"

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

@@ -0,0 +1,3 @@
+10
+-14
+done