rubyduino 0.1.1

data/vendor/spinel/test/array_slice_bang.rb

@@ -0,0 +1,81 @@
+# Array#slice!(from, n) on every typed array. Returns a fresh
+# array of n elements starting at `from`, and mutates the receiver
+# to remove them. IntArray uses its `start` field for an O(1) head
+# peel; the others shift the tail down to fill the hole.
+
+# --- IntArray: head peel (from == 0) ---
+arr = [10, 20, 30, 40, 50]
+head = arr.slice!(0, 2)
+puts head.length        # 2
+puts head[0]            # 10
+puts head[1]            # 20
+puts arr.length         # 3
+puts arr[0]             # 30
+
+# --- IntArray: middle slice (from > 0, tail shift) ---
+arr2 = [1, 2, 3, 4, 5, 6, 7]
+mid = arr2.slice!(2, 3)
+puts mid[0]             # 3
+puts mid[2]             # 5
+puts arr2.length        # 4
+puts arr2[2]            # 6 (tail shifted down)
+puts arr2[3]            # 7
+
+# --- IntArray: n > available, clamped ---
+arr3 = [100, 200, 300]
+big = arr3.slice!(1, 999)
+puts big.length         # 2
+puts arr3.length        # 1
+
+# --- FloatArray ---
+fa = [1.5, 2.5, 3.5, 4.5, 5.5]
+fh = fa.slice!(0, 2)
+puts fh.length          # 2
+puts fh[0]              # 1.5
+puts fa.length          # 3
+puts fa[0]              # 3.5
+
+# --- StrArray ---
+sa = ["a", "b", "c", "d", "e"]
+sh = sa.slice!(1, 2)
+puts sh.length          # 2
+puts sh[0]              # b
+puts sh[1]              # c
+puts sa.length          # 3
+puts sa[0]              # a
+puts sa[1]              # d (tail shifted down)
+puts sa[2]              # e
+
+# --- SymArray (shares the IntArray helper internally) ---
+syms = [:foo, :bar, :baz, :qux]
+sym_h = syms.slice!(0, 2)
+puts sym_h.length       # 2
+puts sym_h[0]           # foo
+puts syms.length        # 2
+puts syms[0]            # baz
+puts syms[1]            # qux
+
+# --- PtrArray (array of obj_X instances) ---
+class Box
+  attr_reader :v
+  def initialize(v); @v = v; end
+end
+
+pa = [Box.new(10), Box.new(20), Box.new(30), Box.new(40)]
+ph = pa.slice!(1, 2)
+puts ph.length          # 2
+puts ph[0].v            # 20
+puts ph[1].v            # 30
+puts pa.length          # 2
+puts pa[0].v            # 10
+puts pa[1].v            # 40 (tail shifted down)
+
+# --- PolyArray (heterogeneous literal) ---
+poly = [1, "two", :three, 4.5, "five"]
+poly_h = poly.slice!(1, 3)
+puts poly_h.length      # 3
+puts poly_h[0]          # two
+puts poly_h[2]          # 4.5
+puts poly.length        # 2
+puts poly[0]            # 1
+puts poly[1]            # five

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

@@ -0,0 +1,40 @@
+2
+10
+20
+3
+30
+3
+5
+4
+6
+7
+2
+1
+2
+1.5
+3
+3.5
+2
+b
+c
+3
+a
+d
+e
+2
+foo
+2
+baz
+qux
+2
+20
+30
+2
+10
+40
+3
+two
+4.5
+2
+1
+five

data/vendor/spinel/test/attr.rb

