rubyduino 0.1.1

data/vendor/spinel/test/forward_call_class_method_nested.rb

@@ -0,0 +1,35 @@
+# Nested forward-ref: `Outer.new(Inner.new)` where both Outer and
+# Inner are defined later than the construction site. The Inner.new
+# nested arg type must propagate to Outer.initialize's param so the
+# outer Class.new ptype widens correctly.
+
+class Driver
+  def boot
+    @outer = Outer.new(Inner.new(42))
+  end
+  def reach
+    @outer.payload.value
+  end
+end
+
+class Inner
+  def initialize(v)
+    @v = v
+  end
+  def value
+    @v
+  end
+end
+
+class Outer
+  def initialize(inner)
+    @inner = inner
+  end
+  def payload
+    @inner
+  end
+end
+
+d = Driver.new
+d.boot
+puts d.reach

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

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

data/vendor/spinel/test/forward_call_class_method_obj.rb

@@ -0,0 +1,36 @@
+# `Class.new(obj_X)` shape: caller passes a user-class instance to a
+# forward-defined Class.new. Mirrors the optcarrot
+# `PPU.new(@conf, @cpu, @video.palette)` site where the callee's
+# obj-typed param flowed in from a yet-to-be-defined sibling class.
+
+class Holder
+  def initialize(name)
+    @name = name
+  end
+  def label
+    "h:#{@name}"
+  end
+end
+
+class Caller
+  def make
+    @h = Holder.new("alpha")
+    @t = Target.new(@h)
+  end
+  def show
+    @t.held_label
+  end
+end
+
+class Target
+  def initialize(h)
+    @holder = h
+  end
+  def held_label
+    @holder.label
+  end
+end
+
+c = Caller.new
+c.make
+puts c.show

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

@@ -0,0 +1 @@
+h:alpha

data/vendor/spinel/test/forward_call_param_type_inference.rb

@@ -0,0 +1,23 @@
+# Direct-call form (no caller-class wrapper): a top-level method
+# `apply` is the caller, target is a parameter. Verifies the callee's
+# param widening fires when the call is inside a top-level method
+# whose param type for `t` is itself widened from the caller-side
+# type.
+
+def apply(t, arr)
+  t.set_data(arr)
+  t
+end
+
+class Target
+  def set_data(arr)
+    @arr = arr
+  end
+  def length
+    @arr.length
+  end
+end
+
+t = Target.new
+apply(t, [10, 20, 30, 40])
+puts t.length

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

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

data/vendor/spinel/test/forward_call_param_type_int_array.rb

@@ -0,0 +1,34 @@
+# File-order caller-first / callee-second: a Caller class invokes a
+# method on a yet-untyped ivar (because the callee class is defined
+# later in the source). Pre-fix codegen left the callee's params at
+# the default `mrb_int` so the IntArray + bool args produced
+# "incompatible-pointer" / "Wint-conversion" errors when the
+# int→class fallback emitted the call. With the forward-ref widening
+# in place the callee picks up `sp_IntArray *` + `mrb_bool` from
+# this single call site.
+
+class Caller
+  def initialize(target)
+    @target = target
+    @arr = [1, 2, 3]
+    @flag = false
+  end
+  def go
+    @target.set_payload(@arr, @flag)
+  end
+end
+
+class Target
+  def set_payload(arr, flag)
+    @arr = arr
+    @flag = flag
+  end
+  def info
+    "len=#{@arr.length} flag=#{@flag}"
+  end
+end
+
+t = Target.new
+c = Caller.new(t)
+c.go
+puts t.info

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

@@ -0,0 +1 @@
+len=3 flag=false

data/vendor/spinel/test/forward_call_param_type_obj.rb

@@ -0,0 +1,38 @@
+# Forward-call with a user-class-typed arg flowing through the
+# caller's ivar to the callee's parameter slot. Mirrors optcarrot's
+# `@ppu.nametables = @mirroring` shape — the callee accepts an
+# `obj_<UserClass>` and the int→class fallback dispatches via the
+# yet-untyped `@ppu` ivar.
+
+class Holder
+  def initialize(name)
+    @name = name
+  end
+  def label
+    "h:#{@name}"
+  end
+end
+
+class Caller
+  def initialize(target)
+    @target = target
+    @holder = Holder.new("alpha")
+  end
+  def go
+    @target.attach(@holder)
+  end
+end
+
+class Target
+  def attach(h)
+    @holder = h
+  end
+  def held_label
+    @holder.label
+  end
+end
+
+t = Target.new
+c = Caller.new(t)
+c.go
+puts t.held_label

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

@@ -0,0 +1 @@
+h:alpha

data/vendor/spinel/test/gc_root_ptr_array_literal.rb

