rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/test/map_array_block_result.rb

@@ -1,29 +0,0 @@
-# `arr.map { array_block }` — outer recv is a typed Array, block
-# returns a typed array (`(0..i).to_a` here is int_array). Without
-# the fix, two issues conspire:
-#
-#   - infer_method_name_type returned int_array, so the ivar `@rows`
-#     was typed as int_array. The outer accumulator was an
-#     sp_IntArray pushed via sp_IntArray_push — but each iteration's
-#     value was an sp_IntArray pointer reinterpreted as mrb_int,
-#     which gcc rejects on -Wint-conversion.
-#   - Even if the cast were silent, the inner arrays would not be
-#     traced from an IntArray slot and could be collected mid-loop.
-#
-# After the fix, the result is `<elem>_ptr_array` and the codegen
-# accumulator is an sp_PtrArray pushed via sp_PtrArray_push.
-
-class C
-  def initialize
-    @rows = [1, 6].map { |i| (0..i).to_a }
-  end
-
-  def show
-    @rows.each do |row|
-      row.each { |x| print x, " " }
-      puts
-    end
-  end
-end
-
-C.new.show

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

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

data/vendor/spinel/test/map_block_returns_nested_array.rb

@@ -1,53 +0,0 @@
-# `Range#map` / `int_array.map` whose block returns an array
-# (1D, 2D, 3D nested) used to silently degrade — the codegen
-# returned `0` for non-int/string/float block returns at the
-# Range#map path, and `int_array.map` boxed inner ptr_array
-# results via `sp_box_ptr_array(val)` which erased the
-# elem-type info (cls_id PTR_ARRAY only) so deeper indexing
-# fell through every dispatch arm to `sp_box_nil()`.
-#
-# Fixes:
-#
-# - Range#map block returning a typed array now stores in
-#   `sp_PtrArray` (matching the inferred `<bret>_ptr_array`
-#   type). Deeper nesting (block returns ptr_array /
-#   poly_array) stores in `sp_PolyArray` with `box_value_to_poly`
-#   boxing — preserves cls_id chain for `arr[i][j][k]...`.
-#
-# - `int_array.map`'s deep-array branch (block returns
-#   `<X>_ptr_array`) converts the inner sp_PtrArray to
-#   sp_PolyArray inline via a per-element `sp_box_<elem>` re-tag,
-#   so the outer PolyArray's elements carry the right cls_id at
-#   the next dispatch level.
-#
-# Together this lets nested-map-of-array-block constructs
-# (e.g. optcarrot's `TILE_LUT = [...].map { (0..7).map {
-# (0...0x10000).map { ... } }.transpose }`) compile and read
-# at every depth.
-
-# Range#map -> int_array_ptr_array (2D)
-class M2
-  def initialize
-    @t = (0..2).map { |i| (0..3).map { |j| i * 10 + j } }
-  end
-  def read(i, j); @t[i][j]; end
-end
-m2 = M2.new
-puts m2.read(0, 0)   # 0
-puts m2.read(1, 2)   # 12
-puts m2.read(2, 3)   # 23
-
-# int_array.map { Range#map { ... } } -> 3D via PolyArray
-class M3
-  def initialize
-    @t = [10, 20].map do |a|
-      (0..2).map { |b| [a + b, a + b + 100] }
-    end
-  end
-  def read(i, j, k); @t[i][j][k]; end
-end
-m3 = M3.new
-puts m3.read(0, 0, 0)   # 10
-puts m3.read(0, 1, 1)   # 111
-puts m3.read(1, 2, 0)   # 22
-puts m3.read(1, 2, 1)   # 122

data/vendor/spinel/test/map_empty_block.rb

