rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/test/instance_exec_direct.rb

@@ -0,0 +1,72 @@
+# Direct-path instance_exec: `recv.instance_exec(args) { |params| body }`
+# called without a wrapping trampoline method. The analyze pass lifts
+# the block to a static function `sp_iexec_<N>(self, args...)` and
+# rewrites the call site to dispatch through it.
+#
+# Sibling of test/instance_exec_trampoline.rb (codegen-time inlining
+# of the def-m-instance_exec trampoline pattern). The direct form is
+# what most CRuby code writes: `obj.instance_exec(5) { |n| ... }` at
+# the call site, no wrapper method involved.
+#
+# Boundaries:
+#   - Strict arity: call-site args count == block params count.
+#   - No outer-local capture (the lifted function cannot see the
+#     caller's locals). Convert to the trampoline form for that.
+#   - Receiver must be a statically-resolvable obj_<C> -- a typed
+#     local, ivar, method param, or constant constructor.
+#   - return / break / next / yield / block_given? inside the block
+#     are rejected (silently for now; a follow-up upgrades to a hard error).
+#   - Value-typed receivers are unsupported (TODO carried over from
+#     compile_instance_eval_inlined_stmt's same issue). Multi-instance
+#     classes keep the receiver heap-allocated.
+
+# 1. Bare direct call with one arg. The block body adds the call-site
+#    arg to the receiver's @sum via the typed method `add`. Bare
+#    method calls inside the block resolve against the receiver's
+#    class (same dispatch path the trampoline tests exercise).
+class Builder
+  def initialize
+    @sum = 0
+  end
+
+  def add(n)
+    @sum = @sum + n
+  end
+
+  def total
+    @sum
+  end
+end
+
+b = Builder.new
+b.instance_exec(10) { |n| add(n) }
+b.instance_exec(20) { |n| add(n) }
+b.instance_exec(12) { |n| add(n) }
+puts b.total                  #=> 42
+
+# 2. Two args at the call site forward into two block params. Block
+#    body computes against them, mutates the receiver's ivar via the
+#    rebound-self path, and returns nothing (the baseline locks the
+#    return type to void).
+class Acc < Builder
+end
+
+a1 = Acc.new
+a2 = Acc.new
+a1.instance_exec(3, 4) { |s, k| add(s * k) }
+a2.instance_exec(7, 2) { |s, k| add(s * k) }
+a1.instance_exec(1, 0) { |s, k| add(s + k) }
+puts a1.total                 #=> 13
+puts a2.total                 #=> 14
+
+# 3. Zero-arg form (degenerate, equivalent to instance_eval): the
+#    detector accepts arity-0, the lifted function takes only the
+#    receiver. Tests that the baseline doesn't conflate arity-0
+#    with the instance_eval lift (they're independent registries
+#    even when behavior overlaps).
+b2 = Builder.new
+b2.instance_exec { add(100) }
+b2.instance_exec { add(50) }
+puts b2.total                 #=> 150
+
+puts "done"

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

@@ -0,0 +1,5 @@
+42
+13
+14
+150
+done

data/vendor/spinel/test/instance_exec_override.rb

@@ -0,0 +1,69 @@
+# User-defined instance_exec / instance_eval methods shadow the
+# compile-time intrinsic. Ordinary method dispatch resolves to the
+# user's method instead of the lift.
+#
+# Before the override check landed in iexec_rewrite_call /
+# ieval_rewrite_call, Spinel silently bypassed user overrides by
+# rewriting the call to __sp_iexec_<N> at the analyze level. CRuby
+# would have dispatched to the user's method; Spinel did not.
+#
+# A fuller approach (registering BasicObject and routing every
+# intrinsic through method-resolution from the start) would
+# rearchitect the class table. The lighter version here -- a
+# cls_find_method check that bails out of the rewrite when the
+# user has their own method -- gets the correctness win without
+# the rearchitecture risk.
+
+class Wrap
+  def initialize
+    @marker = 0
+  end
+
+  # User-defined instance_exec on Wrap. Spinel should NOT lift the
+  # block at the call site below; it should dispatch to this method
+  # instead, matching CRuby.
+  def instance_exec(x, &b)
+    @marker = x + 100
+    @marker
+  end
+
+  def marker
+    @marker
+  end
+end
+
+# Two instances so Wrap stays heap-allocated (value-type promotion
+# would otherwise complicate the test independent of the override
+# question).
+w1 = Wrap.new
+w2 = Wrap.new
+ret = w1.instance_exec(5) { |x| 9999 }  # block ignored -- user method runs
+puts ret              # 105
+puts w1.marker        # 105
+
+# Sibling override of instance_eval. Same expected dispatch.
+class Wrap2
+  def initialize
+    @tag = ""
+  end
+
+  def instance_eval(&b)
+    @tag = "user-instance-eval-ran"
+  end
+
+  def tag
+    @tag
+  end
+end
+
+w3 = Wrap2.new
+w4 = Wrap2.new
+# Block body is a no-op -- the user method ignores it. We use a noop
+# rather than `@tag = "intrinsic-ran"` because the latter would force
+# Spinel to compile the block as a proc literal even though it's
+# never invoked, and proc compilation of a toplevel-ivar string
+# assignment trips an unrelated proc-return-type issue.
+w3.instance_eval { 1 }   # block ignored by user method
+puts w3.tag           # user-instance-eval-ran
+
+puts "done"

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

