rubyduino 0.1.1

data/vendor/spinel/test/undef.rb

@@ -0,0 +1,33 @@
+# UndefNode -- `undef foo` inside a class body.
+#
+# CRuby raises NoMethodError if the undef'd method is called. In
+# Spinel's AOT model we cannot dispatch at runtime (methods are
+# static C functions resolved at compile time), so `undef foo`
+# becomes a compile-time error: any call to `.foo` on an instance
+# of this class fails to compile with a precise message.
+#
+# This test verifies that defining + calling another method on the
+# same class still works after undef -- undef removes only the
+# named method, not the whole class.
+
+class C
+  def foo = "foo"
+  def bar = "bar"
+  undef foo
+end
+
+c = C.new
+puts c.bar     # bar
+
+# Multi-name form: `undef foo, bar` exercises the names-array path in
+# spinel_parse.c (PM_UNDEF_NODE emits `names` as A(...)). Defining a
+# third method `baz` and undef'ing the other two verifies that exactly
+# the named methods are removed.
+class D
+  def foo = "foo"
+  def bar = "bar"
+  def baz = "baz"
+  undef foo, bar
+end
+
+puts D.new.baz # baz

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

@@ -0,0 +1,2 @@
+bar
+baz

data/vendor/spinel/test/user_method_named_like_mutator.rb

@@ -0,0 +1,30 @@
+# compile_body_return treats certain method names (`update`, `clear`,
+# `concat`, `delete`, `each`, `pop`, `push`, `merge!`, ...) as
+# statement-only because Hash and Array mutators are conventionally
+# called for side-effect. That's right when the receiver IS a Hash
+# or Array, but it silently throws away the value when a user class
+# happens to define a method with one of those names — including the
+# implicit `self.update(...)` form, since the receiver chain isn't
+# even consulted before the name match fires.
+#
+# Pre-fix, `C.new.f(7)` returned 0 (correct: 8) and
+# `D.new.run(C.new)` returned 0 (correct: 30). Both follow Ruby
+# semantics now.
+
+class C
+  def update(target)
+    target
+  end
+  def f(n)
+    update(n + 1)   # implicit self.update — was discarded
+  end
+end
+
+class D
+  def run(c)
+    c.update(30)    # explicit recv on user class — was discarded
+  end
+end
+
+puts C.new.f(7)
+puts D.new.run(C.new)

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

@@ -0,0 +1,2 @@
+8
+30

data/vendor/spinel/test/value_type_ctor_gc_save.rb

@@ -0,0 +1,46 @@
+# A value-type constructor body that introduces a GC-managed local
+# (here `arr`, an int_array) needs `SP_GC_SAVE()` paired with the
+# `SP_GC_ROOT(lv_arr)` that `declare_method_locals` emits.
+#
+# `emit_constructor` only emits SP_GC_SAVE for the non-value-type
+# branch. For value types it leaves `@in_gc_scope` whatever the
+# *previous* method left it as. If the previous method was a
+# non-value class's body (which sets `@in_gc_scope = 1`), the
+# inherited scope made `declare_method_locals` skip its SP_GC_SAVE
+# and the value-type ctor emitted an unbalanced SP_GC_ROOT —
+# pushing a stack pointer that becomes dangling on return.
+#
+# Reproducer: Foo (heap class) is compiled before Vec (value type),
+# so without the fix Vec_new's lv_arr root gets pushed without a
+# matching save. The fix resets `@in_gc_scope = 0` at the value-
+# type ctor entry so declare_method_locals emits SP_GC_SAVE.
+
+class Foo
+  def make
+    [1, 2, 3]
+  end
+end
+
+class Vec
+  attr_reader :sum
+  def initialize(x, y)
+    arr = [x, y, x + y]
+    @sum = arr[2]
+  end
+end
+
+f = Foo.new
+puts f.make.length            # 3
+v = Vec.new(3, 4)
+puts v.sum                    # 7
+
+# Many ctor calls so the unbalanced ROOTs would saturate
+# sp_gc_nroots if they weren't matched by SP_GC_RESTORE.
+sum = 0
+i = 0
+while i < 200
+  vv = Vec.new(i, i + 1)
+  sum = sum + vv.sum
+  i = i + 1
+end
+puts sum                       # 200 * (i + (i+1)) summed = sum of (2i+1) for i=0..199 = 200*200 = 40000

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