@@ -1,26 +0,0 @@
-# Issue #210 follow-up: an empty `map {}` block must still produce
-# an array of the same length as the receiver. Each map dispatch
-# (Range#, N.times#, int_array#, str_array#, poly_array#) used to
-# skip the push entirely on an empty block, leaving the typed
-# accumulator short and downstream `.length` / `[i]` wrong.
-
-# Range#map
-puts (0..2).map {}.length          # 3
-
-# N.times.map
-puts 4.times.map {}.length         # 4
-
-# int_array#map
-puts [10, 20, 30].map {}.length    # 3
-
-# str_array#map
-puts ["a", "b", "c", "d"].map {}.length   # 4
-
-# poly_array#map
-puts [1, "two", :three].map {}.length     # 3
-
-# ptr_array#map (homogeneous obj_X[])
-class Box
-  def initialize(v); @v = v; end
-end
-puts [Box.new(1), Box.new(2), Box.new(3)].map {}.length  # 3

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

@@ -1,6 +0,0 @@
-3
-4
-3
-4
-3
-3

data/vendor/spinel/test/map_range_recv_array_block.rb

@@ -1,31 +0,0 @@
-# `infer_method_name_type` for `map` used to fall through to
-# `infer_type(recv)` when the block returned a non-trivial shape
-# (an array literal). For a Range recv that yielded `range`,
-# poisoning any ivar holding the result; an `@x = something_else`
-# assignment then failed to type-check (`@x = 0` against an
-# `sp_Range` slot).
-#
-# Now `Range#map { array_block }` infers as `<inner>_ptr_array`
-# (matching the runtime sp_PtrArray storage), so the result can
-# be indexed `arr[i][j]` directly. A subsequent re-assignment
-# with a different array shape goes to a separate slot to avoid
-# spinel's slot widening to poly.
-
-class C
-  def initialize
-    # Block returns an int_array — outer is int_array_ptr_array.
-    @rows = (0...3).map { |i| [i, i * 10] }
-    # Separate slot for a plain int_array.
-    @flat = [10, 20, 30]
-  end
-
-  def show
-    @rows.each { |row| row.each { |v| puts v } }
-    @flat.each { |v| puts v }
-  end
-end
-
-C.new.show
-# Expected:
-#   0 / 0 / 1 / 10 / 2 / 20 (each row's elements)
-#   10 / 20 / 30 (flat)

data/vendor/spinel/test/method_param_unify_to_poly.rb

@@ -1,40 +0,0 @@
-# Disagreeing call-site types for the same parameter need to widen
-# to `poly`. Pre-fix, `scan_new_calls` (obj-recv) and
-# `scan_cls_method_calls` (self-call inside the same class) both
-# only widened FROM "int": once the first non-int call site set the
-# param type, subsequent disagreeing calls were silently accepted
-# and the C compiler rejected the eventual mismatched call.
-#
-# Once the param widens to `poly`, the int / pointer / etc. arguments
-# at the call sites need to be boxed via `sp_box_*`. That boxing
-# branch was also missing from `compile_typed_call_args`, so even
-# after unify produced "poly", the call sites still passed raw
-# mrb_int / pointers to a sp_RbVal-typed parameter.
-
-class CPU
-  def feed(x, val)
-    val
-  end
-  # Self-call (no receiver). Lands in scan_cls_method_calls.
-  def boot
-    feed("hello", 1)
-    feed(20, 2)
-    feed("world", 3)
-  end
-end
-
-class User
-  def initialize(cpu)
-    @cpu = cpu
-  end
-  # Obj-recv call. Lands in scan_new_calls' obj branch.
-  def reset
-    @cpu.feed(100, 10)
-    @cpu.feed("via_user", 20)
-    @cpu.feed(500, 30)
-  end
-end
-
-cpu = CPU.new
-puts cpu.boot
-puts User.new(cpu).reset

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

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

data/vendor/spinel/test/multi_arg_block_call.rb

