rubyduino 0.1.1

data/vendor/spinel/test/poly_str_append.rb

@@ -0,0 +1,40 @@
+# Issue #313: a poly-typed value flowing into `String#<<` (mutable_str)
+# used to emit `sp_String_append(io, sp_RbVal_value)` directly, which
+# C-rejects (`const char *` parameter vs `sp_RbVal` argument). The
+# canonical shape: a module-level method that returns
+# `@hash[k] || ""` over a heterogeneously-valued hash has return type
+# `sp_RbVal` per #303, and `io << M.get(:t)` then trips the bug.
+#
+# Fix: at the `mutable_str << poly` codegen site (both expression-
+# and statement-context emitters), wrap the arg in sp_poly_to_s
+# before calling sp_String_append. sp_poly_to_s coerces every tag —
+# strings pass through, ints stringify, sym/nil/etc fall through.
+#
+# Sister fix to #303 — that one made the *hash* poly when written
+# heterogeneously; this one handles the *read path* flowing into a
+# narrow callee.
+
+module M
+  @data = {}
+
+  def self.set(k, v)
+    @data[k] = v
+  end
+
+  def self.get(k)
+    @data[k] || ""
+  end
+end
+
+# Mixed value types force the hash to be inferred as poly per #303.
+M.set(:n, 42)
+M.set(:t, "hello")
+
+io = String.new
+io << M.get(:t)
+puts io                # hello
+
+# Also exercise the expression-context << path via chained append.
+io2 = String.new
+(io2 << M.get(:t)) << M.get(:t)
+puts io2               # hellohello

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

@@ -0,0 +1,2 @@
+hello
+hellohello

data/vendor/spinel/test/poly_to_i_via_str_poly_hash.rb

@@ -0,0 +1,19 @@
+# `compile_poly_method_call` lacked a `to_i` arm: `(poly).to_i` fell
+# through to `emit_poly_dispatch` → `emit_poly_builtin_dispatch`,
+# which only handles `[]` / `length` / `size`. The dispatched
+# result temp stayed at its `0` default, so any `.to_i` on a poly-
+# typed receiver returned 0 instead of unboxing the int payload.
+#
+# Repro: heterogeneous Hash returns a poly value; `.to_i` on that.
+
+class C
+  def initialize
+    @h = { "a" => 42, "b" => "hello" }
+  end
+  def at(k)
+    (@h[k]).to_i
+  end
+end
+
+c = C.new
+puts c.at("a")

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

@@ -0,0 +1 @@
+42

data/vendor/spinel/test/post_execution.rb

@@ -0,0 +1,17 @@
+# PostExecutionNode -- `END { ... }`.
+#
+# CRuby runs END blocks at program exit in REVERSE order of
+# registration. Spinel emits each END body as a static C function
+# and registers it via atexit() during main() startup.
+
+puts "middle"
+
+END {
+  puts "last-1"
+}
+
+END {
+  puts "last-2"  # registered second; runs first per atexit semantics
+}
+
+puts "before-end"

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

@@ -0,0 +1,4 @@
+middle
+before-end
+last-2
+last-1

data/vendor/spinel/test/pre_execution.rb

@@ -0,0 +1,18 @@
+# PreExecutionNode -- `BEGIN { ... }`.
+#
+# CRuby runs all BEGIN blocks in source order, BEFORE any other
+# top-level statements, regardless of where they appear in the file.
+# Spinel hoists each BEGIN body to the top of main() in source-encounter
+# order during a pre-pass.
+
+puts "middle"
+
+BEGIN {
+  puts "first"
+}
+
+BEGIN {
+  puts "first-2"
+}
+
+puts "last"

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

@@ -0,0 +1,4 @@
+first
+first-2
+middle
+last

data/vendor/spinel/test/primitive_method_shadow.rb

@@ -0,0 +1,48 @@
+# Issue #302: a user-defined class method whose name matches a
+# primitive method (e.g. `String#index`) used to shadow the primitive
+# during caller-side type inference. `def find_bracket(s); s.index("[");
+# end` walked s's body, found `index` is defined on user-class
+# StringIndexer, and committed s's param type to obj_StringIndexer —
+# even though the call site passed a string and `index` is a primitive
+# String method.
+#
+# Fix: extend `called_methods_only_on_container_builtins` to also
+# accept the methods shared across String / Hash / Integer, so
+# `def index` / `def show` / `def create` etc. on user classes can
+# coexist with primitive callers.
+
+class StringIndexer
+  def index(needle, start = 0)
+    "from-StringIndexer"
+  end
+end
+
+def find_bracket(s)
+  s.index("[")
+end
+puts find_bracket("hello[world]")    # 5
+
+# String method that's also defined on a controller-shaped class.
+class ArticlesController
+  def show
+    "ArticlesController#show"
+  end
+end
+
+def first_or_default(s)
+  s.start_with?("/")    # String#start_with? — should not be shadowed
+end
+puts first_or_default("/articles")    # true
+puts first_or_default("articles")     # false
+
+# Hash-shared `keys` shouldn't pull a user-class param into obj_X.
+class KeyHolder
+  def keys
+    ["alpha", "beta"]
+  end
+end
+
+def count_keys(h)
+  h.keys.length
+end
+puts count_keys({a: 1, b: 2, c: 3})   # 3

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

