rubyduino 0.1.1

data/vendor/spinel/test/lrama_features.rb

@@ -0,0 +1,142 @@
+# lrama-required features. Combines what was previously split across
+# lrama_features.rb / _2.rb / _3.rb (the sections were "part 1/2/3"
+# of the same coverage matrix).
+
+# === Part 1 ===
+
+# private (should be ignored)
+class Foo
+  def pub; "public"; end
+  private
+  def priv; "private"; end
+end
+f = Foo.new
+puts f.pub
+
+# bare case (case without expression)
+x = 5
+result_x = case
+           when x > 10 then "big"
+           when x > 3 then "medium"
+           else "small"
+           end
+puts result_x
+
+# Array.new(n, val)
+arr_new = Array.new(5, 42)
+puts arr_new.length  # 5
+puts arr_new[0]      # 42
+puts arr_new[4]      # 42
+
+# Array#compact (no-op for IntArray)
+a2 = [1, 2, 3]
+puts a2.compact.length  # 3
+
+# Array#flatten (no-op for IntArray)
+puts a2.flatten.length  # 3
+
+# Array#unshift
+a3 = [2, 3, 4]
+a3.unshift(1)
+puts a3[0]  # 1
+puts a3.length  # 4
+
+# Array#reverse
+a4 = [1, 2, 3]
+rev = a4.reverse
+puts rev[0]  # 3
+puts rev[2]  # 1
+
+# Float::INFINITY
+puts Float::INFINITY > 999999  # true
+
+puts "done"
+
+# === Part 2 ===
+
+# A9: Hash#merge (sp_StrIntHash)
+mrg1 = {"a" => 1, "b" => 2}
+mrg2 = {"b" => 3, "c" => 4}
+mrg3 = mrg1.merge(mrg2)
+puts mrg3["a"]  # 1
+puts mrg3["b"]  # 3  (mrg2 overrides mrg1)
+puts mrg3["c"]  # 4
+
+# A19: Array#dup
+arr_dup = [10, 20, 30]
+arr_dup2 = arr_dup.dup
+puts arr_dup2[0]  # 10
+puts arr_dup2.length  # 3
+
+# A19: String#dup (const string)
+sd1 = "hello"
+sd2 = sd1.dup
+puts sd2  # hello
+
+# A20: Hash.new(0) with default value
+counter = Hash.new(0)
+counter["x"] = counter["x"] + 1
+counter["x"] = counter["x"] + 1
+counter["y"] = counter["y"] + 1
+puts counter["x"]  # 2
+puts counter["y"]  # 1
+puts counter["z"]  # 0 (default)
+
+# B2: attr_writer
+class Writer
+  attr_reader :name
+  attr_writer :name
+  def initialize(n)
+    @name = n
+  end
+end
+w = Writer.new("before")
+puts w.name  # before
+w.name = "after"
+puts w.name  # after
+
+# B3: Comparable (include Comparable + def <=>)
+class Weight
+  include Comparable
+  attr_reader :grams
+  def initialize(g)
+    @grams = g
+  end
+  def <=>(other)
+    @grams - other.grams
+  end
+end
+w1 = Weight.new(100)
+w2 = Weight.new(200)
+w3 = Weight.new(100)
+puts w1 < w2    # true
+puts w2 > w1    # true
+puts w1 == w3   # true
+puts w1 > w2    # false
+puts w1 <= w3   # true
+puts w2 >= w1   # true
+
+puts "done"
+
+# === Part 3 ===
+
+# A10: Hash#transform_values (sp_StrIntHash)
+tv = {"a" => 1, "b" => 2, "c" => 3}
+tv2 = tv.transform_values { |v| v * 10 }
+puts tv2["a"]  # 10
+puts tv2["b"]  # 20
+puts tv2["c"]  # 30
+puts tv["a"]   # 1  (original unchanged)
+
+# A18: Array#zip
+za = [1, 2, 3]
+zb = [4, 5, 6]
+zipped = za.zip(zb)
+puts zipped.length  # 3
+
+# Zip with different lengths
+zc = [10, 20]
+zipped2 = za.zip(zc)
+puts zipped2.length  # 3
+
+puts "done"

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