@@ -0,0 +1,77 @@
+# Test attr_accessor, attr_reader, attr_writer, class methods, for..in, loop
+
+class Point
+  attr_accessor :x, :y
+
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+
+  def self.origin
+    Point.new(0, 0)
+  end
+
+  def distance_to(other)
+    dx = @x - other.x
+    dy = @y - other.y
+    Math.sqrt(dx * dx + dy * dy)
+  end
+
+  def to_s
+    "(" + @x.to_s + ", " + @y.to_s + ")"
+  end
+end
+
+p1 = Point.new(3, 4)
+puts p1.x        # 3
+puts p1.y        # 4
+p1.x = 10
+puts p1.x        # 10
+
+p2 = Point.origin
+puts p2.x        # 0
+
+# for..in with range
+total = 0
+for i in 1..10
+  total += i
+end
+puts total        # 55
+
+# loop with break
+count = 0
+loop do
+  count += 1
+  break if count >= 5
+end
+puts count        # 5
+
+# Array#each with index (using each)
+arr = (1..5).to_a
+sum = 0
+arr.each do |x|
+  sum += x
+end
+puts sum          # 15
+
+# String#to_s on object
+puts p1.to_s      # (10, 4)
+
+# attr_accessor path should keep ivar/local namespaces distinct.
+class IvarCollision
+  attr_accessor :x, :iv_x
+
+  def initialize
+    @x = 1
+    @iv_x = 2
+  end
+
+  def sum
+    x = 10
+    iv_x = 20
+    @x + @iv_x + self.x + self.iv_x + x + iv_x
+  end
+end
+
+puts IvarCollision.new.sum   # 36

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

@@ -0,0 +1,9 @@
+3
+4
+10
+0
+55
+5
+15
+(10, 4)
+36

data/vendor/spinel/test/attr_writer_poly_box.rb

@@ -0,0 +1,24 @@
+# `obj.attr = v` codegen emitted `slot = arg0` regardless of slot
+# type. When the slot is poly (sp_RbVal — widened by heterogeneous
+# writes) and the rhs is typed (int / string / obj_X / ...), C
+# rejects the assignment as a struct-from-scalar/pointer mismatch.
+
+class Bag
+  attr_accessor :item
+  def initialize
+    @item = "tag"     # string first…
+    @item = 5         # …then int — slot widens to poly
+  end
+end
+
+class Caller
+  def stuff(bag)
+    bag.item = 99     # statement-form attr-writer on poly slot
+    bag.item
+  end
+end
+
+b = Bag.new
+puts Caller.new.stuff(b)   # 99
+puts (b.item = 7)          # 7  (expression-form; `=` returns rhs)
+puts b.item                # 7

data/vendor/spinel/test/attr_writer_poly_no_double_eval.rb

@@ -0,0 +1,29 @@
+# Expression-form `obj.attr = rhs` on a poly slot used to lower to
+# the comma expression `(slot = box(rhs), rhs)`, which evaluates rhs
+# textually twice in C. If rhs has side effects (a method call, a
+# string allocation, etc.) they run twice. Verify rhs runs exactly
+# once by spilling to a typed temp via statement expression.
+
+class Counter
+  def initialize
+    @n = 0
+  end
+  def step
+    @n = @n + 1
+    @n
+  end
+end
+
+class Bag
+  attr_accessor :item
+  def initialize
+    @item = "tag"   # widen slot to poly via heterogeneous writes
+    @item = 5
+  end
+end
+
+c = Counter.new
+b = Bag.new
+puts (b.item = c.step)   # 1  (chain value is rhs; step runs once)
+puts (b.item = c.step)   # 2
+puts (b.item = c.step)   # 3

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

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

data/vendor/spinel/test/attr_writer_returns_rhs.rb

@@ -0,0 +1,23 @@
+# `obj.attr = v` as an expression should evaluate to `v`, the rhs,
+# matching Ruby semantics. Codegen used to emit `(rc->iv = v, 0)` —
+# the trailing `, 0` made the C expression value `0`, so chained
+# writes `local = obj.attr = v` saw 0 instead of v.
+
+class Box
+  attr_accessor :n
+  def initialize
+    @n = 0
+  end
+end
+
+b = Box.new
+local = (b.n = 42)
+puts local      # 42
+puts b.n        # 42
+
+# Chained variant — both lvalues should land on the same rhs value.
+b1 = Box.new
+b2 = Box.new
+b1.n = b2.n = 7
+puts b1.n       # 7
+puts b2.n       # 7

