rubyduino 0.1.1

data/vendor/spinel/test/rescue.rb

@@ -0,0 +1,48 @@
+# Test rescue/raise/ensure
+
+def safe_div(a, b)
+  if b == 0
+    raise "division by zero"
+  end
+  a / b
+end
+
+# Basic rescue
+begin
+  result = safe_div(10, 2)
+  puts result  # 5
+rescue
+  puts "error"
+end
+
+# Rescue with exception
+begin
+  result = safe_div(10, 0)
+  puts result
+rescue => e
+  puts e  # division by zero
+end
+
+# Ensure
+def with_ensure
+  puts "start"
+  raise "oops"
+  puts "unreachable"
+rescue => e
+  puts e  # oops
+ensure
+  puts "cleanup"
+end
+with_ensure
+
+# Retry pattern
+attempts = 0
+begin
+  attempts += 1
+  raise "fail" if attempts < 3
+  puts attempts  # 3
+rescue
+  retry if attempts < 3
+end
+
+puts "done"

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

@@ -0,0 +1,7 @@
+5
+division by zero
+start
+oops
+cleanup
+3
+done

data/vendor/spinel/test/rescue_modifier_assign.rb

@@ -0,0 +1,24 @@
+# `expr rescue fallback` as an rvalue — verifies that
+# RescueModifierNode is wired into infer_type so the receiving
+# variable gets the unified type rather than the default int.
+#
+# Note: Ruby's `=` has higher precedence than the rescue modifier,
+# so `a = "x" rescue "y"` parses as `(a = "x") rescue "y"` — the
+# RescueModifierNode wraps the assignment, not the rvalue. To
+# actually exercise the RescueModifierNode-as-rvalue path through
+# infer_type, the rescue must be parenthesized as a sub-expression.
+
+# Same-type branches: string=string. Trivial baseline.
+a = ("ok" rescue "fallback")
+puts a
+
+# Mismatched branches: main is `raise` (returns int 0 from
+# compile_expr but never actually returns), fallback is string.
+# The fallback wins type inference; result type is string.
+b = (raise "boom" rescue "default")
+puts b
+
+# Same-type int. Endless method shape stays unchanged.
+def parse_int(s) = Integer(s) rescue 0
+puts parse_int("42")
+puts parse_int("abc")

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

@@ -0,0 +1,4 @@
+ok
+default
+42
+0

data/vendor/spinel/test/rightward_assign.rb

@@ -0,0 +1,36 @@
+# Rightward assignment `expr => var` (Ruby 3.0+). Prism encodes this
+# as a MatchRequiredNode whose `pattern` is a LocalVariableTargetNode.
+# spinel_parse rewrites the simple-target case to a LocalVariableWriteNode
+# at the AST boundary so the codegen reuses the regular assignment path.
+
+# 1. Integer rightward assignment.
+42 => x
+puts x
+# 42
+
+# 2. String rightward assignment.
+"hello" => msg
+puts msg
+# hello
+
+# 3. Method-call result rightward-assigned.
+def square(n)
+  n * n
+end
+
+square(7) => sq
+puts sq
+# 49
+
+# 4. Rightward inside an expression (each statement creates one local).
+1 + 2 + 3 => total
+total * 2 => doubled
+puts total
+# 6
+puts doubled
+# 12
+
+# 5. Boolean.
+(5 > 3) => is_bigger
+puts is_bigger
+# true

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

@@ -0,0 +1,6 @@
+42
+hello
+49
+6
+12
+true

data/vendor/spinel/test/runtime_widen_int_to_poly_array.rb

@@ -0,0 +1,27 @@
+# `compile_bracket_assign`'s `rt == "poly"` branch dispatches
+# `@arr[i] = v` by runtime cls_id, but when the slot's runtime
+# storage is IntArray and the rhs carries a non-int payload (a
+# typed pointer / box whose cls_id we'd lose if cast to int),
+# the write silently truncates to int.
+#
+# This patch widens the storage at runtime: allocate a fresh
+# PolyArray, copy each existing IntArray element as sp_box_int,
+# set the new slot, and reassign the slot expression to hold the
+# new PolyArray.
+
+class C
+  def init_arr_widen
+    @arr = [10, 20, 30]   # int_array storage
+    @arr[1] = "string!"   # heterogeneous → triggers runtime widen
+  end
+  def init_str
+    @arr = "scalar"       # forces slot type to widen to poly
+  end
+  def at(i); @arr[i]; end
+end
+
+c = C.new
+c.init_arr_widen
+puts c.at(0)               # 10 (preserved as int)
+puts c.at(1)               # "string!" (recovered via widen)
+puts c.at(2)               # 30

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

@@ -0,0 +1,3 @@
+10
+string!
+30

data/vendor/spinel/test/sample_user_method.rb