@@ -1,56 +0,0 @@
-# Multi-argument `block.call(a, b, ...)` on the proc-object path.
-#
-# Pre-fix, `compile_proc_literal` hardcoded the lambda's signature
-# as `static mrb_int <fn>(void *_cap, mrb_int lv_<bp>)` — a single
-# `mrb_int` slot — and the call site always lowered to
-# `sp_proc_call(lv_<rname>, <arg0>)`, so any second/third positional
-# arg was silently dropped.
-#
-# Fix collects every block param at proc-literal time and emits
-# `(void *_cap, mrb_int lv_<bp1>, mrb_int lv_<bp2>, ...)`, then
-# dispatches the call site to `sp_proc_call_N` (added to the
-# runtime: cast the stored function pointer to the matching N-arg
-# signature and invoke).
-#
-# Out of scope: arity-mismatched calls (`proc { |a| } .call(1, 2)`)
-# stay UB on the C side. Spinel's static dispatch enforces match in
-# the test cases below.
-
-# 1. Basic: forwarded `&block` invoked with 2 args.
-class App
-  def run(&block)
-    block.call(10, 20)
-  end
-end
-
-App.new.run { |a, b| puts a + b }
-
-# 2. 3-arg block.call.
-class Wider
-  def go(&block)
-    block.call(1, 2, 3)
-  end
-end
-
-Wider.new.go { |x, y, z| puts x + y + z }
-
-# 3. Same proc invoked twice with different concrete args.
-class Twice
-  def both(&block)
-    block.call(100, 1)
-    block.call(200, 2)
-  end
-end
-
-Twice.new.both { |a, b| puts a * b }
-
-# 4. 0-param block called with one arg. Extra arg is silently dropped
-# (matches CRuby semantics). Exercises the `_unused` fallback path
-# that the multi-param refactor must leave intact.
-class Drop
-  def go(&block)
-    block.call(99)
-  end
-end
-
-Drop.new.go { puts "called" }

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

@@ -1,5 +0,0 @@
-30
-6
-100
-400
-called

data/vendor/spinel/test/multi_assign_ivar.rb

@@ -1,33 +0,0 @@
-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

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

data/vendor/spinel/test/multi_write_const.rb

@@ -1,36 +0,0 @@
-# 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

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

data/vendor/spinel/test/multi_write_from_poly_recv.rb

@@ -1,34 +0,0 @@
-# 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_ivar.rb

@@ -1,34 +0,0 @@
-# `@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

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

data/vendor/spinel/test/multi_write_ivar_widening.rb

@@ -1,10 +0,0 @@
-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

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

data/vendor/spinel/test/multi_write_map_block.rb

@@ -1,31 +0,0 @@
-# `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

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

data/vendor/spinel/test/multi_write_setter.rb

@@ -1,28 +0,0 @@
-# `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

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

data/vendor/spinel/test/multi_write_typed_array_dispatch.rb

@@ -1,44 +0,0 @@
-# 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

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

data/vendor/spinel/test/nested_class_in_class.rb

@@ -1,38 +0,0 @@
-# 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

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

data/vendor/spinel/test/no_attr_write_shortcut_complex.rb

@@ -1,33 +0,0 @@
-# `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

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

data/vendor/spinel/test/no_attr_write_shortcut_multi.rb

@@ -1,38 +0,0 @@
-# `obj.x = v` must dispatch to `def x=(v)` when x= is not a registered
-# attr_writer. A multi-statement body never matched the auto-attr_writer
-# pattern (which requires a single `InstanceVariableWriteNode` body), so
-# the fix at the call site is sufficient on its own to make this case
-# work — no auto-classification change required.
-
-class C
-  attr_accessor :real
-
-  def initialize
-    @real = 0
-    @logged = ""
-  end
-
-  # Multi-statement writer. Side-effects on a *different* ivar so we can
-  # tell whether the def actually ran.
-  def logged=(v)
-    @logged = "set:" + v
-    @real = v.length
-  end
-
-  def get_logged
-    @logged
-  end
-end
-
-c = C.new
-
-# attr_accessor path: still short-circuits to field write.
-c.real = 7
-puts c.real           # 7
-
-# Multi-statement def x=: must dispatch (not bypass).
-c.logged = "hello"
-puts c.get_logged     # set:hello
-puts c.real           # 5  (overwritten by the side effect)
-
-puts "done"