@@ -0,0 +1,4 @@
+105
+105
+user-instance-eval-ran
+done

data/vendor/spinel/test/instance_exec_parity.rb

@@ -0,0 +1,44 @@
+# Consolidated CRuby-4.0.5 parity anchor for direct instance_exec: one
+# file exercising the supported core shapes in combination. Every line's
+# output is cross-checked against `ruby` (the .expected is the oracle).
+
+class Acc
+  def initialize(base)
+    @base = base
+  end
+
+  def base
+    @base
+  end
+
+  def combine(x, y)
+    @base + x + y
+  end
+end
+
+class AccPlus < Acc
+end
+
+a = AccPlus.new(100)
+
+# positional args bound to block params; body calls a rebound-self method
+puts a.instance_exec(3, 4) { |x, y| combine(x, y) }      #=> 107
+
+# expression position: call value is the block's last expression
+puts a.instance_exec(5) { |x| base + x }                 #=> 105
+
+# outer-local capture: read + write-back into the caller's scope
+total = 0
+a.instance_exec { total = base + 1 }
+puts total                                               #=> 101
+
+# capture accumulation across multiple calls
+sum = 0
+a.instance_exec { sum = sum + base }
+a.instance_exec { sum = sum + base }
+puts sum                                                 #=> 200
+
+# block body-local + multi-statement
+puts a.instance_exec(2) { |x| t = base + x; t * 2 }      #=> 204
+
+puts "done"

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

@@ -0,0 +1,6 @@
+107
+105
+101
+200
+204
+done

data/vendor/spinel/test/instance_exec_return.rb

@@ -0,0 +1,54 @@
+# Direct instance_exec in expression position: the call's value is the
+# block's last expression (CRuby semantics), not the receiver.
+#
+# Heap receivers are inlined at the call site -- the block body runs
+# with self rebound to the receiver, so @ivar reads and bare method
+# calls resolve against it, and the block's final value flows out as
+# the call's value. The prior void-lift baseline wrapped the call in a
+# comma-expression that yielded the receiver instead.
+
+class Box
+  def initialize(v)
+    @v = v
+  end
+
+  def doubled
+    @v * 2
+  end
+
+  def greet
+    "hi"
+  end
+end
+
+# A subclass keeps Box heap-allocated (multi-instance classes are not
+# SRA-promoted to value types), so the receiver is inlined at the call
+# site. Value-typed receivers are handled separately.
+class BoxPlus < Box
+end
+
+b = Box.new(10)
+
+# Expression position with an arg: value flows from the block.
+n = b.instance_exec(5) { |x| @v + x }
+puts n                                   #=> 15
+
+# Zero-arg block, bare method call against the rebound receiver.
+m = b.instance_exec { doubled }
+puts m                                   #=> 20
+
+# String-valued block.
+g = b.instance_exec { greet }
+puts g                                   #=> hi
+
+# Nested inside a larger expression.
+puts b.instance_exec(3) { |x| @v + x } + 100   #=> 113
+
+# Body-local variable inside the block.
+p = b.instance_exec(4) { |x| t = @v * x; t + @v }
+puts p                                   #=> 50
+
+# Statement position still inlines (value discarded).
+b.instance_exec(7) { |x| puts @v + x }   #=> 17
+
+puts "done"

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