@@ -0,0 +1,63 @@
+# Regression test: `@x = [Klass.new(...)]` literal must keep the freshly
+# allocated PtrArray reachable across each element's allocation. Without
+# the SP_GC_ROOT on the temp, GC fired during a later Klass.new sees the
+# half-built array as unreachable and frees it, leaving a dangling
+# pointer that gets stored into the ivar.
+#
+# Each Tile holds a 256-float buffer (~2 KB) so that allocating a few
+# hundred Containers crosses the 256 KB GC threshold and forces a
+# collect mid-construction. Repro is non-deterministic without the fix
+# but reliably produces nonzero `errors` at this scale on darwin/arm64.
+
+class Tile
+  attr_accessor :tag, :data
+  def initialize(tag)
+    @tag  = tag
+    @data = Array.new(256, tag.to_f)
+  end
+end
+
+class Container
+  attr_accessor :a, :b, :c
+  def initialize
+    @a = [Tile.new(10), Tile.new(20), Tile.new(30), Tile.new(40)]
+    @b = [Tile.new(11), Tile.new(21), Tile.new(31), Tile.new(41)]
+    @c = [Tile.new(12), Tile.new(22), Tile.new(32), Tile.new(42)]
+  end
+end
+
+containers = [Container.new]
+containers.pop
+
+n = 0
+while n < 1000
+  containers.push(Container.new)
+  n += 1
+end
+
+errors = 0
+ci = 0
+while ci < containers.length
+  c = containers[ci]
+  ta = c.a; tb = c.b; tc = c.c
+  if ta.length != 4 || tb.length != 4 || tc.length != 4
+    errors += 1
+  else
+    bad = false
+    if ta[0].tag != 10 || ta[1].tag != 20 || ta[2].tag != 30 || ta[3].tag != 40
+      bad = true
+    end
+    if tb[0].tag != 11 || tb[1].tag != 21 || tb[2].tag != 31 || tb[3].tag != 41
+      bad = true
+    end
+    if tc[0].tag != 12 || tc[1].tag != 22 || tc[2].tag != 32 || tc[3].tag != 42
+      bad = true
+    end
+    if bad
+      errors += 1
+    end
+  end
+  ci += 1
+end
+
+puts errors

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

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

data/vendor/spinel/test/gc_save_double_in_new.rb

@@ -0,0 +1,13 @@
+class GcSaveDoubleInNew
+  def initialize(path)
+    data = [1, 2, 3]
+    @x = data
+  end
+
+  def step
+    @x.length
+  end
+end
+
+o = GcSaveDoubleInNew.new("a")
+puts o.step

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

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

data/vendor/spinel/test/gc_scan_skip_inherited_ivar.rb

@@ -0,0 +1,54 @@
+# When parent and child both record the same ivar name, the struct
+# field is contributed once by `emit_parent_fields`. `emit_class_struct`
+# already skips child-side redeclaration, so child's own gc_scan walk
+# must also skip the inherited slot — otherwise it emits a second
+# (often miscast) mark on top of the parent walk's correct mark.
+#
+# Here parent's `@data` is widened to poly (heterogeneous writes), and
+# child also writes `@data` from a method-returned poly value, exercising
+# the inherited-slot path under GC pressure.
+
+class Base
+  def initialize(kind)
+    if kind == 0
+      @data = [1, 2, 3]
+    else
+      @data = "hello"
+    end
+  end
+end
+
+class Holder
+  def initialize(v)
+    @v = v
+  end
+  attr_reader :v
+end
+
+class Child < Base
+  def initialize(h)
+    super(0)
+    @data = h.v
+  end
+end
+
+class Trash
+  def initialize(n)
+    @n = n
+    @s = "padding payload " * 64
+  end
+end
+
+h_str = Holder.new("from-holder")
+Holder.new(123)
+c = Child.new(h_str)
+
+junk = []
+i = 0
+while i < 5000
+  junk << Trash.new(i)
+  i = i + 1
+end
+
+puts junk.length
+puts "ok"

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

@@ -0,0 +1,2 @@
+5000
+ok

data/vendor/spinel/test/global_var.rb