data/vendor/spinel/test/auto_unbox_keeps_int_slot.rb

@@ -0,0 +1,38 @@
+# Followup to PR #347: when a poly RHS is auto-unboxed into an
+# int local slot, the slot's tracked type must stay int so a
+# *subsequent* poly RHS write also unboxes. Without this, the
+# first auto-unbox-write widened the slot's tracked type to
+# poly; the second poly write then emitted `lv = <sp_RbVal>;`
+# (no unbox) into the still-int C declaration, failing the C
+# compile (`incompatible types when assigning to type 'mrb_int'
+# from type 'sp_RbVal'`).
+#
+# Reproduces optcarrot's chained `pixel0 = sprite[N]` writes:
+# the function-level slot stays mrb_int (set by an earlier
+# int_array read), but later sprite[N] writes are poly.
+
+class C
+  def make_int_arr; @arr = [10, 20, 30]; end
+  def make_poly_arr
+    @arr = [nil] * 3
+    @arr[0] = 100
+    @arr[1] = 200
+    @arr[2] = 300
+  end
+  def at(i); @arr[i]; end
+end
+
+c = C.new
+
+# Two consecutive poly RHS writes into the same int slot. Both
+# must auto-unbox; without the fix, the second one fails C compile.
+c.make_int_arr
+val = c.at(0)            # int RHS, val slot established as int
+puts val
+
+c.make_poly_arr
+val = c.at(0)            # 1st poly RHS — already worked in PR #347
+puts val
+
+val = c.at(2)            # 2nd poly RHS — must also unbox; failed pre-fix
+puts val

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

@@ -0,0 +1,3 @@
+10
+100
+300

data/vendor/spinel/test/auto_unbox_poly_to_int_local.rb

@@ -0,0 +1,36 @@
+# Auto-unbox poly RHS into a primitive int local slot. Common
+# case: `lv = arr[i]` where arr's element dispatch returns poly
+# (heterogeneous element types) but the local was already inferred
+# as int from a prior write. Spinel previously emitted
+# `lv = <sp_RbVal>;` and the C compile failed (`incompatible
+# types when assigning to type 'mrb_int' from type 'sp_RbVal'`).
+#
+# Repro: an ivar widened to poly via two distinct array shapes
+# (an int_array and a poly_array). The local `pixel` was first
+# set from an int_array (so its declared C type is mrb_int),
+# then a second write reassigns from the poly slot. Without
+# auto-unbox, the second assignment fails.
+
+class C
+  def make_int_arr
+    @arr = [10, 20, 30]
+  end
+  def make_poly_arr
+    @arr = [nil] * 3
+    @arr[0] = 99
+    @arr[1] = "x"
+    @arr[2] = :y
+  end
+  def first_int
+    @arr[0]
+  end
+end
+
+c = C.new
+c.make_int_arr
+pixel = c.first_int   # int from int_array
+puts pixel.to_s
+
+c.make_poly_arr
+pixel = c.first_int   # poly from poly_array, must auto-unbox
+puts pixel.to_s

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

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

data/vendor/spinel/test/back_ref.rb

@@ -0,0 +1,21 @@
+# BackReferenceReadNode -- `$&`, `$~`, `$'`, $`.
+#
+# Special globals populated by regex matches. Spinel's regex engine
+# already populates sp_re_match* state for $1..$9 (NumberedReferenceReadNode);
+# this extends to the symbolic back-references.
+#
+#   $&  -- the entire matched substring
+#   $~  -- the MatchData object (aliased to $& in Spinel; no MatchData wrapper)
+#   $`  -- the substring before the match
+#   $'  -- the substring after the match
+
+"hello world" =~ /lo wo/
+puts $&     # lo wo
+puts $`     # hel
+puts $'     # rld
+
+# Re-match updates the state
+"abcdef" =~ /cd/
+puts $&     # cd
+puts $`     # ab
+puts $'     # ef

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

