rubyduino 0.2.0 → 0.2.1

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

@@ -1,4 +0,0 @@
-7
-set:hello
-5
-done

data/vendor/spinel/test/no_keywords_param.rb

@@ -1,15 +0,0 @@
-# NoKeywordsParameterNode — `def f(**nil)` explicit kwarg rejection.
-#
-# In CRuby this declares the method rejects keyword arguments;
-# attempting `f(k: 1)` raises ArgumentError. Spinel's keyword-arg
-# handling is already conservative (only known keys accepted), so
-# the explicit `**nil` marker is effectively a no-op at the codegen
-# level. The parser must still recognize the node so Phase 0's
-# UnsupportedNode loud-error doesn't fire.
-
-def add(a, b, **nil)
-  a + b
-end
-
-puts add(1, 2)     # 3
-puts add(10, 20)   # 30

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

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

data/vendor/spinel/test/obj_array.rb

@@ -1,26 +0,0 @@
-class Point
-  attr_accessor :x
-  attr_accessor :y
-  def initialize(x, y)
-    @tag = "p"
-    @x = x
-    @y = y
-  end
-  def to_s
-    x.to_s + "," + y.to_s
-  end
-end
-
-points = [Point.new(1, 2), Point.new(3, 4), Point.new(5, 6)]
-points.each { |p|
-  puts p.to_s
-}
-puts points.length
-
-# push to obj array
-more = []
-more.push(Point.new(10, 20))
-more.push(Point.new(30, 40))
-more.each { |p|
-  puts p.x + p.y
-}

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

@@ -1,6 +0,0 @@
-1,2
-3,4
-5,6
-3
-30
-70

data/vendor/spinel/test/obj_class_returns_string.rb

@@ -1,24 +0,0 @@
-# `<user_obj>.class` collapses to the class name as a string.
-# Spinel doesn't allocate runtime Class objects, so the only
-# coherent representation for `obj.class` is the textual name.
-# The two real-world consumers in optcarrot are:
-#   1. `"#<#{ self.class }>"`-style interpolation in `inspect`
-#   2. `self.class.to_s.split("::").last`-style introspection
-# Both work fine if `.class` simply yields the class name as a
-# string (the second loses the `::` namespace because Spinel
-# flattens nested modules with `_`, but that's a cosmetic loss).
-
-class Foo
-  def to_s
-    "<" + self.class + ">"
-  end
-end
-
-class Bar
-  def label
-    self.class.to_s
-  end
-end
-
-puts Foo.new.to_s   # => <Foo>
-puts Bar.new.label  # => Bar

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

@@ -1,2 +0,0 @@
-<Foo>
-Bar

data/vendor/spinel/test/optional_string_param_method.rb

@@ -1,11 +0,0 @@
-def parse(source, file_path = nil)
-  if file_path
-    puts file_path.length
-  else
-    puts source.length
-  end
-end
-
-parse("abc", "name.rb")
-parse("abc")
-parse("longer", "another_name.rb")

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

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

data/vendor/spinel/test/poly_array_literal_callnode_typed_elem.rb

@@ -1,37 +0,0 @@
-# `[A, B]` outer literal where A and B are non-ArrayNode expressions
-# returning a typed `<X>_ptr_array` (e.g. `(0..N).map { ... }`).
-# Without the fix, compile_array_literal's poly_array branch hits
-# `box_value_to_poly(et, val)` for the CallNode element, which lowers
-# to `sp_box_ptr_array(val)` — cls_id PTR_ARRAY only, the inner
-# element type is erased. Subsequent `arr[b][i][j]` reads dispatch
-# through the PTR_ARRAY arm at level 1, which boxes the next-level
-# element as `sp_box_obj(p, 0)` (cls_id 0, "unknown obj"), and the
-# level-2 dispatch can't match any cls_id arm — every leaf read
-# returns 0.
-#
-# With the fix, the runtime conversion loop iterates the typed
-# PtrArray and pushes each inner with `sp_box_<inner-type>` (e.g.
-# `sp_box_int_array(...)` for an IntArray element), so the cls_id
-# chain stays tagged through every level.
-
-class C
-  def initialize
-    @a = [(0..3).map { |i| [i * 10, i * 10 + 1, i * 10 + 2] },
-          (0..3).map { |i| [i * 100, i * 100 + 1, i * 100 + 2] }]
-  end
-  def get(b, i, j); @a[b][i][j]; end
-  def out_len; @a.length; end
-  def mid_len(b); @a[b].length; end
-  def in_len(b, i); @a[b][i].length; end
-end
-
-c = C.new
-puts c.out_len           # 2
-puts c.mid_len(0)        # 4
-puts c.in_len(0, 0)      # 3
-puts c.get(0, 0, 0)      # 0
-puts c.get(0, 1, 1)      # 11
-puts c.get(0, 3, 2)      # 32
-puts c.get(1, 0, 0)      # 0
-puts c.get(1, 2, 1)      # 201
-puts c.get(1, 3, 2)      # 302

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

