rubyduino 0.1.3 → 0.2.1

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

@@ -1,5 +0,0 @@
-5
-10
-99
-88
-8

data/vendor/spinel/test/proc_hash_value.rb

@@ -1,27 +0,0 @@
-# Issue #65: an ivar initialized as `{}` and later assigned `&block`
-# captured procs lowered the slot to str_int_hash, then fed
-# `sp_Proc *` into `sp_StrIntHash_set` (which expects mrb_int).
-#
-# Two fixes:
-#   - Issue #64's empty-hash promotion now resolves the slot to
-#     `str_poly_hash` when the value type is `proc`.
-#   - `box_expr_to_poly` / `box_value_to_poly` learned a `proc`
-#     branch so the `[]=` site emits `sp_box_proc(...)` instead of
-#     falling through to `sp_box_int`.
-#   - The empty-hash inline-init paths (compile_stmt and
-#     emit_constructor) now route to `sp_StrPolyHash_new()` /
-#     `sp_SymPolyHash_new()` for poly-valued promotions.
-
-class Registry
-  def initialize
-    @builtins = {}
-  end
-
-  def define_builtin(name, &block)
-    @builtins[name] = block
-  end
-end
-
-r = Registry.new
-r.define_builtin("x") { 1 }
-puts "ok"

data/vendor/spinel/test/regexp.rb

@@ -1,34 +0,0 @@
-# Test Regexp support
-
-# match operator
-if "hello 123 world" =~ /\d+/
-  puts "matched"
-end
-
-# match with capture
-str = "2024-03-17"
-if str =~ /(\d{4})-(\d{2})-(\d{2})/
-  puts $1  # 2024
-  puts $2  # 03
-  puts $3  # 17
-end
-
-# String#match?
-puts "hello".match?(/ell/)    # true
-puts "hello".match?(/xyz/)    # false
-
-# String#gsub with regexp
-puts "hello world".gsub(/o/, "0")   # hell0 w0rld
-
-# String#sub with regexp
-puts "hello world".sub(/o/, "0")    # hell0 world
-
-# String#scan
-"one 1 two 2 three 3".scan(/\d+/) do |m|
-  puts m
-end
-# 1, 2, 3
-
-# String#split with regexp
-parts = "a, b,  c".split(/,\s*/)
-puts parts.length  # 3

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

@@ -1,12 +0,0 @@
-matched
-2024
-03
-17
-true
-false
-hell0 w0rld
-hell0 world
-1
-2
-3
-3

data/vendor/spinel/test/reopen_class.rb

@@ -1,33 +0,0 @@
-# Test: reopening a user-defined class merges into the existing one
-# instead of producing duplicate C struct/constructor definitions.
-
-class Point
-  attr_accessor :x
-  def initialize(x, y)
-    @x = x
-    @y = y
-  end
-end
-
-class Point
-  attr_accessor :y
-  def to_s
-    "(" + @x.to_s + "," + @y.to_s + ")"
-  end
-end
-
-p = Point.new(3, 4)
-puts p.to_s
-puts p.x
-puts p.y
-p.x = 10
-p.y = 20
-puts p.to_s
-
-class Foo
-end
-
-class Foo
-end
-
-puts "ok"

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

@@ -1,5 +0,0 @@
-(3,4)
-3
-4
-(10,20)
-ok

data/vendor/spinel/test/runtime_widen_int_to_poly_array.rb

@@ -1,27 +0,0 @@
-# `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

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

data/vendor/spinel/test/sample_user_method.rb

@@ -1,20 +0,0 @@
-# `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

@@ -1,32 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# `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/send.rb

@@ -1,15 +0,0 @@
-# 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

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

data/vendor/spinel/test/stdlib.rb

@@ -1,28 +0,0 @@
-# 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

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

data/vendor/spinel/test/strip_nullable_int_cast.rb

@@ -1,24 +0,0 @@
-# `compile_typed_call_args` casts an int arg to an object-pointer
-# parameter via `(sp_<base> *)<expr>`. The base name was derived
-# from the raw param-type string. When the param type is nullable
-# (e.g. `obj_Foo?`, set when the writer-scan sees both `Foo.new`
-# and `nil` writes), the cast came out as `(sp_Foo? *)expr` and
-# gcc rejected the stray `?`.
-#
-# Repro: a setter-shaped method whose param is widened to
-# `obj_Foo?` by mixed Foo + nil writes, then called with an int-
-# typed argument (a method that returns int). The int-arg path
-# fires the cast.
-
-class Foo; end
-class C
-  def take(f)
-    @f = f
-  end
-  def get_int; 42; end
-end
-c = C.new
-c.take(Foo.new)
-c.take(nil)
-c.take(c.get_int)
-puts "ok"

data/vendor/spinel/test/super_arg_cross_class_cast.rb