@@ -0,0 +1,6 @@
+lo wo
+hel
+rld
+cd
+ab
+ef

data/vendor/spinel/test/bare_return_in_cls_method.rb

@@ -0,0 +1,46 @@
+# Issue #314 follow-up: a class method whose return type was
+# inferred as `obj_<C>` (because every explicit return path
+# produced a value of that class) lowered a bare `return` to
+# `return self;` — but class methods have no `self` C param, so
+# gcc complained `'self' undeclared`.
+#
+# Fix: thread a `@current_method_has_self` flag through the
+# instance-method / class-method / top-level / constructor-
+# synthesis emit paths. compile_return_stmt's bare-return-with-
+# obj_<C>-return path emits `return self;` only when has_self=1,
+# otherwise `return c_return_default(...);` (which knows about
+# value vs pointer object types).
+#
+# Companion to b9d6303 (#337) which added the obj_<C> branch for
+# constructor synthesis.
+#
+# Surfaced via Roundhouse's `InMemoryAdapter.update` — a module
+# class method whose return type was inferred as obj_HWIA via
+# the `attrs.each` last-expression, with an early `return if
+# row.nil?` lowering to broken `return self;`.
+
+class Holder
+  attr_reader :id
+  def initialize(id)
+    @id = id
+  end
+
+  def self.maybe(id)
+    if id < 0
+      return       # ← bare return; bug emitted `return self;`
+    end
+    Holder.new(id)
+  end
+end
+
+# Pushing into a [Holder] array forces Holder out of the value-type
+# bucket so `Holder.maybe` returns `sp_Holder *` (pointer) and the
+# bare-return shape exercises the pointer fallback.
+holders = [Holder.new(0)]
+
+a = Holder.maybe(42)
+holders << a
+puts a.id                 # 42
+
+b = Holder.maybe(-1)
+puts b.nil?               # true

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

@@ -0,0 +1,2 @@
+42
+true

data/vendor/spinel/test/bare_return_in_initialize.rb

@@ -0,0 +1,55 @@
+# Issue #337: a bare `return` (Ruby's "exit early" form) inside an
+# `initialize` body used to lower to `return 0;` regardless of the
+# wrapping function's C return type. Two emit shapes were affected:
+#
+#  - `sp_<C>_new(...)` (sp_<C> *-returning, the heap-allocated
+#    constructor synthesis): `return 0;` silently NULLed the
+#    instance on the early-return branch — semantically wrong, no C
+#    diagnostic.
+#
+#  - `sp_<C>_initialize(...)` (void-returning, used for `super`
+#    chains): `return 0;` is a `void function should not return a
+#    value` error under strict C compile.
+#
+# Fix: pin @current_method_return per emission shape (obj_<C> for
+# the _new synthesis, "void" for the _initialize wrapper) so the
+# bare-return path picks the right C statement — `return self;` for
+# heap constructors (returns the partially-initialized instance,
+# matching the issue's expected-behavior table) and `return;` for
+# the void wrapper.
+
+class Box
+  attr_reader :data
+  def initialize(other = nil)
+    @data = "ok"
+    return if other.nil?
+    @data = other
+  end
+end
+
+# Default-construct: the bare `return` inside initialize fires;
+# `@data` stays at "ok".
+b1 = Box.new
+puts b1.data           # ok
+
+# Pass an explicit value: the early return is skipped; `@data` is
+# overwritten.
+b2 = Box.new("hi")
+puts b2.data           # hi
+
+# Subclass exercising the void `_initialize` super-call form: the
+# parent's bare return inside the wrapper must lower to `return;`
+# (not `return 0;`, which would be a C error in a void function).
+class TaggedBox < Box
+  attr_reader :tag
+  def initialize(other = nil, tag:)
+    super(other)
+    @tag = tag
+  end
+end
+
+t = TaggedBox.new("payload", tag: "label")
+puts t.tag             # label
+
+t2 = TaggedBox.new(tag: "empty")
+puts t2.tag            # empty

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