@@ -1,9 +0,0 @@
-2
-4
-3
-0
-11
-32
-0
-201
-302

data/vendor/spinel/test/poly_array_slot_literal.rb

@@ -1,41 +0,0 @@
-# `@arr = [a, b]` going into a poly_array slot used to compile the
-# rhs via `compile_array_literal`, which infers a typed storage
-# (ptr_array of one class for homogeneous obj literals, etc.) and
-# emits the matching `sp_PtrArray *`. The slot is `sp_PolyArray *`
-# (widened by writer-scan via heterogeneous `@arr[i] = v` writes
-# elsewhere in the class), so the resulting C contains a pointer-
-# type mismatch:
-#
-#   sp_PtrArray *_t1 = sp_PtrArray_new();
-#   sp_PtrArray_push(_t1, sp_Pad_new());
-#   self->iv_pads = _t1;          /* iv_pads is sp_PolyArray * */
-#
-# The default `-Wno-all` build accepts the cast silently and
-# coerces, but strict flags reject it as
-# `assignment to 'sp_PolyArray *' from incompatible pointer type
-# 'sp_PtrArray *'`. Even under `-Wno-all` the runtime is wrong:
-# `PolyArray_set` writes 16-byte sp_RbVal entries into 8-byte
-# PtrArray slots and silently corrupts adjacent memory.
-
-class Pad
-  def initialize(n)
-    @n = n
-    @arr = []
-    @arr << n
-  end
-  attr_reader :n
-end
-
-class Holder
-  def initialize
-    @pads = [Pad.new(10), Pad.new(20)]
-    @pads[0] = "x"   # heterogeneous []= → @pads widens to poly_array
-  end
-  attr_reader :pads
-
-  def count
-    @pads.length
-  end
-end
-
-puts Holder.new.count    # 2

data/vendor/spinel/test/poly_array_slot_sized_default.rb

@@ -1,33 +0,0 @@
-# `@arr = [nil] * N` going into a poly_array slot used to lower
-# the rhs via the default `*` codegen, which produces an sp_IntArray.
-# The slot is `sp_PolyArray *` (widened by writer-scan via
-# heterogeneous `@arr[i] = v` writes elsewhere in the class), so
-# the resulting C contains a pointer-type mismatch:
-#
-#   sp_IntArray *_t1 = sp_IntArray_new();
-#   ...
-#   self->iv_arr = _t1;          /* iv_arr is sp_PolyArray * */
-#
-# The default `-Wno-all` build silently coerces and the runtime
-# runs with garbage: subsequent `sp_PolyArray_set(@arr, ...)`
-# calls write 16-byte sp_RbVal entries into 8-byte IntArray slots,
-# corrupting adjacent memory and skewing `@arr.length`.
-#
-# An equivalent guard exists for ptr_array slots; this PR extends
-# it to poly_array slots (constructor + general InstanceVariable-
-# WriteNode paths) so the lowered storage matches the slot.
-
-class Holder
-  def initialize
-    @arr = [nil] * 3
-    @arr[0] = 42      # int
-    @arr[1] = "two"   # str — heterogeneous → @arr widens to poly_array
-  end
-  attr_reader :arr
-
-  def count
-    @arr.length
-  end
-end
-
-puts Holder.new.count   # 3

data/vendor/spinel/test/poly_box_int_array.rb

@@ -1,13 +0,0 @@
-# Built-in pointer types (IntArray, etc.) need to be boxable into a
-# poly value so they can flow through a parameter typed as poly.
-# Before this fix, `box_expr_to_poly` fell through to `sp_box_int(v)`
-# for anything that wasn't a recognized scalar / `obj_<Class>` —
-# passing a `sp_IntArray *` to `sp_box_int` (which wants `mrb_int`)
-# is a C type error, so the program simply didn't compile.
-
-def kind_of(a)
-  a.nil? ? "nil" : "something"
-end
-
-puts kind_of(Object.new)
-puts kind_of([1, 2, 3])

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