@@ -0,0 +1,53 @@
+# Global variable compound writes — Or / And / Operator / Target.
+# Was four tests; merged here. Globals across the original files
+# happened to reuse `$count`, so this file picks distinct names per
+# section so the merged script's accumulated state doesn't change
+# the per-section semantics.
+
+# === Operator-write ($x += / -= / *= / /= ... ) ===
+# Mirror of LocalVariableOperatorWriteNode but the storage is a
+# C-level global symbol via sanitize_gvar(name).
+$counter = 0
+$counter += 1
+$counter += 5
+puts $counter   # 6
+$counter -= 2
+puts $counter   # 4
+$counter *= 3
+puts $counter   # 12
+$counter /= 4
+puts $counter   # 3
+
+# === Or-write ($x ||= val) ===
+# Mirror of LocalVariableOrWriteNode. Only assigns if the global
+# is currently falsy.
+#
+# Note: Spinel uses C-truthy semantics (any zero is falsy), which
+# diverges from CRuby (only nil/false are falsy). For unassigned
+# globals (default 0/nil) the two agree on the first assignment;
+# subsequent ||= against truthy non-zero ints also agree. This
+# test exercises only the agreement region.
+$or_count ||= 5    # never assigned, fires
+puts $or_count     # 5
+$or_count ||= 99   # already 5 (truthy in both), doesn't fire
+puts $or_count     # 5
+
+# === And-write ($x &&= val) ===
+# Mirror of LocalVariableAndWriteNode. Only assigns if the global
+# is currently truthy.
+$and_count = 5
+$and_count &&= 10  # 5 is truthy, fires
+puts $and_count    # 10
+$and_count &&= 0   # 10 is truthy in C, fires
+puts $and_count    # 0
+
+# === Target (multi-assign LHS for globals) ===
+# `$a, $b = 1, 2` -- each LHS slot is a GlobalVariableTargetNode.
+# Routes through MultiWriteNode's emit_multi_write_target to the
+# same g_<name> C-level storage GlobalVariableWriteNode uses.
+$ga, $gb = 1, 2
+puts $ga          # 1
+puts $gb          # 2
+$ga, $gb = $gb, $ga    # swap
+puts $ga          # 2
+puts $gb          # 1

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

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

data/vendor/spinel/test/gvar.rb

@@ -0,0 +1,22 @@
+# Test global variables
+$count = 0
+$name = "world"
+
+def increment
+  $count = $count + 1
+end
+
+def greet
+  puts "hello " + $name
+end
+
+increment
+increment
+increment
+puts $count
+greet
+$name = "ruby"
+greet
+
+$pi = 3.14
+puts $pi

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

@@ -0,0 +1,4 @@
+3
+hello world
+hello ruby
+3.14

data/vendor/spinel/test/hash_dig.rb

@@ -0,0 +1,92 @@
+# Hash#dig: nested key traversal across hash variants.
+
+# 1. Single-key form on each hash variant — alias for `[]`.
+sih = {"one" => 1, "two" => 2}
+puts sih.dig("one")          # 1
+puts sih.dig("two")           # 2
+
+ssh = {"a" => "alpha", "b" => "beta"}
+puts ssh.dig("a")             # alpha
+puts ssh.dig("b")             # beta
+
+ish = {1 => "x", 2 => "y"}
+puts ish.dig(1)               # x
+puts ish.dig(2)               # y
+
+syih = {a: 10, b: 20}
+puts syih.dig(:a)             # 10
+puts syih.dig(:b)             # 20
+
+# 2. Multi-key on a sym_poly_hash with a sym_poly_hash leaf.
+nested = { user: { name: "Alice", age: 30 }, count: 7 }
+puts nested.dig(:user, :name) # Alice
+puts nested.dig(:user, :age)  # 30
+puts nested.dig(:count)       # 7
+
+# 3. Multi-key on a sym_poly_hash whose inner hash is sym_int_hash.
+config = { limits: { read: 100, write: 50 }, version: 2 }
+puts config.dig(:limits, :read)  # 100
+puts config.dig(:limits, :write) # 50
+puts config.dig(:version)        # 2
+
+# 4. Multi-key on a sym_poly_hash whose inner hash is sym_str_hash.
+labels = { en: { hello: "hi", bye: "bye" }, ja: { hello: "konnichiwa", bye: "sayonara" } }
+puts labels.dig(:en, :hello)    # hi
+puts labels.dig(:ja, :bye)      # sayonara
+
+# 5. Three-deep nesting.
+deep = { a: { b: { c: 42 } } }
+puts deep.dig(:a, :b, :c)       # 42
+
+# 6. Missing keys produce nil.
+miss = { a: { b: 1 } }
+puts miss.dig(:nope)            # (blank)
+puts miss.dig(:a, :nope)        # (blank)
+# CRuby raises TypeError on `int.dig(:c)`; spinel returns nil. Not
+# probed here so `.expected` stays comparable to CRuby.
+
+# 7. Same shape for str_poly_hash.
+sph = { "user" => { "name" => "Bob", "age" => 25 } }
+puts sph.dig("user", "name")    # Bob
+puts sph.dig("user", "age")     # 25
+puts sph.dig("missing")         # (blank)
+
+# 8. Real 0 / "" leaves vs missing keys: `p` distinguishes 0 / "" / nil.
+zh = { a: { b: 0 } }
+p zh.dig(:a, :b)                # 0
+p zh.dig(:a, :missing)          # nil
+zs = { a: { b: "" } }
+p zs.dig(:a, :b)                # ""
+p zs.dig(:a, :missing)          # nil
+
+# 9. str_poly_hash with str_int_hash and str_str_hash leaves.
+counts = { "a" => { "x" => 1, "y" => 2 } }
+puts counts.dig("a", "x")       # 1
+p counts.dig("a", "missing")    # nil
+labs2 = { "a" => { "x" => "hi" } }
+puts labs2.dig("a", "x")        # hi
+p labs2.dig("a", "missing")     # nil
+
+# 10. Mid-walk into a non-hash leaf.
+flat = { a: 1 }
+p flat.dig(:a, :b)              # nil
+
+# 11. Each key expression evaluates exactly once across the dig walk.
+def k_first
+  puts "k1"
+  :a
+end
+def k_second
+  puts "k2"
+  :b
+end
+side = { a: { b: 99 } }
+puts side.dig(k_first, k_second)
+
+# 12. Static key-type mismatch returns nil (CRuby compat).
+sym_h = {a: 1}
+p sym_h.dig("a")                # nil  (string key on sym hash)
+str_h = {"a" => 1}
+p str_h.dig(:a)                 # nil  (sym key on str hash)
+mismatch = { a: { b: 1 } }
+p mismatch.dig("a", :b)         # nil  (multi-key first-key mismatch)

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

