rubyduino 0.1.1

data/vendor/spinel/test/block_forward_block_arg.rb

@@ -0,0 +1,60 @@
+# `&proc_var` argument forwarding (`def m(&b); g(&b); end`).
+#
+# Pre-fix Spinel never parsed `&expr` in call argument position
+# (`g(&block)`) — Prism's `PM_BLOCK_ARGUMENT_NODE` had no case in
+# `flatten()`, so the codegen saw the call as taking no block at all
+# and the captured `&block` was silently dropped at every forwarding
+# call site.
+#
+# This PR adds:
+#   - parser case for PM_BLOCK_ARGUMENT_NODE → "BlockArgumentNode"
+#   - `find_block_arg(nid)` helper that returns the inner expression
+#   - `strip_block_arg` filter so &block-args don't leak into the
+#     positional-args comma list at compile_call_args / -with_defaults
+#     / compile_typed_call_args
+#   - extends Sites A, B, and the receiverless has_block_param path
+#     to fall through to find_block_arg when has_literal_block returns 0,
+#     emitting the proc expression directly (no compile_proc_literal call,
+#     since the proc is already a captured `sp_Proc *`).
+
+# 1. Site A (self-call) &proc_var forwarding.
+class Forwarder
+  def outer(&block)
+    inner(&block)
+  end
+
+  def inner(&block)
+    block.call
+  end
+end
+
+Forwarder.new.outer { puts "1-self-amp" }
+
+# 2. Site B (typed-receiver) &proc_var forwarding — outer captures
+#    &block, then forwards it to a different receiver's method.
+class Sink
+  def receive(&block)
+    block.call
+  end
+end
+
+class Source
+  def relay(sink, &block)
+    sink.receive(&block)
+  end
+end
+
+Source.new.relay(Sink.new) { puts "2-recv-amp" }
+
+# 3. Top-level (receiverless) `&proc_var` forwarding.
+def outer_top(&block)
+  inner_top(&block)
+end
+
+def inner_top(&block)
+  block.call
+end
+
+outer_top { puts "3-top-amp" }
+
+puts "done"

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

@@ -0,0 +1,4 @@
+1-self-amp
+2-recv-amp
+3-top-amp
+done

data/vendor/spinel/test/block_forward_recv_typed.rb

@@ -0,0 +1,82 @@
+# Typed-receiver `recv.m { ... }` &block forwarding (Site B).
+#
+# Pre-fix `compile_object_method_expr` dropped the literal block: the
+# call site emitted `sp_Cls_m(rc, 0)` and the binary segfaulted inside
+# `sp_proc_call(NULL, ...)`. Fix: precompute `has_proc` from the
+# callee's param types, pass it to `compile_typed_call_args` as the
+# new `omit_trailing` 4th arg so the &block slot isn't padded with
+# "0", then build a `bp`/`tail` that appends the proc literal after
+# the regular args.
+
+# 1. Basic: `recv.m { ... }` with arity-0 block.call.
+class App
+  def run(&block)
+    block.call
+  end
+end
+
+App.new.run { puts "1-basic" }
+
+# 2. block.call with one int arg, return value used.
+class Doubler
+  def apply(x, &block)
+    block.call(x)
+  end
+end
+
+puts Doubler.new.apply(21) { |n| n * 2 }
+
+# 3. Mixed: regular arg + &block, multiple stmts in method body.
+class Logger
+  def log(label, &block)
+    puts label
+    block.call
+  end
+end
+
+Logger.new.log("3-mixed") { puts "  body" }
+
+# 4. Block invoked multiple times from inside the method.
+class Repeater
+  def thrice(&block)
+    block.call
+    block.call
+    block.call
+  end
+end
+
+Repeater.new.thrice { puts "4-thrice" }
+
+# 5. Block uses interpolation of its own argument. (Closure capture
+#    over outer locals is a separate subsystem — out of scope here.)
+class Wrapper
+  def go(n, &block)
+    block.call(n)
+  end
+end
+
+Wrapper.new.go(7) { |i| puts "5-arg=#{i}" }
+
+# 6. Block returns a value used by the method.
+class Picker
+  def pick(&block)
+    block.call(10) + block.call(20)
+  end
+end
+
+puts Picker.new.pick { |n| n * 5 }
+
+# 7. Method declares &block, call site provides none. The &block
+#    slot must be filled with NULL — pre-fix `omit_trailing` dropped
+#    the slot from the C call entirely, leaving an arity mismatch
+#    between sp_Optional_maybe(sp_Optional *, sp_Proc *) and
+#    sp_Optional_maybe(_t1).
+class Optional
+  def maybe(&block)
+    puts "7-no-block"
+  end
+end
+
+Optional.new.maybe
+
+puts "done"

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

@@ -0,0 +1,11 @@
+1-basic
+42
+3-mixed
+  body
+4-thrice
+4-thrice
+4-thrice
+5-arg=7
+150
+7-no-block
+done

data/vendor/spinel/test/block_forward_self_call.rb