@@ -0,0 +1,20 @@
+# `infer_method_name_type` had a name-based shortcut for `sample`
+# that returned the Array#sample default of int regardless of recv.
+# A user-defined `sample` on an obj receiver inferred as int even
+# though the method returns a non-int — and downstream consumers
+# (puts, comparisons, etc.) used the wrong shape.
+
+class Box
+  def initialize(label)
+    @label = label
+  end
+
+  attr_reader :label
+
+  def sample
+    @label
+  end
+end
+
+b = Box.new("ok")
+puts b.sample    # ok

data/vendor/spinel/test/scan_ivars_inherited_slot.rb

@@ -0,0 +1,32 @@
+# When a child class first writes to an ivar that already lives on
+# a parent, scan_ivars used to register the ivar on the child too.
+# update_ivar_type then recursed up to the parent and widened
+# (e.g. `int` → `poly` for heterogeneous writes), but the child's
+# own-table entry kept the new write's narrower type. Two tables
+# disagreed about the slot — and downstream type lookups picked
+# the wrong one depending on path, so codegen for the same field
+# disagreed across class methods.
+#
+# Now scan_ivars detects that the slot is already in an ancestor's
+# table and routes the write through update_ivar_type without
+# adding a duplicate entry to the child. The parent's table stays
+# the single source of truth.
+
+class Parent
+  def initialize
+    @v = 0
+    @v = "s"     # parent widens @v to poly
+  end
+end
+
+class Child < Parent
+  def initialize
+    super
+    @v = 42      # child writes through inherited slot
+  end
+  def read
+    @v
+  end
+end
+
+puts Child.new.read     # 42

data/vendor/spinel/test/scan_new_calls_class_scope.rb

@@ -0,0 +1,35 @@
+# `scan_new_calls` walks the AST looking for `Foo.new(args)` and
+# propagates each arg's inferred type into Foo's initialize param-
+# type table. The arg inference uses `infer_type`, which for an
+# `InstanceVariableReadNode` consults `@current_class_idx` —
+# previously the scan never set it.
+#
+# Result: `Bar.new(@x, ...)` inside `Foo#initialize` resolved
+# `@x` against an empty scope (returned the int default), so
+# Bar.initialize's first param wedged at mrb_int. The fix pins
+# `@current_class_idx` while recursing into ClassNode bodies.
+
+class A
+  attr_reader :n
+  def initialize(n)
+    @n = n
+  end
+end
+
+class B
+  attr_reader :a
+  def initialize(a_arg)
+    @a = a_arg
+  end
+end
+
+class C
+  attr_reader :b
+  def initialize
+    @inner = A.new(7)
+    @b = B.new(@inner)
+  end
+end
+
+c = C.new
+puts c.b.a.n   # 7

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

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

data/vendor/spinel/test/send.rb

@@ -0,0 +1,15 @@
+# Test send(:literal_symbol)
+# Note: send rewrite requires Ruby parser (spinel_parse.rb)
+x = [1,2,3]
+puts x.length
+
+class Adder
+  def initialize(n)
+    @n = n
+  end
+  def add(x)
+    @n + x
+  end
+end
+a = Adder.new(10)
+puts a.add(5)

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

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

data/vendor/spinel/test/shareable_constant.rb

@@ -0,0 +1,10 @@
+# shareable_constant_value: literal
+# ShareableConstantNode — the `# shareable_constant_value:` magic comment.
+#
+# CRuby uses this to mark constants for Ractor-shareable initialization.
+# Spinel has no Ractor runtime, so the shareability state is a no-op
+# and the wrapped constant write executes normally.
+
+FOO = [1, 2, 3]
+puts FOO.length
+puts FOO.first

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

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

data/vendor/spinel/test/sized_poly_array_nil_n.rb

@@ -0,0 +1,37 @@
+# `@arr = [nil] * N` against an ivar slot inferred as `poly`
+# (sp_RbVal — wider than poly_array, set by `finalize_ivar_heterogeneity`
+# when distinct non-array writes are observed) used to compile to
+# `sp_box_int_array(sp_IntArray_new())`. The runtime storage was
+# IntArray, so subsequent heterogeneous writes via the poly-recv
+# `[]=` runtime widening path (or directly via `[]=` with cls_id
+# dispatch) lost the typed-pointer cls_id on the IntArray-typed
+# storage path.
+#
+# Repro: force the slot type to plain `poly` via mixed scalar
+# observations. Then `[nil] * N` against the poly slot must
+# produce a PolyArray, not IntArray, for cls_id-preserving
+# heterogeneous reads/writes to work.
+
+class C
+  def init_arr_widen
+    @arr = [nil] * 8
+    @arr[0] = "string-payload"
+    @arr[1] = 42
+    @arr[2] = :sym
+  end
+  def init_str
+    @arr = "scalar"
+  end
+  def init_int
+    @arr = 7
+  end
+  def at(i)
+    @arr[i]
+  end
+end
+
+c = C.new
+c.init_arr_widen
+puts c.at(0).to_s   # "string-payload"
+puts c.at(1).to_i   # 42
+puts c.at(2).to_s   # "sym"

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

