rubyduino 0.1.1

data/vendor/spinel/test/alias_global.rb

@@ -0,0 +1,16 @@
+# AliasGlobalVariableNode -- `alias $copy $orig`.
+#
+# Compile-time only: Spinel registers $copy as a name pointing to
+# $orig's storage slot. Subsequent reads/writes of either share
+# state. Out of scope: dynamic alias from method body, since the
+# entire compile-time map is built once at AST scan.
+
+$orig = "hello"
+alias $copy $orig
+puts $copy        # hello
+
+$orig = "updated"
+puts $copy        # updated
+
+$copy = "back"
+puts $orig        # back

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

@@ -0,0 +1,3 @@
+hello
+updated
+back

data/vendor/spinel/test/alias_method.rb

@@ -0,0 +1,28 @@
+# AliasMethodNode -- `alias greet hello` inside a class body.
+#
+# CRuby snapshots the method at alias time -- if `hello` is later
+# redefined, `greet` still calls the original. In Spinel's AOT model
+# methods are static C functions; we register a compile-time
+# synonym so dispatch on `.greet` routes to the same C function as
+# `.hello`. Out of scope: alias inside a method body (CRuby allows
+# but the semantics differ); alias of an inherited method.
+
+class Greeter
+  def hello = "hi from hello"
+  alias greet hello
+end
+
+g = Greeter.new
+puts g.hello   # hi from hello
+puts g.greet   # hi from hello
+
+# Two aliases of the same method.
+class Counter
+  def value = 42
+  alias get value
+  alias read value
+end
+c = Counter.new
+puts c.value   # 42
+puts c.get     # 42
+puts c.read    # 42

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

@@ -0,0 +1,5 @@
+hi from hello
+hi from hello
+42
+42
+42

data/vendor/spinel/test/and_node_poly_operand.rb

@@ -0,0 +1,24 @@
+# `a && b` codegen used to lower to raw C `a && b` regardless of
+# operand type. When either operand is `sp_RbVal` (poly), C rejects
+# `&&` between a struct and an int. Wrap poly operands with
+# `sp_poly_truthy`.
+
+class Holder
+  def initialize
+    @poly = "x"   # string first…
+    @poly = 42    # …then int — slot widens to poly
+    @counter = 0
+  end
+
+  attr_reader :poly, :counter
+
+  def chain
+    if @poly && @counter == 0
+      @counter = 1
+    end
+    @counter
+  end
+end
+
+h = Holder.new
+puts h.chain    # 1

data/vendor/spinel/test/anon_block_forward.rb

@@ -0,0 +1,47 @@
+# Anonymous `&` block forwarding (Ruby 3.1+).
+#
+# `def outer(&); inner(&); end` declares an unnamed block parameter
+# and forwards it via the matching anonymous `&` in the call. Pre-fix,
+# the parameter `BlockParameterNode { name: nil }` was registered with
+# an empty name, leaving the method without a `_block`/`lv_` slot, and
+# the forwarding `BlockArgumentNode { expression: -1 }` got dropped at
+# the call site (it slipped through `find_block_arg`'s -1 return).
+#
+# Fix synthesizes the internal name `__anon_block` for unnamed block
+# params so they flow through `find_block_param_name` and
+# `@current_method_block_param` like any other `&block`, and extends
+# `block_forward_expr` to forward the current method's anon-block
+# slot when it sees a BlockArgumentNode with no expression.
+
+# 1. Top-level outer/inner with anonymous & forwarding.
+def outer(&)
+  inner(&)
+end
+
+def inner(&block)
+  block.call
+end
+
+outer { puts "1-top-level" }
+
+# 2. Anonymous & with a body that does work before forwarding.
+def with_prefix(label, &)
+  puts label
+  inner(&)
+end
+
+with_prefix("2-prefix") { puts "  body" }
+
+# 3. Anonymous & on a class instance method, forwarding to another
+#    class instance method via typed-receiver dispatch.
+class Outer
+  def kick(&)
+    sink(&)
+  end
+
+  def sink(&block)
+    block.call
+  end
+end
+
+Outer.new.kick { puts "3-class-method" }

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

@@ -0,0 +1,4 @@
+1-top-level
+2-prefix
+  body
+3-class-method

data/vendor/spinel/test/array_3d_nested.rb