@@ -0,0 +1,61 @@
+# Self-call `m { ... }` &block forwarding (Site A).
+#
+# When a method on class C calls another method on the same class
+# without an explicit receiver (`m { ... }` instead of `self.m { ... }`),
+# dispatch goes through `compile_no_recv_call_expr`'s
+# `@current_class_idx >= 0` branch — call this Site A. Pre-fix this
+# branch always emitted `sp_C_m(self, ca)` with no block tail, so a
+# literal block at the call site was silently dropped and the binary
+# segfaulted in `sp_proc_call(NULL, ...)`.
+#
+# Site A reuses the `has_literal_block` helper and the
+# `omit_trailing` 4th arg of `compile_typed_call_args` introduced
+# in the previous PR (Site B / typed-receiver forwarding); the only
+# new code here is the same `bp`/`tail` template adapted to the
+# self-call form.
+
+# 1. Bare self-call dispatch — one method invokes another method
+#    of the same class with a literal block.
+class Caller
+  def kick
+    inner { puts "1-self-call" }
+  end
+
+  def inner(&block)
+    block.call
+  end
+end
+
+Caller.new.kick
+
+# 2. Self-call passes a value through to the block via block.call(arg).
+class Wrapper
+  def go
+    forward(7) { |i| puts "2-arg=#{i}" }
+  end
+
+  def forward(n, &block)
+    block.call(n)
+  end
+end
+
+Wrapper.new.go
+
+# 3. Self-call inside a loop — each iteration forwards a fresh block.
+class Bank
+  def run
+    deposit_each(3) { |i| puts "3-dollar-#{i}" }
+  end
+
+  def deposit_each(n, &block)
+    i = 0
+    while i < n
+      block.call(i)
+      i = i + 1
+    end
+  end
+end
+
+Bank.new.run
+
+puts "done"

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

@@ -0,0 +1,6 @@
+1-self-call
+2-arg=7
+3-dollar-0
+3-dollar-1
+3-dollar-2
+done

data/vendor/spinel/test/block_given_block_param.rb

@@ -0,0 +1,46 @@
+# `block_given?` for `&block` parameters.
+#
+# Pre-fix `block_given?` only returned the right answer inside methods
+# that used `yield` (`@in_yield_method == 1`). Methods that captured
+# the block solely via `&block` and never invoked yield fell through
+# to the constant `"0"` — losing the answer for the one case where
+# the runtime *does* know whether a block was forwarded.
+#
+# Fix: track the enclosing method's `&block` param name in
+# `@current_method_block_param`, set/restored at all three method-emit
+# sites (emit_instance_method, emit_class_level_method,
+# emit_toplevel_method) via a new find_block_param_name helper. The
+# block_given? handler returns `(lv_<param> != NULL)` after the
+# existing `@in_yield_method` branch.
+#
+# This test exercises the no-block-passed observable through the
+# receiverless default-padding path. (Receivered + literal-block
+# paths route through the yield-inliner's own `block_given?`
+# shortcut, which doesn't transit the new lowering at all.)
+
+# 1. Top-level `&block` method, called without a block — block_given?
+#    must return false. Pre-fix this constant-returned 0 with no
+#    visibility into the actual presence of a block.
+def top(&block)
+  if block_given?
+    puts "1-yes"
+  else
+    puts "1-no"
+  end
+end
+
+top                       #=> 1-no
+
+# 2. Same shape with a regular arg before &block — find_block_param_name
+#    must skip the int param and pick the trailing proc-typed slot.
+def top2(label, &block)
+  if block_given?
+    puts label + "-yes"
+  else
+    puts label + "-no"
+  end
+end
+
+top2("2")                 #=> 2-no
+
+puts "done"

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

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

data/vendor/spinel/test/block_param_shadow.rb