@@ -0,0 +1,7 @@
+15
+20
+hi
+113
+50
+17
+done

data/vendor/spinel/test/instance_exec_trampoline.rb

@@ -0,0 +1,101 @@
+# Inline-at-call-site instance_exec trampoline.
+#
+# Sibling of test/instance_eval_trampoline.rb. instance_exec differs
+# from instance_eval by forwarding positional args from the call site
+# into the block's parameters:
+#
+#   def configure(x, &block)
+#     instance_exec(x, &block)   # x flows into block param at call site
+#   end
+#   b.configure(10) { |n| add(n) }   # n == 10 inside the spliced block
+#
+# Same AOT compromise as instance_eval: detected at compile time by
+# shape match (def m(p1..pN, &b); instance_exec(p1..pN, &b); end),
+# inlined at the call site with self rebound to the receiver and block
+# params bound to fresh suffixed C locals carrying the call-site arg
+# values. A non-trampoline shape falls through to ordinary dispatch; an
+# arity mismatch between block params and forwarded args is a hard error.
+#
+# Limitations exercised by the asymmetry note in section A below:
+#   - Direct `recv.instance_exec(args) { ... }` (outside a trampoline
+#     method) lifts to a static function and cannot capture outer
+#     locals (a follow-up adds pointer capture on the direct path).
+#   - Trampoline body must forward params 1:1, no literals / ivars /
+#     splat (relaxed in follow-ups).
+#   - Value-typed receivers crash on the pointer cast in the splice
+#     today; multi-instance classes (which Spinel keeps heap-allocated)
+#     are the workaround until the TODO in
+#     compile_instance_exec_inlined_stmt is fixed.
+
+# A. Asymmetry note
+#
+# Outer-local capture works on THIS path (trampoline) because the
+# block body is spliced at the call site, so outer locals are in
+# scope. The direct form `obj.instance_exec(args) { ... }` does NOT
+# capture outer locals -- its lifted static function cannot see the
+# caller's locals. Use the trampoline form when you need capture; a
+# follow-up closes this gap on the direct path.
+
+# 1. Single fixed arg, statement form: forwards the call-site arg
+#    into the block param, then bare method calls dispatch against
+#    the receiver's class (same rebound-self mechanism as
+#    instance_eval).
+class Builder
+  def initialize
+    @sum = 0
+  end
+
+  def add(n)
+    @sum = @sum + n
+  end
+
+  def total
+    @sum
+  end
+
+  def configure(x, &block)
+    instance_exec(x, &block)
+  end
+end
+
+b = Builder.new
+b.configure(10) { |n| add(n) }
+b.configure(20) { |n| add(n) }
+b.configure(12) { |n| add(n) }
+puts b.total              #=> 42
+
+# 2. Two fixed args, ivar read/write inside the block: each arg
+#    becomes a typed C local, the block body computes against them
+#    and the rebound receiver's @ivars. Validates that the
+#    rebound-self retrofit composes with block-param renaming. Builder is
+#    reused (already heap-allocated above) instead of a fresh
+#    class -- single-instance classes with only ivar mutation in
+#    the block tend to value-promote, which the TODO in
+#    compile_instance_exec_inlined_stmt does not yet handle.
+class Acc < Builder
+  def bump_by(step, k, &block)
+    instance_exec(step, k, &block)
+  end
+end
+
+a1 = Acc.new
+a2 = Acc.new                  # second instance keeps heap allocation
+a1.bump_by(3, 4) { |s, k| add(s * k) }
+a2.bump_by(7, 2) { |s, k| add(s * k) }
+a1.bump_by(1, 0) { |s, k| add(s + k) }
+puts a1.total                 #=> 13
+puts a2.total                 #=> 14
+
+# 3. Outer-local capture via the splice: total is in scope at the
+#    call site, so the block body reads and writes it. Validates
+#    that the trampoline path does NOT lift the block to a static
+#    function (which would lose closure scope) -- it splices,
+#    keeping outer locals reachable.
+total = 0
+b2 = Builder.new
+b2.configure(5) { |d| add(d); total = total + d }
+b2.configure(7) { |d| add(d); total = total + d }
+puts b2.total             #=> 12
+puts total                #=> 12
+
+puts "done"

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

@@ -0,0 +1,6 @@
+42
+13
+14
+12
+12
+done