@@ -0,0 +1,48 @@
+# Deep-nested array literals (3D and beyond). Spinel doesn't
+# have a typed `<X>_ptr_array_ptr_array` slot — the second-level
+# `[[1,2,3],[4,5,6]]` infers as `int_array_ptr_array` and the
+# outer `[[[...]],[[...]]]` would naively box each element via
+# `sp_box_ptr_array`, which erases the elem-type info and
+# leaves the dispatch returning an unknown obj at the next `[]`
+# read.
+#
+# Fix: when an array literal element is itself a typed
+# ptr_array (or already poly_array) and the outer is
+# poly_array, recompile the inner literal as poly_array so
+# every level boxes via `sp_box_poly_array` / `sp_box_int_array`
+# / etc. — the cls_id chain stays tagged and the poly-builtin
+# dispatch recurses correctly through `arr[i][j][k]...`.
+#
+# The recursion in `compile_array_literal_as_poly` makes the
+# fix dimension-agnostic — 3D, 4D, 5D, ... all work.
+#
+# Without the fix `read` returned 0 for every index (sp_box_nil
+# fallback). With the fix it returns the right ints.
+
+class H3
+  def initialize
+    @t = [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]
+  end
+  def read(i, j, k); @t[i][j][k]; end
+end
+
+h3 = H3.new
+puts h3.read(0, 0, 0)   # 1
+puts h3.read(0, 1, 1)   # 5
+puts h3.read(1, 0, 2)   # 9
+puts h3.read(1, 1, 2)   # 12
+
+# 4D — recursion handles arbitrary depth.
+class H4
+  def initialize
+    @t = [[[[1, 2], [3, 4]], [[5, 6], [7, 8]]],
+          [[[9, 10], [11, 12]], [[13, 14], [15, 16]]]]
+  end
+  def read(i, j, k, l); @t[i][j][k][l]; end
+end
+
+h4 = H4.new
+puts h4.read(0, 0, 0, 0)   # 1
+puts h4.read(0, 1, 0, 1)   # 6
+puts h4.read(1, 0, 1, 0)   # 11
+puts h4.read(1, 1, 1, 1)   # 16

data/vendor/spinel/test/array_clear_typed.rb

@@ -0,0 +1,40 @@
+# `Array#clear` on typed arrays used to fall through the
+# dispatcher and produce no C output, leaving the array
+# unchanged. Zero the length (and `start` for IntArray, which
+# uses a sliding window) so the next push refills from index 0.
+
+# IntArray
+ints = [1, 2, 3]
+ints.clear
+puts ints.length    # 0
+ints.push(7)
+puts ints[0]        # 7
+
+# SymArray (shares IntArray internally)
+syms = [:a, :b, :c]
+syms.clear
+puts syms.length    # 0
+
+# FloatArray
+floats = [1.5, 2.5, 3.5]
+floats.clear
+puts floats.length  # 0
+
+# StrArray
+strs = ["a", "b", "c"]
+strs.clear
+puts strs.length    # 0
+
+# PtrArray (array of objects)
+class Box
+  attr_reader :n
+  def initialize(n); @n = n; end
+end
+boxes = [Box.new(1), Box.new(2)]
+boxes.clear
+puts boxes.length   # 0
+
+# PolyArray (mixed-type elements)
+mixed = [1, "x", :sym, 4.5]
+mixed.clear
+puts mixed.length   # 0

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

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

data/vendor/spinel/test/array_concat.rb

@@ -0,0 +1,18 @@
+# Array#concat used to silently miss the type-check on both poly_array
+# and ptr_array — the loop never ran, so the receiver kept its
+# original length. Both shapes regression-tested here.
+
+# poly_array (heterogeneous)
+a = [1, "x"]
+a.concat([2, "y"])
+puts a.length
+
+# ptr_array (user objects)
+class Bar
+  def initialize(x); @x = x; end
+  attr_accessor :x
+end
+
+b = [Bar.new(1)]
+b.concat([Bar.new(2), Bar.new(3)])
+puts b.length

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

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

data/vendor/spinel/test/array_each_with_object.rb