@@ -1,2 +0,0 @@
-something
-something

data/vendor/spinel/test/poly_dispatch_args_ret.rb

@@ -1,45 +0,0 @@
-# Regression test for polymorphic return flow:
-# a method returning different class instances from branches.
-
-class A
-  def read(v)
-    v + 1
-  end
-end
-
-class B
-  def read(v)
-    v + 2
-  end
-end
-
-class Builder
-  def make(flag)
-    if flag == 0
-      A.new
-    else
-      B.new
-    end
-  end
-
-  def make_with_return(flag)
-    if flag == 0
-      return A.new
-    end
-    return B.new
-  end
-end
-
-b = Builder.new
-
-obj0 = b.make(0)
-puts obj0.read(41)
-
-obj1 = b.make(1)
-puts obj1.read(41)
-
-ret0 = b.make_with_return(0)
-puts ret0.read(41)
-
-ret1 = b.make_with_return(1)
-puts ret1.read(41)

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

@@ -1,4 +0,0 @@
-42
-43
-42
-43

data/vendor/spinel/test/poly_dispatch_arity_padding.rb

@@ -1,36 +0,0 @@
-# Poly dispatch over user classes whose `m` definitions have
-# different arities — Switch#toggle takes 0 args; Knob#toggle takes
-# one positional default. Without per-arm padding, the C compiler
-# rejects the dispatch table with "too few arguments to function
-# 'sp_Knob_toggle'" (the dispatch arms have one fixed call shape
-# but the candidate methods have different arities).
-
-class Switch
-  def initialize
-    @v = 1
-  end
-  def toggle
-    @v = 0
-  end
-  attr_reader :v
-end
-
-class Knob
-  def toggle(soft = true)
-    0
-  end
-end
-
-class Box
-  def initialize
-    @items = [Switch.new, Switch.new]   # poly-typed; .toggle dispatch
-                                        # over every class with `toggle`
-  end
-  attr_reader :items
-end
-
-b = Box.new
-b.items[0].toggle
-b.items[1].toggle
-puts b.items[0].v   # 0
-puts b.items[1].v   # 0

data/vendor/spinel/test/poly_dispatch_arity_truncate.rb

@@ -1,45 +0,0 @@
-# Poly-dispatch arms must match each candidate method's *fixed* C
-# arity. The padding side (target takes more params than the call
-# supplied — defaults fill the extras) was already in place. The
-# truncate side is the complement: when a candidate class's method
-# accepts *fewer* params than the call supplied, that arm has to
-# drop the surplus to compile, even though the runtime cls_id check
-# would skip it for a non-matching receiver.
-
-class Heater
-  def initialize
-    @v = 0
-  end
-  def write(addr, data)
-    @v = addr + data
-  end
-  attr_reader :v
-end
-
-class Buzzer
-  def initialize
-    @v = 0
-  end
-  def write(addr)        # one fewer arg than Heater#write
-    @v = addr
-  end
-  attr_reader :v
-end
-
-class Box
-  def initialize
-    @poly = nil
-    @poly = "x"
-    @poly = Heater.new   # widen to poly via heterogeneous writes
-  end
-
-  attr_reader :poly
-
-  def call_write(addr, data)
-    @poly.write(addr, data)   # poly recv → arms over Heater + Buzzer
-  end
-end
-
-b = Box.new
-b.call_write(7, 5)
-puts b.poly.v   # 12  (Heater: addr + data)

data/vendor/spinel/test/poly_hash_literal_from_ivar.rb

@@ -1,47 +0,0 @@
-# Issue #287: a method that returns `{ key: @x, ... }` had its
-# inferred return type frozen at the first scan, before #247 widened
-# the ivar slot to poly via a sibling-writer disagreement. The hash
-# literal then emitted as `sp_StrIntHash *` (int-valued) and tried
-# to insert the now-poly ivar value at C compile time.
-#
-# Fix: extend `infer_hash_val_type`'s all_same branch to handle
-# `first_vt == "poly"` — sym/str-keyed poly hashes get the same
-# *_poly_hash storage as the mixed-types `else` branch.
-
-class C
-  def initialize
-    @x = 0
-  end
-  def write_str(s)
-    @x = s
-  end
-  def hash_of_x
-    { key: @x }
-  end
-end
-
-c = C.new
-c.write_str("hello")
-puts c.hash_of_x.size       # 1
-puts c.hash_of_x.has_key?(:key)  # true
-
-# Multiple sym-keyed entries, all flowing from poly ivars.
-class D
-  def initialize
-    @a = 0
-    @b = 0
-  end
-  def write(sa, sb)
-    @a = sa
-    @b = sb
-  end
-  def attrs
-    { a: @a, b: @b }
-  end
-end
-
-d = D.new
-d.write("alpha", "beta")
-puts d.attrs.size           # 2
-puts d.attrs.has_key?(:a)   # true
-puts d.attrs.has_key?(:c)   # false

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