data/vendor/spinel/test/instance_exec_valuetype.rb

@@ -0,0 +1,48 @@
+# A value-type receiver (an immutable, scalar-only class the compiler
+# promotes to a by-value struct) works with direct instance_exec via
+# inline-splice. self is rebound to a by-value copy of the receiver, so
+# ivar reads, bare rebound method calls, block params, expression-
+# position values and outer-local capture all resolve against it. (A
+# value type is immutable by construction, so there is no self-ivar
+# write-back to observe -- matching how the receiver is passed by value.)
+
+class Vec
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+
+  def x
+    @x
+  end
+
+  def sum
+    @x + @y
+  end
+end
+
+v = Vec.new(3, 4)
+
+# ivar read in the block.
+puts(v.instance_exec { @x })               #=> 3
+
+# operator over two ivar reads.
+puts(v.instance_exec { @x * @y })          #=> 12
+
+# bare rebound method call against the value-type self.
+puts(v.instance_exec { sum })              #=> 7
+
+# positional arg bound to a block param, combined with a rebound call.
+puts(v.instance_exec(10) { |k| sum + k })  #=> 17
+
+# expression position: the call value flows into an outer local.
+r = v.instance_exec { @x + 100 }
+puts r                                     #=> 103
+
+# outer-local capture: written from inside the block (caller scope, so
+# it propagates regardless of by-value self).
+acc = 0
+v.instance_exec { acc = sum + 1 }
+puts acc                                   #=> 8
+
+puts "done"

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

@@ -0,0 +1,7 @@
+3
+12
+7
+17
+103
+8
+done

data/vendor/spinel/test/instance_methods_false.rb

@@ -0,0 +1,41 @@
+# `Klass.instance_methods(false)` const-folds to a literal symbol array
+# of the class/module's own (non-inherited) instance methods. The set
+# matches method_defined?(name, false): the method table plus attr
+# readers and `=`-suffixed writers (spinel doesn't model visibility, so
+# private defs are included). The no-arg / `true` forms stay unfolded.
+class Foo
+  attr_reader :r
+  attr_writer :w
+  attr_accessor :rw
+  def hello; end
+  def world(a, b); end
+  private
+  def secret; end
+end
+
+ms = Foo.instance_methods(false)
+puts ms.class
+puts ms.include?(:hello)
+puts ms.include?(:world)
+puts ms.include?(:r)
+puts ms.include?(:w=)
+puts ms.include?(:rw)
+puts ms.include?(:rw=)
+puts ms.include?(:secret)
+puts ms.include?(:nope)
+
+module M
+  def self.a; end
+  def b; end
+  def c(x); end
+end
+
+mm = M.instance_methods(false)
+puts mm.include?(:b)
+puts mm.include?(:c)
+puts mm.include?(:a)
+puts mm.length
+
+class Empty
+end
+puts Empty.instance_methods(false).inspect

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

@@ -0,0 +1,14 @@
+Array
+true
+true
+true
+true
+true
+true
+true
+false
+true
+true
+false
+2
+[]

data/vendor/spinel/test/int_array_bracket_assign_expr.rb

@@ -0,0 +1,30 @@
+# `arr[i] = v` in *expression* position on int_array. The stmt-
+# form is handled by `compile_bracket_assign`; in rvalue chains
+# like `outer = arr[i] = rhs`, the call lands in the expression
+# dispatcher and was previously unresolved (warning + literal 0).
+#
+# Surfaced via optcarrot PPU's `@io_latch = @sp_ram[@regs_oam] = io_latch_mask(data)`
+# shape — the `sp_ram[idx] = mask` write is also the rvalue
+# assigned to `@io_latch`.
+
+a = [10, 20, 30, 40, 50]
+
+# Chained assignment: `b` should pick up the rhs (Ruby []= returns rhs).
+b = a[2] = 999
+
+puts a[0]
+puts a[1]
+puts a[2]   # mutated
+puts a[3]
+puts a[4]
+puts b      # 999
+
+# Index/value side-effect ordering: each subexpression evaluated once.
+i = 0
+def bump_i_to_3
+  3
+end
+
+c = a[bump_i_to_3] = 7777
+puts a[3]
+puts c

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

@@ -0,0 +1,8 @@
+10
+20
+999
+40
+50
+999
+7777
+7777

