rubyduino 0.1.1

data/vendor/spinel/test/each_poly_recv_block_auto_splat.rb

@@ -0,0 +1,43 @@
+# `arr.each {|a, b| ... }` over a poly receiver (an sp_RbVal that
+# carries an array of arrays at runtime) should auto-splat each
+# element across the block params, matching CRuby's
+# `arr.each {|*args| a, b, *_ = args }` shape.  Pre-fix the poly
+# branch only assigned `bp1` and dropped `bp2`, so e.g.
+# `[[1, 2], [3, 4]].each {|a, b| sum += a + b }` skipped `b`
+# entirely.  Cover both inner kinds the destructuring uses:
+# poly_array (heterogeneous element types) and int_array
+# (homogeneous int element types — what `[i, fixed]` lowers to in
+# optcarrot's `setup_lut`).
+
+class C
+  def initialize
+    @h = {}
+  end
+
+  def push_int(bank, pair)
+    # `pair` lowers to int_array because both elements are ints.
+    (@h[bank] ||= []) << pair
+  end
+
+  def push_poly(bank, pair)
+    # `pair` lowers to poly_array because the elements are mixed.
+    (@h[bank] ||= []) << pair
+  end
+
+  def each_pair(bank)
+    arr = @h[bank]
+    sum = 0
+    arr.each {|a, b| sum += a.to_i + b.to_i }
+    sum
+  end
+end
+
+c = C.new
+c.push_int(0, [10, 20])
+c.push_int(0, [3,  4])
+puts c.each_pair(0)         # 10 + 20 + 3 + 4 = 37
+
+d = C.new
+d.push_poly(1, [100, "x"])  # b is a string, exercising the poly_array branch
+d.push_poly(1, [5,   "y"])
+puts d.each_pair(1)         # 100 + 0 + 5 + 0 = 105 (string `to_i` of "x" / "y" = 0)

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

@@ -0,0 +1,2 @@
+37
+105

data/vendor/spinel/test/each_with_object_seed_shadow.rb

@@ -0,0 +1,14 @@
+# Array#each_with_object: the seed (second block param) must shadow an
+# outer same-named local of a different type. Without push_scope/
+# declare_var on the seed, infer_type inside the block resolves against
+# the outer binding and dispatches the wrong runtime call.
+
+def f
+  obj = 42
+  out = [1, 2, 3].each_with_object([]) { |x, obj| obj.push(x * 2) }
+  puts out[0]   # 2
+  puts out[1]   # 4
+  puts out[2]   # 6
+  puts obj      # 42
+end
+f

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

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

data/vendor/spinel/test/elsif_isa_chain.rb

@@ -0,0 +1,56 @@
+# Issue #310: an `if/elsif/else` chain with `is_a?(Class)` checks
+# in the elsif branch used to emit `} else <prologue> if (...)`
+# without wrapping braces. The compile_cond_expr for a poly is_a?
+# emits prologue C statements (`sp_RbVal _t = recv; if (_t.tag ==
+# SP_TAG_OBJ) {...}`) before returning the cond flag. Those
+# prologue statements deposited between the bare `else` and the
+# inner `if` — invalid C: the bare-else's body is the next single
+# statement, and the temp decl's scope ended right there.
+#
+# Fix: wrap elsif branches in `{ }`. The cosmetic `else if` is
+# replaced by `else { if ... }` — semantically identical, scope-
+# correct.
+#
+# This test verifies the C *compiles*. Note that is_a?(UserClass)
+# on a poly receiver still has gaps elsewhere (the SP_TAG_OBJ
+# dispatch loop in compile_poly_method_call only walks user-class
+# method tables, none of which define `is_a?`, so the runtime
+# check is conservative — orthogonal to #310's brace bug). All
+# arms below return the same string so the test passes regardless
+# of which branch the runtime picks.
+
+class A
+end
+
+class B
+end
+
+def normalize(value)
+  if value.is_a?(A)
+    "ok"
+  elsif value.is_a?(B)
+    "ok"
+  else
+    "ok"
+  end
+end
+
+puts normalize(A.new)              # ok
+puts normalize(B.new)              # ok
+puts normalize(42)                 # ok
+
+# Same shape but as the method's tail-position return — exercises
+# compile_if_return's elsif path (companion fix in the same patch).
+def classify(value)
+  if value.is_a?(A)
+    1
+  elsif value.is_a?(B)
+    1
+  else
+    1
+  end
+end
+
+puts classify(A.new)               # 1
+puts classify(B.new)               # 1
+puts classify(99)                  # 1

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

@@ -0,0 +1,6 @@
+ok
+ok
+ok
+1
+1
+1

data/vendor/spinel/test/embedded_var.rb