@@ -0,0 +1,38 @@
+public
+medium
+5
+42
+42
+3
+3
+1
+4
+3
+1
+true
+done
+1
+3
+4
+10
+3
+hello
+2
+1
+0
+before
+after
+true
+true
+true
+false
+true
+true
+done
+10
+20
+30
+1
+3
+3
+done

data/vendor/spinel/test/map_array_block_result.rb

@@ -0,0 +1,29 @@
+# `arr.map { array_block }` — outer recv is a typed Array, block
+# returns a typed array (`(0..i).to_a` here is int_array). Without
+# the fix, two issues conspire:
+#
+#   - infer_method_name_type returned int_array, so the ivar `@rows`
+#     was typed as int_array. The outer accumulator was an
+#     sp_IntArray pushed via sp_IntArray_push — but each iteration's
+#     value was an sp_IntArray pointer reinterpreted as mrb_int,
+#     which gcc rejects on -Wint-conversion.
+#   - Even if the cast were silent, the inner arrays would not be
+#     traced from an IntArray slot and could be collected mid-loop.
+#
+# After the fix, the result is `<elem>_ptr_array` and the codegen
+# accumulator is an sp_PtrArray pushed via sp_PtrArray_push.
+
+class C
+  def initialize
+    @rows = [1, 6].map { |i| (0..i).to_a }
+  end
+
+  def show
+    @rows.each do |row|
+      row.each { |x| print x, " " }
+      puts
+    end
+  end
+end
+
+C.new.show

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

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

data/vendor/spinel/test/map_block_returns_nested_array.rb

@@ -0,0 +1,53 @@
+# `Range#map` / `int_array.map` whose block returns an array
+# (1D, 2D, 3D nested) used to silently degrade — the codegen
+# returned `0` for non-int/string/float block returns at the
+# Range#map path, and `int_array.map` boxed inner ptr_array
+# results via `sp_box_ptr_array(val)` which erased the
+# elem-type info (cls_id PTR_ARRAY only) so deeper indexing
+# fell through every dispatch arm to `sp_box_nil()`.
+#
+# Fixes:
+#
+# - Range#map block returning a typed array now stores in
+#   `sp_PtrArray` (matching the inferred `<bret>_ptr_array`
+#   type). Deeper nesting (block returns ptr_array /
+#   poly_array) stores in `sp_PolyArray` with `box_value_to_poly`
+#   boxing — preserves cls_id chain for `arr[i][j][k]...`.
+#
+# - `int_array.map`'s deep-array branch (block returns
+#   `<X>_ptr_array`) converts the inner sp_PtrArray to
+#   sp_PolyArray inline via a per-element `sp_box_<elem>` re-tag,
+#   so the outer PolyArray's elements carry the right cls_id at
+#   the next dispatch level.
+#
+# Together this lets nested-map-of-array-block constructs
+# (e.g. optcarrot's `TILE_LUT = [...].map { (0..7).map {
+# (0...0x10000).map { ... } }.transpose }`) compile and read
+# at every depth.
+
+# Range#map -> int_array_ptr_array (2D)
+class M2
+  def initialize
+    @t = (0..2).map { |i| (0..3).map { |j| i * 10 + j } }
+  end
+  def read(i, j); @t[i][j]; end
+end
+m2 = M2.new
+puts m2.read(0, 0)   # 0
+puts m2.read(1, 2)   # 12
+puts m2.read(2, 3)   # 23
+
+# int_array.map { Range#map { ... } } -> 3D via PolyArray
+class M3
+  def initialize
+    @t = [10, 20].map do |a|
+      (0..2).map { |b| [a + b, a + b + 100] }
+    end
+  end
+  def read(i, j, k); @t[i][j][k]; end
+end
+m3 = M3.new
+puts m3.read(0, 0, 0)   # 10
+puts m3.read(0, 1, 1)   # 111
+puts m3.read(1, 2, 0)   # 22
+puts m3.read(1, 2, 1)   # 122