data/vendor/spinel/test/int_array_tally.rb

@@ -0,0 +1,14 @@
+# Array#tally on int_array maps each distinct element to its
+# occurrence count. Result is an int_int_hash (new variant
+# alongside sym_int_hash / str_int_hash etc.).
+result = [1, 2, 2, 3, 3, 3].tally
+puts result[1]
+puts result[2]
+puts result[3]
+puts result.length
+puts result.inspect
+puts result.has_key?(2)
+puts result.has_key?(99)
+# missing-key returns 0 in spinel today (vs nil in CRuby) —
+# the broader nullable-hash semantics are tracked in #801.
+puts result[99] == 0

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

@@ -0,0 +1,8 @@
+1
+2
+3
+3
+{1=>1, 2=>2, 3=>3}
+true
+false
+false

data/vendor/spinel/test/int_array_uniq_bang.rb

@@ -0,0 +1,15 @@
+# Array#uniq! on int_array — mutates in place. Returns the
+# receiver (CRuby returns self when something was removed and nil
+# otherwise; the typed int_array can't carry nil so we always
+# return self).
+a = [1, 2, 2, 3, 3, 3]
+a.uniq!
+puts a.inspect
+
+b = [1, 2, 3]
+b.uniq!
+puts b.inspect
+
+c = []
+c.uniq!
+puts c.inspect

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

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

data/vendor/spinel/test/int_ceil_floor_round.rb

@@ -0,0 +1,11 @@
+# Integer#ceil / floor / round / truncate without a precision arg
+# return self per CRuby. Previously fell through to the unresolved-
+# call path and emitted 0.
+puts 3.ceil
+puts 3.floor
+puts 3.round
+puts 3.truncate
+puts (-3).ceil
+puts (-3).floor
+puts (-3).round
+puts (-3).truncate

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

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

data/vendor/spinel/test/int_ceil_floor_round_truncate_ndigits.rb

@@ -0,0 +1,17 @@
+# Integer#ceil/floor/round/truncate with ndigits argument.
+# Without ndigits these return self; with negative ndigits they
+# round to the nearest 10^(-ndigits). Previously spinel silently
+# emitted 0 for any call with an argument.
+
+p 1234.ceil(-2)       # 1300
+p 1234.floor(-2)      # 1200
+p 1234.round(-2)      # 1200
+p 1234.truncate(-2)   # 1200
+p -1234.ceil(-2)      # -1200
+p -1234.floor(-2)     # -1300
+p -1234.truncate(-2)  # -1200
+p 1255.ceil(-2)       # 1300
+p 1255.floor(-2)      # 1200
+p 5.round(-1)         # 10
+p 1234.ceil(0)        # 1234 (positive ndigits: no-op)
+p 1234.round(2)       # 1234

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

@@ -0,0 +1,12 @@
+1300
+1200
+1200
+1200
+-1200
+-1300
+-1200
+1300
+1200
+10
+1234
+1234

data/vendor/spinel/test/int_hash_missing_nil_check.rb

@@ -0,0 +1,27 @@
+# Consumption-site nil-awareness for int-valued hashes (#801): a missing
+# key is nil in Ruby. The read stays typed `int` (making it int? cascades
+# through the self-host compiler), but at direct nil-check sites the
+# missing key is reported via has_key. Covers `.nil?`, and the already-
+# working `== nil` / `|| fallback`, across str_int / sym_int / int_int.
+
+si = {a: 1, b: 2}
+puts si[:zzz].nil?       # true
+puts si[:a].nil?         # false
+puts (si[:zzz] == nil)   # true
+puts (si[:zzz] || 99)    # 99
+puts (si[:a] || 99)      # 1
+
+sti = {"x" => 1}
+puts sti["y"].nil?       # true
+puts sti["x"].nil?       # false
+puts (sti["y"] || 7)     # 7
+
+ii = {1 => 10, 2 => 20}
+puts ii[9].nil?          # true
+puts ii[1].nil?          # false
+puts (ii[9] == nil)      # true
+puts (ii[9] || 5)        # 5
+
+# Present keys still behave as plain ints
+puts (si[:a] + 100)      # 101
+puts ii[2]               # 20

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

@@ -0,0 +1,14 @@
+true
+false
+true
+99
+1
+true
+false
+7
+true
+false
+true
+5
+101
+20