@@ -0,0 +1,3 @@
+string-payload
+42
+sym

data/vendor/spinel/test/source_file.rb

@@ -0,0 +1,37 @@
+# SourceFileNode -- the `__FILE__` keyword.
+#
+# Spinel inlines `require`/`require_relative` at parse time, so call
+# sites in different source files are not distinguished. `__FILE__`
+# always returns the toplevel script path passed to spinel_parse,
+# matching CRuby's behavior for top-level uses.
+#
+# This test exercises __FILE__ end-to-end: it must (a) emit the path,
+# (b) flow as `string` through type inference (so dispatch picks the
+# string-method arms), (c) interoperate with literals (concat / compare
+# / interpolate), and (d) round-trip through a typed-String parameter
+# at a method call site.
+
+# Basic emission.
+puts __FILE__
+
+# String#length returns an Integer -> dispatch hit the string arm.
+puts __FILE__.length > 0
+
+# Concat with literal -> __FILE__ is a `string`, not poly/object.
+puts "[" + __FILE__ + "]"
+
+# Interpolation works (path appears verbatim).
+puts "got: #{__FILE__}"
+
+# Two reads compare equal -- same toplevel path resolves identically.
+puts __FILE__ == __FILE__
+
+# String predicates dispatch via the string arm.
+puts __FILE__.end_with?(".rb")
+puts __FILE__.include?("source_file")
+
+# Round-trip through a typed-String parameter at a method call site.
+def show(s)
+  puts "param: " + s
+end
+show(__FILE__)

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

@@ -0,0 +1,8 @@
+test/source_file.rb
+true
+[test/source_file.rb]
+got: test/source_file.rb
+true
+true
+true
+param: test/source_file.rb

data/vendor/spinel/test/splat_call.rb

@@ -0,0 +1,72 @@
+# Splat operator at the call site.
+# Covers pure splat, splat into a method with required + rest params,
+# and mixed prefix/splat/suffix into a rest-collecting method.
+
+def collect(*nums)
+  total = 0
+  nums.each { |n| total += n }
+  puts nums.length
+  puts total
+end
+
+# Pure splat into rest-only method
+args = [1, 2, 3]
+collect(*args)        # length 3, total 6
+
+# Empty splat
+empty = []
+collect(*empty)       # length 0, total 0
+
+# Splat with a method that has fixed prefix + rest
+def mix(a, b, *rest)
+  puts a
+  puts b
+  puts rest.length
+  rest.each { |x| puts x }
+end
+
+# Pure splat fills both fixed slots and the rest
+quad = [10, 20, 30, 40]
+mix(*quad)            # a=10, b=20, rest=[30,40]
+
+# Prefix + splat fills the rest
+tail = [3, 4, 5]
+mix(1, 2, *tail)      # a=1, b=2, rest=[3,4,5]
+
+# Prefix + splat + suffix all bundle into rest
+mid = [3, 4]
+mix(1, 2, *mid, 5, 6) # a=1, b=2, rest=[3,4,5,6]
+
+# Bare call leaves rest empty (regression check for the empty-rest fix)
+mix(100, 200)         # a=100, b=200, rest=[]
+
+# Prefix overflows into rest when method has *only* a rest param
+collect(7, *args)     # length 4, total 13
+collect(7, 8, *args, 9) # length 6, total 36
+
+# Mixed-type splat sources: poly_array source, mixed prefix/suffix.
+# Spinel's *rest is always int_array so element values are mrb_int bits
+# for non-int elements — but the length is correct and the bundle
+# round-trips intact for downstream splatting.
+def count(*xs)
+  puts xs.length
+end
+count(1, "x", 2.0)            # 3
+mix = [1, "two", :three, 4.0]
+count(*mix)                   # 4
+count(0, *mix, "tail", 99.5)  # 7
+
+# Two splats in one call (multi-splat fallback path).
+left = [1, 2]
+right = [3, 4, 5]
+count(*left, *right)          # 5
+
+# Splat into a method with str fixed prefix + rest — exercises the
+# splat-aware param-type inference (without it, "first" would default to
+# mrb_int and we'd print garbage instead of "alpha").
+def head_str(first, *tail)
+  puts first
+  puts tail.length
+end
+strs = ["alpha", "beta", "gamma"]
+head_str(*strs)               # alpha / 2

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