@@ -0,0 +1,246 @@
+# Block parameters shadow outer differently-typed locals correctly.
+# Without push_scope/declare_var around the block body compile, infer_type
+# returned the outer scope's type for the block param, dispatching the
+# wrong runtime call (e.g. sp_str_repeat for an int param).
+
+# --- each on int_array, outer string v (the original report) ---
+def f1
+  v = "hello"
+  [1, 2, 3].each do |v|
+    puts v * 10
+  end
+  puts v
+end
+f1
+# 10
+# 20
+# 30
+# hello
+
+# --- each_with_index, outer string i ---
+def f2
+  i = "outer"
+  ["a", "b"].each_with_index do |s, i|
+    puts s + i.to_s
+  end
+  puts i
+end
+f2
+# a0
+# b1
+# outer
+
+# --- each_with_index on str_array, outer int i ---
+def f3
+  i = 99
+  ["a", "b", "c"].each_with_index do |s, i|
+    puts s + ":" + i.to_s
+  end
+  puts i
+end
+f3
+# a:0
+# b:1
+# c:2
+# 99
+
+# --- map on int_array, outer string i ---
+def f4
+  i = "outer"
+  out = [10, 20, 30].map { |i| i + 1 }
+  puts out[0]               # 11
+  puts out[1]               # 21
+  puts out[2]               # 31
+  puts i                    # outer
+end
+f4
+
+# --- map on str_array, outer int s ---
+def f5
+  s = 42
+  words = ["a", "b", "c"]
+  up = words.map { |s| s.upcase }
+  puts up[0]                # A
+  puts up[1]                # B
+  puts up[2]                # C
+  puts s                    # 42
+end
+f5
+
+# --- select on int_array, outer string n ---
+def f6
+  n = "kept"
+  out = [1, 2, 3, 4].select { |n| n > 2 }
+  puts out.length           # 2
+  puts out[0]               # 3
+  puts out[1]               # 4
+  puts n                    # kept
+end
+f6
+
+# --- reject on int_array, outer string n ---
+def f7
+  n = "drop"
+  out = [1, 2, 3, 4].reject { |n| n > 2 }
+  puts out.length           # 2
+  puts out[0]               # 1
+  puts out[1]               # 2
+  puts n                    # drop
+end
+f7
+
+# --- partition on int_array, outer string n ---
+def f8
+  n = "outer"
+  parts = [1, 2, 3, 4, 5].partition { |n| n > 2 }
+  puts parts[0].length      # 3
+  puts parts[0][0]          # 3
+  puts parts[0][1]          # 4
+  puts parts[0][2]          # 5
+  puts parts[1].length      # 2
+  puts parts[1][0]          # 1
+  puts parts[1][1]          # 2
+  puts n                    # outer
+end
+f8
+
+# --- partition on str_array, outer int x ---
+def f9
+  x = 99
+  parts = ["a", "bb", "ccc"].partition { |x| x.length > 1 }
+  puts parts[0].length      # 2
+  puts parts[0][0]          # bb
+  puts parts[0][1]          # ccc
+  puts parts[1].length      # 1
+  puts parts[1][0]          # a
+  puts x                    # 99
+end
+f9
+
+# --- each_char on string, outer int c ---
+def f10
+  c = 7
+  "abc".each_char do |c|
+    puts c + "!"
+  end
+  puts c
+end
+f10
+# a!
+# b!
+# c!
+# 7
+
+# --- each_byte on string, outer string b ---
+def f11
+  b = "kept"
+  "AB".each_byte do |b|
+    puts b + 1
+  end
+  puts b
+end
+f11
+# 66
+# 67
+# kept
+
+# --- cycle on int_array with count, outer string x ---
+def f12
+  x = "outer"
+  [1, 2].cycle(2) do |x|
+    puts x * 10
+  end
+  puts x
+end
+f12
+# 10
+# 20
+# 10
+# 20
+# outer
+
+# --- scan with block on string, outer int m ---
+def f13
+  m = 99
+  "a1b2c3".scan(/\d+/) do |m|
+    puts m + "!"
+  end
+  puts m
+end
+f13
+# 1!
+# 2!
+# 3!
+# 99
+
+# --- each_slice on int_array, outer string v ---
+def f14
+  v = "hello"
+  [1, 2, 3, 4].each_slice(2) do |v|
+    puts v.length
+  end
+  puts v
+end
+f14
+# 2
+# 2
+# hello
+
+# --- each_cons on str_array, outer int c ---
+def f15
+  c = 7
+  ["a", "b", "c", "d"].each_cons(3) do |c|
+    puts c.length
+  end
+  puts c
+end
+f15
+# 3
+# 3
+# 7
+
+# --- tap on int receiver, outer string v ---
+def f16
+  v = "hello"
+  42.tap do |v|
+    puts v + 1
+  end
+  puts v
+end
+f16
+# 43
+# hello
+
+# --- tap on string receiver, outer int s ---
+def f17
+  s = 99
+  "abc".tap do |s|
+    puts s + "!"
+  end
+  puts s
+end
+f17
+# abc!
+# 99
+
+# --- then on int receiver, outer string v ---
+def f18
+  v = "hello"
+  out = 42.then { |v| v + 1 }
+  puts out
+  puts v
+end
+f18
+# 43
+# hello
+
+# --- yield_self with int receiver returning string, outer float v ---
+def f19
+  v = 3.14
+  out = 42.yield_self { |v| v.to_s + "!" }
+  puts out
+  puts v
+end
+f19
+# 42!
+# 3.14

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

@@ -0,0 +1,71 @@
+10
+20
+30
+hello
+a0
+b1
+outer
+a:0
+b:1
+c:2
+99
+11
+21
+31
+outer
+A
+B
+C
+42
+2
+3
+4
+kept
+2
+1
+2
+drop
+3
+3
+4
+5
+2
+1
+2
+outer
+2
+bb
+ccc
+1
+a
+99
+a!
+b!
+c!
+7
+66
+67
+kept
+10
+20
+10
+20
+outer
+1!
+2!
+3!
+99
+2
+2
+hello
+3
+3
+7
+43
+hello
+abc!
+99
+43
+hello
+42!
+3.14