@@ -0,0 +1,17 @@
+# EmbeddedVariableNode -- `"#$gv"`, `"#@iv"`, `"#@@cv"`.
+#
+# Shorthand interpolation form that skips the braces around a
+# bare variable reference. Lowered at parser side to an
+# EmbeddedStatementsNode wrapping the matching variable read,
+# so the codegen reuses the existing interpolation path.
+
+$global = "global!"
+puts "got: #$global"          # got: global!
+
+class C
+  def initialize
+    @ivar = "ivar!"
+  end
+  def show = puts("got: #@ivar")
+end
+C.new.show                    # got: ivar!

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

@@ -0,0 +1,2 @@
+got: global!
+got: ivar!

data/vendor/spinel/test/empty_array_param.rb

@@ -0,0 +1,94 @@
+# Empty `[]` literal as parameter — deferred element-type resolution
+# must converge across caller / param / body. Issues #58 (top-level
+# def + instance method) and #84 (inherited dispatch). Was four
+# tests; class names don't collide so the merge is straight
+# concatenation with shared helpers.
+
+# === Top-level def, [] passed directly at call site ===
+def push_floats(buf)
+  buf.push(1.5)
+  buf.push(2.5)
+  buf
+end
+result_pf = push_floats([])
+puts result_pf[0]   # 1.5
+puts result_pf[1]   # 2.5
+
+# === Top-level def, [] stored in local first ===
+def collect_names(buf)
+  buf.push("alpha")
+  buf.push("beta")
+end
+names = []
+collect_names(names)
+puts names[0]       # alpha
+puts names[1]       # beta
+puts names.length   # 2
+
+# === Instance method receiving [] — same deferred path ===
+class Recorder
+  def record(buf, name)
+    buf.push(name)
+    buf.push(name + "!")
+  end
+end
+r = Recorder.new
+log = []
+r.record(log, "go")
+r.record(log, "stop")
+puts log.length     # 4
+puts log[0]         # go
+puts log[1]         # go!
+puts log[2]         # stop
+puts log[3]         # stop!
+
+# === Inherited dispatch (#84): caller-side inference must walk
+# the inheritance chain to update the *parent's* @cls_meth_ptypes
+# when cls_find_method_direct misses on the child. ===
+class Base
+  def add_to(buf)
+    buf.push("hi")
+  end
+end
+class Child < Base
+end
+names1 = []
+Child.new.add_to(names1)
+names1.push("more")
+puts names1[0]      # hi
+puts names1[1]      # more
+
+# Two-deep inheritance.
+class Grandchild < Child
+end
+names2 = []
+Grandchild.new.add_to(names2)
+names2.push("again")
+puts names2[0]      # hi
+puts names2[1]      # again
+
+# Class that overrides the inherited slot AND inherits a different
+# defaulted method. The promotion must hit Base2's slot for the
+# inherited `also_add` call, not Mixed's.
+class Base2
+  def also_add(buf)
+    buf.push("base2")
+  end
+end
+class Mixed < Base2
+  def add_to(buf)
+    buf.push(42)
+  end
+end
+
+ints = []
+Mixed.new.add_to(ints)
+ints.push(7)
+puts ints[0]        # 42
+puts ints[1]        # 7
+
+strs = []
+Mixed.new.also_add(strs)
+strs.push("more")
+puts strs[0]        # base2
+puts strs[1]        # more

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

@@ -0,0 +1,18 @@
+1.5
+2.5
+alpha
+beta
+2
+4
+go
+go!
+stop
+stop!
+hi
+more
+hi
+again
+42
+7
+base2
+more

data/vendor/spinel/test/empty_hash_ivar_string_value.rb

@@ -0,0 +1,51 @@
+# Issue #64: an ivar initialized as `{}` defaulted to `str_int_hash`,
+# and a later `@h[k] = "string"` write fed `const char *` into
+# `sp_StrIntHash_set` (which expects `mrb_int`). Three pieces of the
+# fix:
+#   - scan_writer_calls now recognises `@h[k] = v` against an ivar
+#     still typed as the empty-hash default and promotes the slot
+#     based on the actual key/value types
+#   - the same scanner skips empty `{}` / `[]` writes when re-scanning
+#     so the iterative loop doesn't widen the promoted type back to
+#     poly via "old=str_str_hash, new=str_int_hash"
+#   - both compile_stmt(InstanceVariableWriteNode) and the inline
+#     constructor walker route empty `{}` against a promoted ivar to
+#     the matching `sp_*Hash_new()` ctor
+
+class Sources
+  def initialize
+    @file_sources = {}
+    @current_file = "a.rb"
+  end
+
+  def add(source)
+    @file_sources[@current_file] = source if @current_file
+  end
+
+  def lookup(name)
+    @file_sources[name]
+  end
+end
+
+s = Sources.new
+s.add("body")
+puts s.lookup("a.rb")        # body
+puts s.lookup("missing")     # (empty line — string hash default for missing key)
+
+# The other key/value-type combos covered by the same promotion path.
+class IntKeyed
+  def initialize; @h = {}; end
+  def put(k, v); @h[k] = v; end
+  def get(k); @h[k]; end
+end
+
+ik = IntKeyed.new
+ik.put(7, "seven")
+ik.put(42, "forty-two")
+puts ik.get(7)               # seven
+puts ik.get(42)              # forty-two
+
+# Symbol-keyed promotion is also wired through but exercises a
+# pre-existing -Walloc-size-larger-than warning in the runtime
+# `sp_SymIntHash_grow` (unrelated to this issue), so it isn't part
+# of the make-test surface here.

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