@@ -1,5 +0,0 @@
-1
-true
-2
-true
-false

data/vendor/spinel/test/poly_int_arith_auto_unify.rb

@@ -1,26 +0,0 @@
-# Auto-unify int receiver + poly argument in arithmetic. Common
-# case: `addr + arr[i][j]` where the inner dispatch is a
-# heterogeneous user-class+IntArray array — both arms genuinely
-# return int at runtime, but spinel statically types `[]`
-# dispatch as poly. Spinel previously emitted `(addr +
-# <sp_RbVal>)` and the C compile failed (`invalid operands to
-# binary + (have 'mrb_int' and 'sp_RbVal')`). The operator-site
-# fall-through now unboxes the poly arg via .v.i, mirroring PR
-# #347's LV-write semantics.
-
-# Class that defines `[]` returning int — when stored alongside an
-# IntArray in a poly_array, the outer `[]` dispatch returns poly.
-class Lookup
-  def [](i); i * 10 + 1; end
-end
-
-arr = [Lookup.new, [100, 200, 300]]
-
-# arr[i] is poly (Lookup or IntArray), then `[j]` dispatches —
-# every runtime arm returns int, but the static return type is
-# poly. So `addr + arr[1][0]` is `int + poly` at codegen time.
-addr = 7
-puts(addr + arr[1][0])  # 7 + 100 = 107
-puts(addr - arr[0][2])  # 7 - 21  = -14
-puts(addr * arr[1][1])  # 7 * 200 = 1400
-puts(arr[1][2] / 3)     # 300 / 3 = 100  (recv-poly + arg-int already worked via sp_poly_div, included for coverage)

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

@@ -1,4 +0,0 @@
-107
--14
-1400
-100

data/vendor/spinel/test/poly_int_bit_index.rb

@@ -1,50 +0,0 @@
-# `Integer#[N]` (bit-extraction) where the receiver was typed
-# poly via cascading inference. Used to fall through to the
-# SP_TAG_OBJ array dispatch in `emit_poly_builtin_dispatch`'s
-# `[]` branch, leaving the result at the nil/0 default — so
-# `int[i]` returned 0 for every i, and downstream
-# `pc[8] == tmp[8] ? a : b` style page-bit checks always took
-# the same-page branch.
-
-class Holder
-  # Mixed-type ivar writes widen @x to poly. Reads return sp_RbVal
-  # even when the runtime value is concretely int.
-  def initialize
-    @x = "init"
-    @x = 0b10110100  # 180 — actual value at test time
-  end
-
-  attr_reader :x
-
-  # Same-page check pattern: extract bit 8 from each poly-typed int.
-  def same_page?(a, b)
-    a[8] == b[8]
-  end
-end
-
-h = Holder.new
-v = h.x  # `v` is poly here
-
-# Static index, dynamic value. Without the fix, every output is 0.
-puts v[0]    # 0
-puts v[1]    # 0
-puts v[2]    # 1
-puts v[3]    # 0
-puts v[4]    # 1
-puts v[5]    # 1
-puts v[6]    # 0
-puts v[7]    # 1
-
-# Dynamic index. Same buggy fallthrough.
-i = 0
-while i < 4
-  puts v[i]
-  i += 1
-end
-
-# Page-bit check: `0x100 | x` flips bit 8 on/off so the comparison
-# meaningfully differs depending on input. With the bug both values
-# get bit-8 == 0 (default), the comparison is always true, and
-# branch-cycle counting collapses.
-puts h.same_page?(h.x, h.x | 0x100)   # false (bit 8 differs)
-puts h.same_page?(h.x, h.x | 0x10)    # true (bit 8 same — both 0)

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

@@ -1,14 +0,0 @@
-0
-0
-1
-0
-1
-1
-0
-1
-0
-0
-1
-0
-false
-true