@@ -0,0 +1,17 @@
+# Array#each_with_object on poly_array and ptr_array used to silently
+# miss the type-check; the loop body never ran. Both shapes covered.
+
+# poly_array (heterogeneous)
+n = 0
+[1, "x"].each_with_object("") {|_e, _a| n += 1 }
+puts n
+
+# ptr_array (user objects)
+class Bar
+  def initialize(x); @x = x; end
+  attr_accessor :x
+end
+
+m = 0
+[Bar.new(1), Bar.new(2)].each_with_object("") {|_e, _a| m += 1 }
+puts m

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

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

data/vendor/spinel/test/array_fill_poly.rb

@@ -0,0 +1,17 @@
+# `arr.fill(val)` on a poly_array used to lower as
+# `sp_PolyArray_set(arr, i, val)` with the raw scalar `val`. The
+# storage is sp_RbVal — passing an unboxed int / str / float
+# fails to compile (`incompatible type for argument 3 of
+# sp_PolyArray_set`).
+#
+# Fix: wrap the value via `box_value_to_poly` first when the
+# receiver is `poly_array`. Other typed-array fills (int / float
+# / str / sym / ptr) keep their raw scalar path.
+
+def make_arr
+  arr = [1, "two", 3.14]   # heterogeneous → poly_array
+  arr.fill(42)
+  arr
+end
+
+p make_arr   # [42, 42, 42]

data/vendor/spinel/test/array_flat_map.rb

@@ -0,0 +1,16 @@
+# Array#flat_map where the block returns a poly_array / ptr_array
+# failed to type the result; the inferred receiver-array type clashed
+# with the generated inner accumulator. Both shapes covered.
+
+# poly_array
+a = [1, "x"].flat_map { |pe| [pe, pe] }
+puts a.length
+
+# ptr_array
+class Bar
+  def initialize(x); @x = x; end
+  attr_accessor :x
+end
+
+b = [Bar.new(1), Bar.new(2)].flat_map { |re| [re, re] }
+puts b.length

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

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

data/vendor/spinel/test/array_keyed_hash_int_array_eql.rb

@@ -0,0 +1,29 @@
+# Array-keyed Hash. `entries[[a, b]] ||= ...` was broken because
+# spinel's PolyPolyHash defaulted to pointer-identity comparison
+# for SP_TAG_OBJ keys — every fresh `[a, b]` literal allocated a
+# new IntArray, so identical-content keys never matched and the
+# `||=` never deduped. The cache grew unboundedly and reads with
+# a fresh `[a, b]` returned nil.
+#
+# Fix: extend the codegen-emitted sp_obj_hash_hook /
+# sp_obj_eql_hook to handle SP_BUILTIN_INT_ARRAY with element-wise
+# content hash + comparison. Two IntArray instances with the same
+# elements now hash and eql? identically — array-keyed Hash
+# behaves like CRuby's `Hash` with the [a,b]-style key idiom.
+
+entries = {}
+entries[[1, 2]] = "a"
+entries[[3, 4]] = "b"
+entries[[1, 2]] ||= "z"   # already set, no overwrite
+puts entries[[1, 2]]      # "a"
+puts entries[[3, 4]]      # "b"
+puts entries.length       # 2
+
+# Heterogeneous keys still work — int / IntArray / string mixed.
+mixed = {}
+mixed[42] = "int-key"
+mixed[[5, 6, 7]] = "arr-key"
+mixed[[5, 6, 7]] ||= "no-overwrite"
+puts mixed[42]            # int-key
+puts mixed[[5, 6, 7]]     # arr-key
+puts mixed.length         # 2

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

@@ -0,0 +1,6 @@
+a
+b
+2
+int-key
+arr-key
+2

data/vendor/spinel/test/array_method_name_clash.rb

@@ -0,0 +1,15 @@
+# A user class with a method whose name overlaps an Array method (e.g.
+# `def sample`, `def first`) used to compile to the Array dispatch even
+# when the receiver wasn't an array. `array_c_prefix` falls back to
+# `IntArray`, so e.g. `m.sample` on `sp_Mixer *` emitted
+# `sp_IntArray_get(m, rand() % sp_IntArray_length(m))` and gcc rejected
+# the pointer-type mismatch.
+
+class Mixer
+  def sample
+    42
+  end
+end
+
+m = Mixer.new
+puts m.sample

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

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

data/vendor/spinel/test/array_new_block_typed_container.rb