@@ -0,0 +1,4 @@
+5
+true
+false
+3

data/vendor/spinel/test/primitive_method_shadow_int_recv.rb

@@ -0,0 +1,47 @@
+# Issue #305: follow-up to #302's primitive-shadow fix.
+#
+# #302 stopped the body-side param-type inference from committing
+# a param to a user class when the called methods are also defined
+# on a primitive type (`def find_bracket(s); s.index("[")` no
+# longer pins `s` as obj_StringIndexer when the only call site
+# passes a string literal).
+#
+# But the *emit-time* int-recv fallback (`compile_int_class_fallback
+# _expr`) still walked every user class and picked the first one
+# whose method-name matched. When the receiver flowed in as
+# `mrb_int` (e.g. unpinned param, IntArray-of-pointer fallback),
+# the fallback would route `raw_key.index("[")` to
+# `ArticlesController#index` regardless of the receiver's actual
+# nature.
+#
+# Fix: when `mname` is a primitive-shared method AND any user class
+# defines it, refuse the int-to-class cast and let the unresolved-
+# call diagnostic fire. The shape happens to compile to a `0`
+# placeholder for the call's result — that's the existing fallback
+# contract for genuinely unresolvable calls; it's vastly better
+# than the silent miscompile that picked a random user class.
+
+class ArticlesController
+  def index
+    "controller-action"
+  end
+end
+
+# A param with no upstream pinning. Spinel defaults the param to
+# mrb_int when no call site supplies a non-int. Without the fix,
+# the body's `.index` call hits compile_int_class_fallback_expr,
+# which walks the user-class table and picks ArticlesController
+# (the first class defining `def index`), emitting a typed cast
+# `((sp_ArticlesController *)raw_key)->index_get(...)` that is
+# either a C-compile error or a silent miscompile. With the fix,
+# the int-recv fallback refuses primitive-shared method names and
+# the call lowers to the unresolved-call placeholder (literal 0).
+#
+# We don't call `find_first` from Ruby — defining it is enough for
+# spinel to emit and type-check the body, and avoiding the call
+# keeps MRI happy (Integer#index doesn't exist).
+def find_first(raw_key)
+  raw_key.index("[")
+end
+
+puts "compiled-cleanly"

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

@@ -0,0 +1 @@
+compiled-cleanly

data/vendor/spinel/test/proc.rb

@@ -0,0 +1,42 @@
+# Test &block, Proc.new, proc, Proc#call
+
+# &block parameter — receive block as Proc
+def apply(x, &block)
+  block.call(x)
+end
+
+puts apply(5) { |n| n * 2 }  # 10
+
+# Store block in variable
+def make_doubler
+  proc { |n| n * 2 }
+end
+
+doubler = make_doubler
+puts doubler.call(7)  # 14
+
+# Proc.new
+adder = Proc.new { |n| n + 10 }
+puts adder.call(5)  # 15
+
+# Pass proc to method
+def transform(x, fn)
+  fn.call(x)
+end
+
+puts transform(3, doubler)  # 6
+
+# Method with &block forwarding
+def with_logging(x, &blk)
+  puts "before"
+  result = blk.call(x)
+  puts "after"
+  result
+end
+
+with_logging(42) do |n|
+  puts n
+end
+# before, 42, after
+
+puts "done"

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

@@ -0,0 +1,8 @@
+10
+14
+15
+6
+before
+42
+after
+done

data/vendor/spinel/test/proc_closure.rb

@@ -0,0 +1,44 @@
+# Regression test for proc closures (capturing outer locals).
+# Phase 2 of proc closure recovery: captures via heap cells + per-proc
+# capture struct, mirroring the Fiber capture mechanism.
+
+# Escaping closure with mutation
+def make_counter
+  n = 0
+  proc { n = n + 1; n }
+end
+
+c = make_counter
+puts c.call
+puts c.call
+puts c.call
+
+# Read-only escaping closure
+def make_adder(base)
+  proc { |n| n + base }
+end
+add5 = make_adder(5)
+puts add5.call(3)
+puts add5.call(10)
+
+# Non-escaping closure with multiple captures and mutation
+def apply_twice(x)
+  total = 0
+  count = 0
+  doubler = proc { |n| total = total + n * 2; count = count + 1 }
+  doubler.call(x)
+  doubler.call(x)
+  puts total
+  puts count
+end
+apply_twice(5)
+
+# Two procs capturing the same local — mutations must propagate
+def make_pair
+  shared = 100
+  inc = proc { shared = shared + 1 }
+  inc.call
+  inc.call
+  shared
+end
+puts make_pair

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