data/vendor/spinel/test/poly_or_returns_value.rb

@@ -1,13 +0,0 @@
-def pick(a, b)
-  a || b
-end
-
-puts pick(nil, "fallback")
-puts pick("actual", "fallback")
-
-def pick_int(a, b)
-  a || b
-end
-
-puts pick_int(0, 5)
-puts(nil || "direct")

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

@@ -1,4 +0,0 @@
-fallback
-actual
-0
-direct

data/vendor/spinel/test/poly_recv_bracket_assign.rb

@@ -1,31 +0,0 @@
-# `compile_bracket_assign` had no `rt == "poly"` branch. When an
-# ivar slot widens to plain `poly` (sp_RbVal — wider than
-# poly_array, set by `finalize_ivar_heterogeneity` because of
-# multiple distinct non-array writes), `@arr[i] = v` falls through
-# every typed branch and emits *nothing* — the assignment silently
-# drops from generated C.
-#
-# Trigger: @arr is observed as int_array (`[nil] * N`) AND as a
-# scalar (string, int) — finalize collapses to plain `poly`. Then
-# `@arr[i] = v` should still write to the underlying storage, but
-# without the poly arm spinel emits zero code for the assignment.
-
-class C
-  def init_arr(n)
-    @arr = [nil] * n      # int_array observation
-    @arr[0] = 100
-  end
-  def init_str
-    @arr = "scalar"       # string observation — widens slot to poly
-  end
-  def init_int
-    @arr = 42             # int observation
-  end
-  def at(i)
-    @arr[i]
-  end
-end
-
-c = C.new
-c.init_arr(3)
-puts c.at(0)              # post-write: 100 (master: 0 — write dropped)

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

@@ -1 +0,0 @@
-100

data/vendor/spinel/test/poly_recv_each.rb

@@ -1,35 +0,0 @@
-# `<poly>.each` runtime dispatch on cls_id. The compile_each_block
-# handler previously bailed when the receiver type was `poly` (no
-# matching `if rt == "..."` branch), so a method body that ends in
-# `iterable.each do |a| ... end` over a poly slot silently dropped
-# the iteration.
-#
-# Repro: an ivar `@store` widened to poly via two distinct array
-# shapes (an int_array and a poly_array) is iterated via `.each`.
-# Spinel previously emitted no loop at all — the body never ran.
-# The block param `a` is delivered as sp_RbVal (the widest fit
-# across the cls_id arms).
-
-class C
-  def store_int_array
-    @store = [10, 20, 30]
-  end
-  def store_poly_array
-    @store = [nil] * 3
-    @store[0] = "a"
-    @store[1] = "b"
-    @store[2] = "c"
-  end
-  def visit
-    @store.each do |x|
-      puts x.to_s
-    end
-  end
-end
-
-c = C.new
-c.store_int_array
-c.visit
-puts "---"
-c.store_poly_array
-c.visit

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

@@ -1,7 +0,0 @@
-10
-20
-30
----
-a
-b
-c

data/vendor/spinel/test/poly_shl_array_push_dispatch.rb

@@ -1,35 +0,0 @@
-# `<<` on a poly recv used to always lower to sp_poly_shl, which
-# was Integer-bit-shift only. An IntArray boxed into a poly slot
-# (e.g. an ivar that the type-inference passes widened to poly
-# because it received both nil and an array) had its `<<` push
-# silently turn into a bit-shift of the encoded pointer/length,
-# dropping the rhs.
-#
-# After the fix, sp_poly_shl dispatches by recv cls_id and invokes
-# the matching Array#<< push. Falls through to bit-shift only when
-# the recv is a non-array (genuine Integer<<int).
-
-class C
-  def initialize
-    # `nil` then concrete-array writes widen @v to poly (Issue #130
-    # "definite int/nil + obj → poly"). Once poly, the runtime
-    # carries cls_id INT_ARRAY at access time.
-    @v = nil
-    @v = [10, 20, 30]
-  end
-  def push(x); @v << x; end
-  def length; @v.length; end
-  def get(i); @v[i]; end
-end
-
-c = C.new
-c.push(99)
-c.push(88)
-puts c.length         # 5
-puts c.get(0)         # 10
-puts c.get(3)         # 99
-puts c.get(4)         # 88
-
-# Bit-shift on genuine Integer recv still works (the fall-through).
-x = 1
-puts x << 3           # 8