@@ -0,0 +1,37 @@
+# `Array.new(N) { block }` should pick its accumulator container
+# from the block's return type, not collapse to IntArray. Without
+# the fix, `Array.new(N) { _x = [0]; _x.clear; _x }` (the seed-int
+# idiom for an empty-but-typed inner array) emits a flat IntArray
+# at the C level, then later `<<` pushes silently cast pointers
+# to ints — every read returns 0.
+#
+# The fix mirrors compile_map_expr's range / typed-container
+# branch: infer the block tail's type and emit StrArray /
+# FloatArray / PtrArray<X> / PolyArray accordingly. Three call
+# sites need it (infer_type, infer_ivar_init_type,
+# compile_constructor_expr) so the ivar widening pipeline stays
+# consistent.
+
+class C
+  def initialize
+    @typed = Array.new(4) { _a = [0]; _a.clear; _a }
+    @strs  = Array.new(3) { |i| "row#{i}" }
+    @flts  = Array.new(3) { |i| i.to_f * 0.5 }
+  end
+  def push_typed(i, v); @typed[i] << v; end
+  def get_typed(i, j); @typed[i][j]; end
+  def get_str(i); @strs[i]; end
+  def get_flt(i); @flts[i]; end
+end
+
+c = C.new
+c.push_typed(0, 100)
+c.push_typed(0, 200)
+c.push_typed(2, 999)
+puts c.get_typed(0, 0)    # 100
+puts c.get_typed(0, 1)    # 200
+puts c.get_typed(2, 0)    # 999
+puts c.get_str(0)         # row0
+puts c.get_str(2)         # row2
+puts c.get_flt(0)         # 0.0
+puts c.get_flt(2)         # 1.0

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

@@ -0,0 +1,7 @@
+100
+200
+999
+row0
+row2
+0.0
+1.0

data/vendor/spinel/test/array_new_empty_inner_deferred.rb

@@ -0,0 +1,47 @@
+# `Array.new(N) { [].dup }` returns an array of N empty-array
+# inners. The static element type of `[]` is ambiguous — int_array
+# is the natural default but if later pushes drop pointer-typed
+# values (3-tuples, IntArrays, ...) into the inner, that fallback
+# silently truncates the pointer to mrb_int and the cache is
+# corrupt.
+#
+# After the fix, `Array.new(N) { [].dup }` (and `{ [] }`) emits
+# each inner as a fresh sp_PolyArray. Pushes go through the
+# sp_poly_shl runtime cls_id dispatch (any kind survives), and
+# `arr[i][j]` reads back the boxed element with its real cls_id
+# preserved. The outer Array.new returns `poly_array` so the
+# whole structure is sp_PolyArray of sp_PolyArrays.
+#
+# Also covers the multi-write destructure poly RHS shape that
+# arises naturally:
+# `@a, @b, = entries[key]` against entries: poly_poly_hash whose
+# values are 3-element arrays. compile_multi_write now recognizes
+# val_t_local == "poly" and unboxes via cls_id-POLY_ARRAY check.
+
+class C
+  def initialize
+    @inners = [Array.new(4) { [].dup }, Array.new(4) { [].dup }]
+  end
+  def add_tuple(b, i, io, ptr, shift)
+    entry = [io, ptr, shift]
+    @inners[b][i] << entry
+  end
+  def get_io(b, i, k);    @inners[b][i][k][0]; end
+  def get_shift(b, i, k); @inners[b][i][k][2]; end
+  def len(b, i);          @inners[b][i].length; end
+end
+
+c = C.new
+inner_a = [10, 20, 30]
+inner_b = [40, 50, 60]
+c.add_tuple(0, 0, 0x100, inner_a, 4)
+c.add_tuple(0, 0, 0x200, inner_b, 6)
+c.add_tuple(1, 2, 0x300, inner_a, 0)
+puts c.get_io(0, 0, 0)        # 256
+puts c.get_shift(0, 0, 0)     # 4
+puts c.get_io(0, 0, 1)        # 512
+puts c.get_shift(0, 0, 1)     # 6
+puts c.get_io(1, 2, 0)        # 768
+puts c.len(0, 0)              # 2
+puts c.len(1, 2)              # 1
+puts c.len(0, 3)              # 0

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

@@ -0,0 +1,8 @@
+256
+4
+512
+6
+768
+2
+1
+0