@@ -0,0 +1,37 @@
+1
+2
+alpha
+beta
+x
+y
+10
+20
+Alice
+30
+7
+100
+50
+2
+hi
+sayonara
+42
+
+
+Bob
+25
+
+0
+nil
+""
+nil
+1
+nil
+hi
+nil
+nil
+k1
+k2
+99
+nil
+nil
+nil

data/vendor/spinel/test/hash_keys_each_shadow.rb

@@ -0,0 +1,40 @@
+# Follow-up to PR #120: the hash.keys.each fusion path emitted the
+# block param as a bare assignment (`lv_k = hash->order[i]`), so a
+# block param that shadowed an outer same-named local of a different
+# type re-used the outer local's C declaration and the assignment
+# warned / produced wrong values. Mirror PR #115's pattern: declare
+# `lv_<bp>` inline with the key's C type and wrap the body in
+# push_scope / declare_var / pop_scope.
+
+# 1. Outer string `k`, inner int key (int_str_hash).
+def f1
+  k = "outer-string"
+  h = {1 => "a", 2 => "b"}
+  h.keys.each do |k|
+    puts k * 10
+  end
+  puts k
+end
+f1
+
+# 2. Outer int `s`, inner string key (str_int_hash).
+def f2
+  s = 42
+  h = {"x" => 1, "y" => 2}
+  h.keys.each do |s|
+    puts s + "!"
+  end
+  puts s
+end
+f2
+
+# 3. Outer string `n`, inner sym key (sym_int_hash).
+def f3
+  n = "outer"
+  h = {a: 10, b: 20}
+  h.keys.each do |n|
+    puts n
+  end
+  puts n
+end
+f3

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

@@ -0,0 +1,9 @@
+10
+20
+outer-string
+x!
+y!
+42
+a
+b
+outer

data/vendor/spinel/test/hash_shorthand.rb

@@ -0,0 +1,37 @@
+# Hash shorthand `{ x:, y: }` (Ruby 3.1+): an AssocNode whose value is
+# implicit. Prism wraps the implicit value in a PM_IMPLICIT_NODE that
+# carries the actual LocalVariableReadNode (or MethodCallNode for an
+# undeclared name) as its `value` child. spinel_parse unwraps the
+# ImplicitNode at the AST boundary so the codegen never sees the
+# wrapper, which means the shorthand reuses the existing
+# AssocNode + LocalVariableReadNode compile path with zero codegen
+# change.
+
+# 1. Two-key shorthand from int-valued locals.
+x = 10
+y = 20
+nums = {x:, y:}
+puts nums[:x]
+# 10
+puts nums[:y]
+# 20
+
+# 2. Single-key shorthand returned from a method body.
+def make_pair(weight)
+  {weight:}
+end
+
+h = make_pair(42)
+puts h[:weight]
+# 42
+
+# 3. Mixing shorthand and explicit pair (same value type — int).
+n = 7
+m = 11
+total = {n:, m:, sum: 18}
+puts total[:n]
+# 7
+puts total[:m]
+# 11
+puts total[:sum]
+# 18

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

@@ -0,0 +1,6 @@
+10
+20
+42
+7
+11
+18