@@ -0,0 +1,4 @@
+ok
+hi
+label
+empty

data/vendor/spinel/test/bare_return_in_poly_method.rb

@@ -0,0 +1,26 @@
+# Issue #383: bare `return` (no value) in a method whose declared
+# return type is `sp_RbVal` (poly) emitted literal `return 0;`
+# instead of `return sp_box_nil();` — gcc errors `incompatible
+# types when returning type 'int' but 'sp_RbVal' was expected`.
+# The implicit end-of-function fallthrough already emitted the
+# correct boxed nil; only bare-return statements were missed.
+#
+# Sister to the void-initialize and obj_<C>-class-method fixes
+# (#337 / #314 follow-up). compile_return_stmt's bare-return
+# path now has a poly arm that emits `sp_box_nil()`.
+
+class Adapter
+  def self.lookup(key)
+    return unless key == "x"     # poly-returning fn, bare return
+    if key.length > 5
+      "long-string"
+    else
+      [1, 2, 3]
+    end
+  end
+end
+
+# Heterogeneous return types collapse to poly; the bare-return
+# branch needs to box nil into the same slot.
+puts Adapter.lookup("x").to_s
+puts Adapter.lookup("none").to_s

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

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

data/vendor/spinel/test/bigint_div_by_zero.rb

@@ -0,0 +1,43 @@
+# Bigint division / modulo by zero raises ZeroDivisionError.
+#
+# Bigint detection: `a = a * 2` inside a `while` loop promotes the
+# local to bigint via scan_bigint_in_loop_node. Raising 1 by *2 50
+# times overflows the mrb_int range so `a` is bigint-typed by the
+# time we hit the / 0 expression.
+#
+# Runtime path: sp_bigint_div / sp_bigint_mod call into mini-gmp,
+# which detects the zero divisor at sp_bigint.c:2718 and calls
+# mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0"). The mrb_raise
+# macro now dispatches to sp_bigint_raise_zerodiv (defined non-
+# static in sp_runtime.h, linked from gen.c), which calls
+# sp_raise_cls — same longjmp path as the int-div case.
+
+a = 1
+i = 0
+while i < 50
+  a = a * 2
+  i = i + 1
+end
+
+# `a` is now 2^50, well above the mrb_int range — bigint-typed.
+
+begin
+  x = a / 0
+  puts "no raise"
+rescue ZeroDivisionError => e
+  puts "caught bigint div: #{e}"
+end
+
+begin
+  x = a % 0
+  puts "no raise"
+rescue ZeroDivisionError => e
+  puts "caught bigint mod: #{e}"
+end
+
+# Bare rescue also catches.
+begin
+  a / 0
+rescue => e
+  puts "bare-rescue: #{e}"
+end

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

@@ -0,0 +1,3 @@
+caught bigint div: divided by 0
+caught bigint mod: divided by 0
+bare-rescue: divided by 0

data/vendor/spinel/test/block2.rb

@@ -0,0 +1,31 @@
+# Test block_given? and optional blocks
+
+def maybe_yield(x)
+  if block_given?
+    yield x
+  else
+    x * 2
+  end
+end
+
+puts maybe_yield(5)  # 10 (no block)
+
+result = 0
+maybe_yield(5) do |n|
+  result = n * 3
+end
+puts result  # 15
+
+# Method that always yields
+def each_pair(a, b)
+  yield a
+  yield b
+end
+
+total = 0
+each_pair(10, 20) do |n|
+  total += n
+end
+puts total  # 30
+
+puts "done"

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

@@ -0,0 +1,4 @@
+10
+15
+30
+done