data/vendor/spinel/test/map_empty_block.rb

@@ -0,0 +1,26 @@
+# Issue #210 follow-up: an empty `map {}` block must still produce
+# an array of the same length as the receiver. Each map dispatch
+# (Range#, N.times#, int_array#, str_array#, poly_array#) used to
+# skip the push entirely on an empty block, leaving the typed
+# accumulator short and downstream `.length` / `[i]` wrong.
+
+# Range#map
+puts (0..2).map {}.length          # 3
+
+# N.times.map
+puts 4.times.map {}.length         # 4
+
+# int_array#map
+puts [10, 20, 30].map {}.length    # 3
+
+# str_array#map
+puts ["a", "b", "c", "d"].map {}.length   # 4
+
+# poly_array#map
+puts [1, "two", :three].map {}.length     # 3
+
+# ptr_array#map (homogeneous obj_X[])
+class Box
+  def initialize(v); @v = v; end
+end
+puts [Box.new(1), Box.new(2), Box.new(3)].map {}.length  # 3

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

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

data/vendor/spinel/test/map_range_recv_array_block.rb

@@ -0,0 +1,31 @@
+# `infer_method_name_type` for `map` used to fall through to
+# `infer_type(recv)` when the block returned a non-trivial shape
+# (an array literal). For a Range recv that yielded `range`,
+# poisoning any ivar holding the result; an `@x = something_else`
+# assignment then failed to type-check (`@x = 0` against an
+# `sp_Range` slot).
+#
+# Now `Range#map { array_block }` infers as `<inner>_ptr_array`
+# (matching the runtime sp_PtrArray storage), so the result can
+# be indexed `arr[i][j]` directly. A subsequent re-assignment
+# with a different array shape goes to a separate slot to avoid
+# spinel's slot widening to poly.
+
+class C
+  def initialize
+    # Block returns an int_array — outer is int_array_ptr_array.
+    @rows = (0...3).map { |i| [i, i * 10] }
+    # Separate slot for a plain int_array.
+    @flat = [10, 20, 30]
+  end
+
+  def show
+    @rows.each { |row| row.each { |v| puts v } }
+    @flat.each { |v| puts v }
+  end
+end
+
+C.new.show
+# Expected:
+#   0 / 0 / 1 / 10 / 2 / 20 (each row's elements)
+#   10 / 20 / 30 (flat)

data/vendor/spinel/test/mega.rb

@@ -0,0 +1,35 @@
+# Test megamorphic dispatch (3+ types)
+
+class Dog
+  def speak; "Woof!"; end
+  def name; "Dog"; end
+end
+
+class Cat
+  def speak; "Meow!"; end
+  def name; "Cat"; end
+end
+
+class Bird
+  def speak; "Tweet!"; end
+  def name; "Bird"; end
+end
+
+def make_noise(animal)
+  puts animal.speak
+end
+
+make_noise(Dog.new)   # Woof!
+make_noise(Cat.new)   # Meow!
+make_noise(Bird.new)  # Tweet!
+
+# Also test with name method
+def identify(animal)
+  puts animal.name
+end
+
+identify(Dog.new)   # Dog
+identify(Cat.new)   # Cat
+identify(Bird.new)  # Bird
+
+puts "done"

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

@@ -0,0 +1,7 @@
+Woof!
+Meow!
+Tweet!
+Dog
+Cat
+Bird
+done

data/vendor/spinel/test/method.rb

@@ -0,0 +1,21 @@
+def double(x)
+  x * 2
+end
+
+# Direct call for type inference
+puts double(1)   # 2
+
+m = method(:double)
+puts m.call(5)   # 10
+puts m.call(10)  # 20
+
+def add_ten(x)
+  x + 10
+end
+
+puts add_ten(0)  # 10
+
+a = method(:add_ten)
+puts a.call(3)   # 13
+
+puts "done"

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