@@ -0,0 +1,8 @@
+1
+2
+3
+8
+15
+20
+2
+102

data/vendor/spinel/test/proc_hash_value.rb

@@ -0,0 +1,27 @@
+# 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/proc_hash_value.rb.expected

@@ -0,0 +1 @@
+ok

data/vendor/spinel/test/ptr_array.rb

@@ -0,0 +1,107 @@
+# Pointer-array (`<obj>_ptr_array`) coverage — typed-obj `[]` map,
+# value-class instances in array literals (and via `push`/`<<`),
+# and slot widening from `[nil] * N` writes. Was four tests; the
+# only class-name collisions were Foo (same definition reused
+# across the two value-class sections — kept once) and Bag (two
+# unrelated shapes — section 1's Bag renamed to MapBag).
+
+# === Section 1: ptr_array map ===
+# `compile_map_expr` had no `ptr_array` recv branch — `.map { ... }`
+# on a typed `obj_X[]` ivar/local fell through to the trailing
+# `"0"` placeholder.
+class Box
+  attr_reader :v
+  def initialize(v); @v = v; end
+end
+
+class MapBag
+  def initialize
+    @items = [Box.new(1), Box.new(2), Box.new(3)]
+  end
+  def doubled
+    @items.map { |b| b.v * 2 }
+  end
+  def names
+    @items.map { |b| "v=#{b.v}" }
+  end
+end
+
+mbag = MapBag.new
+mints = mbag.doubled
+puts mints.length    # 3
+puts mints[0]        # 2
+puts mints[2]        # 6
+mnames = mbag.names
+puts mnames.length   # 3
+puts mnames[0]       # v=1
+puts mnames[2]       # v=3
+
+# === Section 2 + 3: value-class instances in ptr_array (literal + push) ===
+# A class with no attr_writers / no mutating methods would normally
+# be value-type'd, but its instances landing in an array literal or
+# being push'd into one must demote it to a heap-allocated obj so
+# `sp_PtrArray_push`'s `void *` arg type-checks. PR #87 covered the
+# literal case; #91 (follow-up) extended it to push / <<.
+class Foo
+  def initialize(x); @x = x; end
+  attr_reader :x
+end
+
+# Literal form.
+flit = [Foo.new(1), Foo.new(2), Foo.new(3)]
+puts flit.length
+flit.each { |f| puts f.x }
+
+# `push` form.
+fpush = []
+fpush.push(Foo.new(1))
+fpush.push(Foo.new(2))
+puts fpush.length
+fpush.each { |f| puts f.x }
+
+# `<<` form (same code path through the parser).
+fsh = []
+fsh << Foo.new(10)
+fsh << Foo.new(20)
+fsh << Foo.new(30)
+puts fsh.length
+fsh.each { |f| puts f.x }
+
+# === Section 4: ptr_array slot widening from [nil] * N ===
+# `@arr = [nil] * N` followed by `@arr[i] = obj` widens the slot
+# to `<obj>_ptr_array`. Without the widening, the slot stays at
+# the default IntArray and the object pointer write is truncated.
+class Item
+  def initialize(label)
+    @label = label
+    @history = [0]   # array ivar keeps Item off the value-type fast path
+  end
+  def visit
+    @history << @history.last + 1
+    @label
+  end
+  def visits
+    @history.length - 1
+  end
+end
+
+class Bag
+  def initialize
+    @slots = [nil] * 4
+    @slots[0] = Item.new("a")
+    @slots[1] = Item.new("b")
+    @slots[3] = Item.new("d")
+  end
+  attr_reader :slots
+  def visit_at(i)
+    @slots[i].visit
+  end
+end
+
+b = Bag.new
+puts b.visit_at(0)
+puts b.visit_at(1)
+puts b.visit_at(3)
+puts b.slots[0].visits   # 1
+puts b.slots[1].visits   # 1
+puts b.slots[3].visits   # 1

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

@@ -0,0 +1,23 @@
+3
+2
+6
+3
+v=1
+v=3
+3
+1
+2
+3
+2
+1
+2
+3
+10
+20
+30
+a
+b
+d
+1
+1
+1

data/vendor/spinel/test/range.rb