data/vendor/spinel/test/array_partition_gc.rb

@@ -0,0 +1,20 @@
+# Regression: Array#partition (block form) returns a tuple holding two
+# inner arrays. The tuple's sp_gc_alloc was emitted with scan=NULL, so
+# the inner arrays were swept while the tuple was still alive, and a
+# subsequent allocation reused the freed memory — `parts[0].length`
+# came back as the length of whatever object now sat there.
+
+arr = [1, 2, 3, 4, 5, 6]
+parts = arr.partition { |x| x.odd? }
+
+# Force many GCs by allocating lots of GC-managed objects.
+i = 0
+while i < 200000
+  tmp = [1, 2, 3]
+  tmp.push(i)
+  i += 1
+end
+
+puts parts[0].length   # 3
+puts parts[1].length   # 3
+puts "done"

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

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

data/vendor/spinel/test/array_plus.rb

@@ -0,0 +1,18 @@
+# Array#+ used to fall through on poly_array / ptr_array — the result
+# temp held its default 0 because the dispatcher's type-list omitted
+# those shapes.
+
+# poly_array
+a = [1, "x"]
+b = [2, "y"]
+puts (a + b).length
+
+# ptr_array
+class Bar
+  def initialize(x); @x = x; end
+  attr_accessor :x
+end
+
+c = [Bar.new(1)]
+d = [Bar.new(2)]
+puts (c + d).length

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

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

data/vendor/spinel/test/array_rotate_bang.rb

@@ -0,0 +1,54 @@
+# Array#rotate!(n): in-place left rotation by n positions.
+# Previously the bang form was not dispatched at all and the codegen
+# emitted a no-op, so `rotate!` left the array untouched.
+
+# IntArray
+ints = [1, 2, 3, 4, 5]
+ints.rotate!(2)
+ints.each { |i| puts i }   # 3 4 5 1 2
+
+# Negative n rotates right.
+ints2 = [1, 2, 3, 4, 5]
+ints2.rotate!(-1)
+ints2.each { |i| puts i }  # 5 1 2 3 4
+
+# n larger than length wraps modulo len.
+ints3 = [1, 2, 3]
+ints3.rotate!(7)
+ints3.each { |i| puts i }  # 2 3 1
+
+# Empty array is a no-op (no malloc, no crash).
+empty = []
+empty.rotate!(3)
+puts empty.length          # 0
+
+# SymArray (shares the IntArray helper internally).
+syms = [:a, :b, :c, :d]
+syms.rotate!(1)
+syms.each { |s| puts s }   # b c d a
+
+# FloatArray
+floats = [1.5, 2.5, 3.5, 4.5]
+floats.rotate!(2)
+floats.each { |f| puts f } # 3.5 4.5 1.5 2.5
+
+# StrArray
+strs = ["a", "b", "c", "d"]
+strs.rotate!(1)
+strs.each { |s| puts s }   # b c d a
+
+# PtrArray (array of objects)
+class Box
+  attr_reader :n
+  def initialize(n)
+    @n = n
+  end
+end
+boxes = [Box.new(10), Box.new(20), Box.new(30), Box.new(40)]
+boxes.rotate!(2)
+boxes.each { |b| puts b.n } # 30 40 10 20
+
+# PolyArray (mixed-type elements)
+mixed = [1, "x", :sym, 4.5]
+mixed.rotate!(1)
+mixed.each { |v| puts v }   # x sym 4.5 1

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

@@ -0,0 +1,34 @@
+3
+4
+5
+1
+2
+5
+1
+2
+3
+4
+2
+3
+1
+0
+b
+c
+d
+a
+3.5
+4.5
+1.5
+2.5
+b
+c
+d
+a
+30
+40
+10
+20
+x
+sym
+4.5
+1

data/vendor/spinel/test/array_shuffle_ptr.rb

@@ -0,0 +1,11 @@
+# Array#shuffle / Array#shuffle! used to skip ptr_array. The
+# dispatcher silently fell through, the result temp ended up `0`,
+# and the runtime had no PtrArray shuffle helper to call anyway.
+
+class Bar
+  def initialize(x); @x = x; end
+  attr_accessor :x
+end
+
+arr = [Bar.new(1), Bar.new(2), Bar.new(3)]
+puts arr.shuffle.length

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

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