@@ -0,0 +1,6 @@
+2
+10
+20
+10
+13
+done

data/vendor/spinel/test/method_defined.rb

@@ -0,0 +1,36 @@
+# Module#method_defined?(:sym) — compile-time decided via the
+# class's recorded method table (walks the parent chain, includes
+# attr readers/writers).
+class Animal
+  def name; "Animal"; end
+  attr_accessor :age
+end
+
+class Dog < Animal
+  def bark; "woof"; end
+end
+
+p Animal.method_defined?(:name)
+p Animal.method_defined?(:age)
+p Animal.method_defined?(:age=)
+p Animal.method_defined?(:bark)
+p Animal.method_defined?(:nope)
+
+p Dog.method_defined?(:name)
+p Dog.method_defined?(:bark)
+p Dog.method_defined?(:age)
+p Dog.method_defined?(:nope)
+
+# String arg form
+p Animal.method_defined?("name")
+p Animal.method_defined?("nope")
+
+# Inherit=false — restrict the lookup to the receiver's own methods.
+# Dog#bark is defined locally; Dog inherits #name and #age from Animal.
+# With inherit=false, only :bark is reported on Dog.
+p Dog.method_defined?(:bark, false)   # true  (defined on Dog)
+p Dog.method_defined?(:name, false)   # false (inherited from Animal)
+p Dog.method_defined?(:age, false)    # false (inherited)
+p Dog.method_defined?(:age=, false)   # false (inherited)
+p Animal.method_defined?(:name, false) # true (defined on Animal)
+p Animal.method_defined?(:bark, false) # false (defined on Dog only)

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

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

data/vendor/spinel/test/method_dispatch_poly_array.rb

@@ -0,0 +1,35 @@
+# Master PR #312 added heap-allocated `Method` objects but left a
+# hole in heterogeneous poly_array element dispatch:
+#
+# - `@arr[i] = method(:foo)` mixed with `@arr[i] = some_int_array`
+#   had no widen-to-poly_array path on the write side
+#   (`scan_writer_calls`).
+# - `finalize_ivar_heterogeneity` collapsed the multi-array
+#   observation list to plain `poly` (sp_RbVal slot), discarding
+#   element-array semantics.
+# - `emit_poly_builtin_dispatch` had no Method-cls_id arm in the
+#   read-side `bm[arg]` dispatch on poly recv.
+#
+# Combined effect on master: the IntArray write was void*-cast
+# into a `<X>_ptr_array<Method>` storage, then the read
+# dereferenced the IntArray pointer as if it were `sp_Method *`
+# — `iv_fn_ptr` reads garbage and the indirect call segfaults.
+# This is the natural CPU-memory dispatch shape `@fetch[a][a]`.
+
+class C
+  def peek(addr); 42; end
+  def setup
+    @arr = [nil] * 16
+    range = [10, 20, 30, 40, 50, 60, 70, 80]
+    @arr[5] = range            # IntArray
+    @arr[10] = method(:peek)   # Method
+  end
+  def call_via(addr)
+    (@arr[addr][addr & 0xff]).to_i
+  end
+end
+
+c = C.new
+c.setup
+puts c.call_via(10)            # via Method peek_X → 42
+puts c.call_via(5)             # via IntArray range → range[5] = 60

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

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

data/vendor/spinel/test/method_introspection.rb

@@ -0,0 +1,24 @@
+# Test __method__, freeze/frozen?
+
+# __method__
+def greet
+  puts __method__  # greet
+end
+greet
+
+def calculate
+  puts __method__  # calculate
+end
+calculate
+
+# freeze / frozen? (AOT treats everything as frozen)
+s = "hello"
+s.freeze
+puts s           # hello
+puts s.frozen?   # true
+
+# Integer#freeze (no-op)
+n = 42
+puts n.frozen?   # true
+
+puts "done"

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