@@ -0,0 +1,4 @@
+body
+
+seven
+forty-two

data/vendor/spinel/test/endless_method.rb

@@ -0,0 +1,61 @@
+# Endless methods (Ruby 3.0+): `def name(args) = expr` is shorthand for
+# a single-expression method body. Prism flattens this to the same
+# DefNode shape as a regular def with a one-statement StatementsNode
+# body, so the existing codegen path supports it transparently. This
+# test pins that contract — if a future Prism upgrade emits a distinct
+# node type (e.g. SingleLineMethodDefinitionNode), the test breaks
+# loudly instead of silently regressing.
+
+# 1. Plain integer return.
+def double(x) = x * 2
+puts double(21)
+# 42
+
+# 2. String return with interpolation.
+def greet(name) = "hello, #{name}"
+puts greet("world")
+# hello, world
+
+# 3. Self-recursive endless method (still expressible, since the body
+#    is one expression).
+def fact(n) = n <= 1 ? 1 : n * fact(n - 1)
+puts fact(5)
+# 120
+
+# 4. No-arg endless method.
+def answer = 42
+puts answer
+# 42
+
+# 5. Endless method using a block-passing call.
+def doubled_max(arr) = arr.map { |x| x * 2 }.max
+puts doubled_max([1, 4, 2])
+# 8
+
+# 6. Class endless method (instance + class methods).
+class Box
+  def self.unit = 1
+  def initialize(v); @v = v; end
+  def double = @v * 2
+  def name = "Box"
+end
+
+puts Box.unit
+# 1
+puts Box.new(7).double
+# 14
+puts Box.new(0).name
+# Box
+
+# 7. Boolean-returning endless method.
+def positive?(n) = n > 0
+puts positive?(10)
+# true
+puts positive?(-1)
+# false
+
+# 8. Method composition (one endless method calling another).
+def square(x) = x * x
+def square_of_sum(a, b) = square(a + b)
+puts square_of_sum(2, 3)
+# 25

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

@@ -0,0 +1,11 @@
+42
+hello, world
+120
+42
+8
+1
+14
+Box
+true
+false
+25

data/vendor/spinel/test/endless_method_rescue.rb

@@ -0,0 +1,33 @@
+# Endless method with rescue modifier:
+#   def name(args) = expr rescue fallback
+# Combines `def foo(x) = expr` (already supported) with the postfix
+# `rescue` modifier. This test
+# pins int-typed-return shapes.
+
+# Plain endless + rescue with Integer() conversion
+def parse_int(s) = Integer(s) rescue 0
+puts parse_int("42")
+puts parse_int("abc")
+puts parse_int("0")
+puts parse_int("-7")
+
+# Explicit-raise rescue trigger. Pre-fix the test was `half(n) = n / 2`,
+# which never raises (0/2 == 0) and so never exercised the rescue path.
+# Uses an explicit raise() so the rescue trigger is independent of the
+# integer-division-by-zero machinery (covered separately in
+# test/integer_div_by_zero.rb). The raise lives inside a helper so the
+# endless body is a single call expression — keeps codegen happy and
+# exercises the cross-frame rescue path.
+def assert_pos(n)
+  n < 0 ? raise("negative") : n
+end
+def safe(n) = assert_pos(n) rescue -1
+puts safe(10)
+puts safe(-5)
+puts safe(0)
+
+# Nested call with rescue
+def chain(s) = s.to_i + 1 rescue 0
+puts chain("99")
+puts chain("zero")
+puts chain("-1")

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

@@ -0,0 +1,10 @@
+42
+0
+0
+-7
+10
+-1
+0
+100
+1
+0

data/vendor/spinel/test/ensure_raise_overrides_body_raise.rb

@@ -0,0 +1,19 @@
+# Ruby semantics: when both the body and the ensure clause raise,
+# the ensure-raise wins — the original body exception is replaced
+# by the ensure exception as it propagates.
+
+class C
+  def f
+    begin
+      raise "original"
+    ensure
+      raise "from-ensure"
+    end
+  end
+end
+
+begin
+  C.new.f
+rescue => e
+  puts e
+end

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