@@ -0,0 +1,35 @@
+3
+6
+0
+0
+10
+20
+2
+30
+40
+1
+2
+3
+3
+4
+5
+1
+2
+4
+3
+4
+5
+6
+100
+200
+0
+4
+13
+6
+30
+3
+4
+7
+5
+alpha
+2

data/vendor/spinel/test/splat_destructure.rb

@@ -0,0 +1,56 @@
+# Splat (rest) target in multi-assignment.
+# Covers leading / trailing / middle splat against array literals,
+# different element types, and a rest-returning function source.
+
+# Trailing splat from array literal (int_array)
+a, *b = [1, 2, 3, 4]
+puts a            # 1
+puts b.length     # 3
+b.each { |v| puts v }   # 2 / 3 / 4
+
+# Leading splat (everything but the last lands in the splat target)
+*xs, last = [10, 20, 30, 40]
+puts last         # 40
+puts xs.length    # 3
+xs.each { |v| puts v }  # 10 / 20 / 30
+
+# Middle splat
+first, *mid, fin = [100, 200, 300, 400, 500]
+puts first        # 100
+puts fin          # 500
+puts mid.length   # 3
+mid.each { |v| puts v } # 200 / 300 / 400
+
+# Splat with str_array RHS
+s, *rest = ["alpha", "beta", "gamma"]
+puts s            # alpha
+puts rest.length  # 2
+rest.each { |w| puts w }  # beta / gamma
+
+# RHS shorter than fixed targets — splat target empty
+p, *q = [42]
+puts p            # 42
+puts q.length     # 0
+
+# Function returning typed array
+def numbers
+  [7, 8, 9, 10]
+end
+
+n1, *n_rest = numbers
+puts n1           # 7
+puts n_rest.length  # 3
+n_rest.each { |v| puts v }  # 8 / 9 / 10
+
+# Mixed-type destructure: each fixed target gets its own native type
+ma, mb, mc = [1, "b", 2.0]
+puts ma           # 1
+puts mb           # b
+puts mc           # 2.0
+
+# Mixed-type with splat: splat target becomes a poly_array
+mx, *mmid, mlast = [10, "two", :three, 4.0, "five"]
+puts mx           # 10
+puts mlast        # five
+puts mmid.length  # 3
+mmid.each { |mv| p mv }  # "two" / :three / 4.0

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

@@ -0,0 +1,36 @@
+1
+3
+2
+3
+4
+40
+3
+10
+20
+30
+100
+500
+3
+200
+300
+400
+alpha
+2
+beta
+gamma
+42
+0
+7
+3
+8
+9
+10
+1
+b
+2.0
+10
+five
+3
+"two"
+:three
+4.0

data/vendor/spinel/test/splat_destructure_poly.rb

@@ -0,0 +1,26 @@
+# Splat destructure with a poly_array RHS — Gemini concern on PR #116:
+# the runtime-slice path of compile_multi_write_splat had no case for
+# poly_array, so it fell through to sp_IntArray_get / sp_IntArray_slice
+# and the C compile rejected the type mismatch. With the fix the path
+# uses sp_PolyArray_get / sp_PolyArray_slice for poly_array RHS.
+
+def heterogeneous
+  ["alpha", 1, "beta", 2.5, "gamma"]
+end
+
+# Trailing splat — splat target is a sp_PolyArray * holding the tail.
+a, b, *rest = heterogeneous
+puts a              # alpha
+puts rest.length    # 3
+
+# Leading splat — splat target holds the head, then two scalar tails.
+*head, y, z = heterogeneous
+puts head.length    # 3
+puts z              # gamma
+puts y              # 2.5  (Ruby) — verifies float scalar from poly RHS
+
+# Middle splat — most exercise of the slice + bracketing helpers.
+p, *mid, q = heterogeneous
+puts mid.length     # 3
+puts p              # alpha
+puts q              # gamma

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

@@ -0,0 +1,8 @@
+alpha
+3
+3
+gamma
+2.5
+3
+alpha
+gamma

data/vendor/spinel/test/stdlib.rb

@@ -0,0 +1,28 @@
+# Test stdlib additions
+
+# Array#join
+arr = (1..5).to_a
+puts arr.join(", ")  # 1, 2, 3, 4, 5
+
+# Array#uniq
+nums = (1..5).to_a
+nums.push(3)
+nums.push(1)
+uniq = nums.uniq
+puts uniq.length  # 5
+
+# srand/rand
+srand(0)
+r = rand(100)
+puts r >= 0  # true (some number)
+
+# ARGV.length
+puts ARGV.length  # 0
+
+# $stderr.puts
+$stderr.puts("stderr msg")
+
+# exit — skip (would terminate)
+# sleep — skip (would delay)
+
+puts "done"

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

@@ -0,0 +1,5 @@
+1, 2, 3, 4, 5
+5
+true
+0
+done