@@ -0,0 +1,3 @@
+3
+7
+40000

data/vendor/spinel/test/widen_int_obj_to_poly.rb

@@ -0,0 +1,29 @@
+# When an ivar's first observed write is a definite int / nil
+# literal and a later write assigns an obj-typed value, the slot
+# was overwritten with the obj type — silently casting the prior
+# int payload to a struct pointer. Subsequent dispatch through
+# the slot then read garbage or computed pointer arithmetic.
+#
+# Widening to poly so the slot carries either case at runtime
+# preserves the program's actual semantics: the dispatch path
+# decides per cls_id at the call site.
+
+class Box
+  def initialize(n)
+    @n = n
+    @arr = []
+    @arr << n
+  end
+  attr_reader :n
+end
+
+class Holder
+  def initialize
+    @poly = 10              # definite int first
+    @poly = Box.new(5)      # …then obj — slot widens to poly
+  end
+  attr_reader :poly
+end
+
+# poly recv → Box#n via cls_id == Box dispatch
+puts Holder.new.poly.n      # 5

data/vendor/spinel/test/yield.rb

@@ -0,0 +1,67 @@
+# Test program for yield/block support
+
+# User-defined iterator with yield
+def my_times(n)
+  i = 0
+  while i < n
+    yield i
+    i += 1
+  end
+end
+
+# Array#each
+def sum_array(arr)
+  total = 0
+  arr.each do |x|
+    total += x
+  end
+  total
+end
+
+# Array#map
+def double_array(arr)
+  arr.map do |x|
+    x * 2
+  end
+end
+
+# Array#select
+def evens(arr)
+  arr.select do |x|
+    x % 2 == 0
+  end
+end
+
+# Nested yield
+def repeat(n)
+  i = 0
+  while i < n
+    yield i
+    i += 1
+  end
+end
+
+# Main
+total = 0
+my_times(10) do |i|
+  total += i
+end
+puts total  # 45
+
+arr = (1..10).to_a
+puts sum_array(arr)  # 55
+
+doubled = double_array(arr)
+puts doubled.length  # 10
+
+even_nums = evens(arr)
+puts even_nums.length  # 5
+
+# Nested: repeat yields, inner block accumulates
+result = 0
+repeat(5) do |i|
+  my_times(i) do |j|
+    result += j
+  end
+end
+puts result  # 0+0+1+0+1+2+0+1+2+3 = 10

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

@@ -0,0 +1,5 @@
+45
+55
+10
+5
+10

data/vendor/spinel/test/yield_method_call_in_method_body.rb

@@ -0,0 +1,58 @@
+# Calling a yield-using method on implicit self from inside another
+# instance method's body used to drop the literal block — the call
+# site emitted `sp_C_run(self, "foo")` against a signature that
+# wanted 4 args. Same call from top-level worked.
+#
+# scan path: compile_writer_and_block_call_stmt's literal-block
+# branch only handled `recv < 0` for top-level methods (via the
+# global @meth_has_yield table) and `recv >= 0` for class methods
+# (via try_yield_or_trampoline_dispatch). The "implicit self inside
+# class method" case fell into neither.
+
+class C
+  def run(name)
+    yield
+    name
+  end
+
+  def call_it
+    run("foo") do
+      puts "block ran"
+    end
+  end
+
+  # Variant: default arg in target. Same root cause; just a different
+  # arity surface — exercised explicitly because the issue called it
+  # out as a separate failure mode.
+  def run_with_default(name, count = 1)
+    yield
+    count
+  end
+
+  def call_it_default
+    run_with_default("bar", -1) do
+      puts "default-arg block ran"
+    end
+  end
+end
+
+# Parent class with the yield method, child calls it via implicit
+# self — exercises the new ancestor walk.
+class P
+  def each_thing
+    yield 1
+    yield 2
+  end
+end
+
+class K < P
+  def use
+    each_thing do |v|
+      puts v
+    end
+  end
+end
+
+C.new.call_it
+C.new.call_it_default
+K.new.use

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

@@ -0,0 +1,4 @@
+block ran
+default-arg block ran
+1
+2