@@ -0,0 +1,130 @@
+# Range methods — first / last / include? / to_a / each, cover? /
+# min / max / count, Range#map, inclusive-vs-exclusive distinction,
+# step without block param. Was five separate tests; merged here.
+# No class collisions. The only top-level def (`classify` in the
+# inclusive/exclusive section) is unique within the file. Local
+# names use per-section prefixes where the original tests reused
+# generic names like `r`, `sum`, `i`.
+
+# === Basic Range methods ===
+r0 = (1..10)
+puts r0.first             # 1
+puts r0.last              # 10
+puts r0.include?(5)       # true
+puts r0.include?(11)      # false
+
+arr0 = r0.to_a
+puts arr0.length          # 10
+puts arr0.sum             # 55
+
+total = 0
+r0.each do |x|
+  total += x
+end
+puts total                # 55
+puts "done"
+
+# === cover? / min / max / count ===
+puts (1..10).cover?(5)
+puts (1..10).cover?(1)
+puts (1..10).cover?(10)
+puts (1..10).cover?(0)
+puts (1..10).cover?(11)
+puts (-5..5).cover?(0)
+puts (-5..5).cover?(-5)
+puts (-5..5).cover?(6)
+
+puts (1..10).min
+puts (1..10).max
+puts (-5..5).min
+puts (-5..5).max
+puts (100..200).min
+puts (100..200).max
+
+puts (1..10).count
+puts (1..1).count
+puts (-5..5).count
+puts (100..200).count
+
+puts (1...10).count
+puts (1...1).count
+puts (-5...5).count
+
+# === Range#map ===
+puts (0..3).map { |i| i * 10 }.length      # 4
+puts (0..3).map { |i| i * 10 }[2]          # 20
+puts (0...3).map { |i| i }.length          # 3
+puts (0...3).map { |i| i }[2]              # 2
+puts ((1..3).map { |i| "x#{i}" }.join(","))   # x1,x2,x3
+puts ((0...3).map { |i| i * 0.5 }.length)     # 3
+
+# === Inclusive vs exclusive (slicing / for-in / Range#to_a / case-when) ===
+ia = [10, 20, 30, 40, 50]
+puts ia[1..3].length      # 3 (inclusive)
+puts ia[1...3].length     # 2 (exclusive)
+puts ia[1...3][0]         # 20
+puts ia[1...3][1]         # 30
+
+sa = "a,b,c,d,e".split(",")
+puts sa[0..2].join(":")   # a:b:c
+puts sa[0...2].join(":")  # a:b
+
+fa = [1.5, 2.5, 3.5, 4.5]
+puts fa[0..2].length      # 3
+puts fa[0...2].length     # 2
+puts fa[0...3].sum        # 7.5
+
+s = "abcdef"
+puts s[1..3]              # bcd
+puts s[1...3]             # bc
+
+sum_inc = 0
+for ix in 1..3
+  sum_inc = sum_inc + ix
+end
+puts sum_inc              # 6
+
+sum_exc = 0
+for ix in 1...3
+  sum_exc = sum_exc + ix
+end
+puts sum_exc              # 3
+
+puts (1..3).to_a.length   # 3
+puts (1...3).to_a.length  # 2
+
+def classify(n)
+  case n
+  when 0...10 then "small"
+  when 10..99 then "medium"
+  else "large"
+  end
+end
+puts classify(5)
+puts classify(9)
+puts classify(10)
+puts classify(99)
+puts classify(100)
+
+# === Range#=== (case-when membership) ===
+puts (1..10) === 5      # true
+puts (1..10) === 1      # true
+puts (1..10) === 10     # true
+puts (1..10) === 0      # false
+puts (1..10) === 11     # false
+
+# === step without block param ===
+# `Integer#step` with a do-block that omits its parameter used a
+# synthesized `_i` index that wasn't declared. Two paramless `step`
+# blocks in the same function also redefined it.
+sum_step = 0
+1.step(10, 1) do
+  sum_step += 1
+end
+1.step(5, 1) do
+  sum_step += 10
+end
+1.step(5, 1) do
+  sum_step += 100
+end
+puts sum_step

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

@@ -0,0 +1,61 @@
+1
+10
+true
+false
+10
+55
+55
+done
+true
+true
+true
+false
+false
+true
+true
+false
+1
+10
+-5
+5
+100
+200
+10
+1
+11
+101
+9
+0
+10
+4
+20
+3
+2
+x1,x2,x3
+3
+3
+2
+20
+30
+a:b:c
+a:b
+3
+2
+7.5
+bcd
+bc
+6
+3
+3
+2
+small
+small
+medium
+medium
+large
+true
+true
+true
+false
+false
+560