@@ -1,39 +0,0 @@
-# Two subclasses each call `super` from `initialize` forwarding a
-# differently-typed arg. The parent's param-type inference picks one
-# concrete C type, so the other subclass's super-forwarded arg ends
-# up with a mismatching C type at the call site without an explicit
-# cast.
-
-class Box
-  def initialize(v)
-    @v = v
-  end
-end
-
-class StrBox < Box
-  def initialize(s)
-    super
-    @len = s.length
-  end
-
-  def len
-    @len
-  end
-end
-
-class IntBox < Box
-  def initialize(n)
-    super
-    @doubled = n * 2
-  end
-
-  def doubled
-    @doubled
-  end
-end
-
-s = StrBox.new("hello")
-puts s.len
-
-n = IntBox.new(7)
-puts n.doubled

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

@@ -1,2 +0,0 @@
-5
-14

data/vendor/spinel/test/super_forwarding.rb

@@ -1,25 +0,0 @@
-# Bare `super` (no args, no parens) inside a constructor parses as
-# `ForwardingSuperNode`, not `SuperNode`. Without the
-# ForwardingSuperNode case, the call to the parent's `initialize`
-# was silently dropped — the parent's ivar setup never ran and the
-# child object was left in a half-initialized state.
-
-class Base
-  def initialize(x)
-    @x = x
-    @y = x * 10
-  end
-end
-
-class Child < Base
-  attr_reader :x, :y, :z
-  def initialize(x)
-    super              # bare — forwards x to Base#initialize
-    @z = x + 1
-  end
-end
-
-c = Child.new(3)
-puts c.x   # 3
-puts c.y   # 30
-puts c.z   # 4

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

@@ -1,3 +0,0 @@
-3
-30
-4

data/vendor/spinel/test/sym_case.rb

@@ -1,15 +0,0 @@
-# Symbol in case/when
-def classify(sym)
-  case sym
-  when :red then "warm"
-  when :orange then "warm"
-  when :blue then "cool"
-  when :green then "cool"
-  else "unknown"
-  end
-end
-
-puts classify(:red)     # warm
-puts classify(:orange)  # warm
-puts classify(:blue)    # cool
-puts classify(:purple)  # unknown

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

@@ -1,4 +0,0 @@
-warm
-warm
-cool
-unknown

data/vendor/spinel/test/symbol_ivar_reassign.rb

@@ -1,25 +0,0 @@
-# Reassigning an instance variable to a different symbol used to demote
-# its type to `poly` because `infer_ivar_init_type` reported `:foo` as
-# `string` while `infer_type` reported it as `symbol`. The mismatch
-# tripped `update_ivar_type`'s "old != new_type" branch, widening the
-# field to `sp_RbVal`. Subsequent assignments emitted `self->s = SPS_bar`
-# (sp_sym = mrb_int) into an `sp_RbVal` slot — a C type error.
-
-class C
-  def initialize
-    @s = :foo
-  end
-
-  def reset
-    @s = :bar
-  end
-
-  def show
-    @s
-  end
-end
-
-c = C.new
-puts c.show
-c.reset
-puts c.show

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

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

data/vendor/spinel/test/toplevel_ivar_array.rb

@@ -1,19 +0,0 @@
-# Top-level instance variables: `@x` at script scope binds to the
-# main object, the same as inside an instance method. Spinel currently
-# emits `self->iv_x = ...` for ivar access but the script's top-level
-# function has no `self` parameter, so the C compiler errors with
-# `use of undeclared identifier 'self'`. The ivar read also falls
-# through type inference and gets defaulted to `int`, producing a
-# bogus "cannot resolve call to 'push' on int" warning before the
-# hard error.
-
-@n = 0
-@n = @n + 1
-@n = @n + 1
-puts @n
-
-@arr = []
-@arr.push(7)
-@arr.push(8)
-puts @arr.length
-@arr.each { |v| puts v }

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

@@ -1,4 +0,0 @@
-2
-2
-7
-8

data/vendor/spinel/test/unbox_poly_index_in_dispatch.rb

@@ -1,20 +0,0 @@
-# `emit_poly_builtin_dispatch` referenced `arg_types` out of scope.
-# Without the fix, `(poly_recv)[poly_idx]` produced
-# `sp_PolyArray_get(arr, sp_RbVal_idx)` — passing sp_RbVal where
-# mrb_int is expected and failing the C compile.
-#
-# Trigger: poly recv (from heterogeneous Hash) + poly idx (also).
-
-class C
-  def initialize
-    @bag  = { "arr" => [100, 200, 300, 400], "lbl" => "x" }
-    @keys = { "i" => 2, "s" => "lbl" }
-  end
-  def at(k)
-    arr = @bag["arr"]      # poly
-    idx = @keys[k]         # poly
-    arr[idx]               # poly recv + poly idx
-  end
-end
-
-puts C.new.at("i").to_s    # use .to_s (handled separately) instead of .to_i

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

@@ -1 +0,0 @@
-300

data/vendor/spinel/test/undef.rb

@@ -1,33 +0,0 @@
-# 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

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

data/vendor/spinel/test/user_method_named_like_mutator.rb

@@ -1,30 +0,0 @@
-# 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

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

data/vendor/spinel/test/value_type_ctor_gc_save.rb

@@ -1,46 +0,0 @@
-# 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

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

data/vendor/spinel/test/widen_int_obj_to_poly.rb

@@ -1,29 +0,0 @@
-# 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