@@ -0,0 +1 @@
+from-ensure

data/vendor/spinel/test/ensure_runs_on_raise.rb

@@ -0,0 +1,32 @@
+# When the body of a `begin..ensure..end` raises, the ensure
+# clause must still run before the exception keeps propagating.
+# Previously the generated C had no setjmp around the body, so
+# raise unwound past the ensure entirely.
+
+class C
+  def initialize
+    @cleanup = "no"
+    @before_raise = 0
+  end
+
+  def f
+    begin
+      @before_raise = 1
+      raise "boom"
+    ensure
+      @cleanup = "yes"
+    end
+  end
+
+  def report
+    begin
+      f
+    rescue => e
+      puts e
+    end
+    puts @before_raise
+    puts @cleanup
+  end
+end
+
+C.new.report

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

@@ -0,0 +1,3 @@
+boom
+1
+yes

data/vendor/spinel/test/ensure_runs_on_raise_nested.rb

@@ -0,0 +1,38 @@
+# Nested `begin..ensure..end` with raise — both ensures must run
+# (inner first, then outer) before the exception reaches the
+# enclosing rescue.
+
+class T
+  def initialize
+    @inner = "no"
+    @outer = "no"
+    @log = ""
+  end
+
+  def f
+    begin
+      begin
+        raise "inner-boom"
+      ensure
+        @inner = "yes"
+        @log = @log + "i"
+      end
+    ensure
+      @outer = "yes"
+      @log = @log + "o"
+    end
+  end
+
+  def report
+    begin
+      f
+    rescue => e
+      puts e
+    end
+    puts @inner
+    puts @outer
+    puts @log
+  end
+end
+
+T.new.report

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

@@ -0,0 +1,4 @@
+inner-boom
+yes
+yes
+io

data/vendor/spinel/test/ensure_runs_on_return.rb

@@ -0,0 +1,61 @@
+# `begin..ensure..end` must run the ensure clause when the body
+# exits via `return` (bare or with a value). Previously the
+# generated C placed the ensure body *after* the unconditional
+# `return` it followed, so the writeback was dead code.
+
+class C
+  def initialize
+    @x = 0
+    @v = 0
+    @a = 0
+  end
+
+  def bare_return
+    begin
+      x = 100
+      return
+    ensure
+      @x = x
+    end
+  end
+
+  def value_return
+    begin
+      v = 7
+      return v * 6
+    ensure
+      @v = v
+    end
+  end
+
+  def multi_return(c)
+    begin
+      a = 1
+      if c == 1
+        return 11
+      end
+      a = 2
+      if c == 2
+        return 22
+      end
+      a = 3
+    ensure
+      @a = a
+    end
+  end
+
+  def report
+    bare_return
+    puts value_return
+    multi_return(1)
+    puts "a1=" + @a.to_s
+    multi_return(2)
+    puts "a2=" + @a.to_s
+    multi_return(3)
+    puts "a3=" + @a.to_s
+    puts @x
+    puts @v
+  end
+end
+
+C.new.report

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

@@ -0,0 +1,6 @@
+42
+a1=1
+a2=2
+a3=3
+100
+7

data/vendor/spinel/test/ensure_runs_on_return_from_rescue.rb

@@ -0,0 +1,26 @@
+# `begin..rescue..ensure..end` — when the rescue body exits via
+# `return`, the ensure clause must still run before the function
+# returns.
+
+class C
+  def initialize
+    @cleanup = "no"
+  end
+
+  def f
+    begin
+      raise "boom"
+    rescue
+      return 99
+    ensure
+      @cleanup = "yes"
+    end
+  end
+
+  def report
+    puts f
+    puts @cleanup
+  end
+end
+
+C.new.report

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

@@ -0,0 +1,2 @@
+99
+yes

data/vendor/spinel/test/ensure_runs_on_return_nested.rb

@@ -0,0 +1,37 @@
+# Nested `begin..ensure..end` — a `return` inside the inner begin
+# must replay the inner ensure first, then the outer ensure, then
+# return. Both writebacks must take effect, in order.
+
+class T
+  def initialize
+    @inner = 0
+    @outer = 0
+    @log = ""
+  end
+
+  def run
+    begin
+      a = 1
+      begin
+        b = 10
+        a = 2
+        return
+      ensure
+        @inner = b
+        @log = @log + "i"
+      end
+    ensure
+      @outer = a
+      @log = @log + "o"
+    end
+  end
+
+  def report
+    run
+    puts "inner=" + @inner.to_s
+    puts "outer=" + @outer.to_s
+    puts "log=" + @log
+  end
+end
+
+T.new.report