@@ -0,0 +1,6 @@
+greet
+calculate
+hello
+true
+true
+done

data/vendor/spinel/test/method_param_unify_to_poly.rb

@@ -0,0 +1,40 @@
+# Disagreeing call-site types for the same parameter need to widen
+# to `poly`. Pre-fix, `scan_new_calls` (obj-recv) and
+# `scan_cls_method_calls` (self-call inside the same class) both
+# only widened FROM "int": once the first non-int call site set the
+# param type, subsequent disagreeing calls were silently accepted
+# and the C compiler rejected the eventual mismatched call.
+#
+# Once the param widens to `poly`, the int / pointer / etc. arguments
+# at the call sites need to be boxed via `sp_box_*`. That boxing
+# branch was also missing from `compile_typed_call_args`, so even
+# after unify produced "poly", the call sites still passed raw
+# mrb_int / pointers to a sp_RbVal-typed parameter.
+
+class CPU
+  def feed(x, val)
+    val
+  end
+  # Self-call (no receiver). Lands in scan_cls_method_calls.
+  def boot
+    feed("hello", 1)
+    feed(20, 2)
+    feed("world", 3)
+  end
+end
+
+class User
+  def initialize(cpu)
+    @cpu = cpu
+  end
+  # Obj-recv call. Lands in scan_new_calls' obj branch.
+  def reset
+    @cpu.feed(100, 10)
+    @cpu.feed("via_user", 20)
+    @cpu.feed(500, 30)
+  end
+end
+
+cpu = CPU.new
+puts cpu.boot
+puts User.new(cpu).reset

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

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

data/vendor/spinel/test/misc.rb

@@ -0,0 +1,49 @@
+# Test miscellaneous features: is_a?, respond_to?, String <<, Array#reduce, upto/downto
+
+# String << (append/concat mutating)
+s = "Hello"
+s << ", World"
+puts s  # Hello, World
+
+# Array#reduce / inject
+arr = (1..5).to_a
+total = 0
+arr.each do |x|
+  total += x
+end
+puts total  # 15
+
+# upto / downto
+count = 0
+1.upto(5) do |i|
+  count += i
+end
+puts count  # 15
+
+count2 = 0
+5.downto(1) do |i|
+  count2 += i
+end
+puts count2  # 15
+
+# abs on negative
+puts (-42).abs  # 42
+
+# Multiple return (via array)
+def min_max(arr)
+  mn = arr[0]
+  mx = arr[0]
+  arr.each do |x|
+    if x < mn
+      mn = x
+    end
+    if x > mx
+      mx = x
+    end
+  end
+  puts mn
+  puts mx
+end
+
+data = (1..10).to_a
+min_max(data)  # 1, 10

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

@@ -0,0 +1,7 @@
+Hello, World
+15
+15
+15
+42
+1
+10

data/vendor/spinel/test/mixin.rb

@@ -0,0 +1,54 @@
+# Test include (mixin)
+
+module Printable
+  def to_str
+    "Printable"
+  end
+
+  def print_info
+    puts to_str
+  end
+end
+
+module Measurable
+  def measure
+    42
+  end
+end
+
+class Widget
+  include Printable
+  include Measurable
+
+  def initialize(name)
+    @name = name
+  end
+
+  def name
+    @name
+  end
+
+  def to_str
+    @name
+  end
+end
+
+w = Widget.new("button")
+puts w.name         # button
+w.print_info        # button (uses Widget#to_str, not Printable#to_str)
+puts w.measure      # 42 (from Measurable)
+
+class Gadget
+  include Printable
+
+  def initialize(label)
+    @label = label
+  end
+
+  def label
+    @label
+  end
+end
+
+g = Gadget.new("dial")
+g.print_info        # Printable (uses Printable#to_str since Gadget doesn't override)

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

@@ -0,0 +1,4 @@
+button
+button
+42
+Printable