rubyduino 0.1.1

data/vendor/spinel/test/module_acc_dispatch_param_box.rb

@@ -0,0 +1,46 @@
+# Issue #314 follow-up: `Mod.accessor.method(args)` (the
+# module-singleton-accessor dispatch from #126/#304) emitted
+# call-site args with raw `compile_expr` (no boxing). When the
+# resolved candidate's per-arg ptype was widened to `poly` (e.g.
+# via #304's cross-class unification), but the caller passed an
+# int/string at the specific call site, the C arg type didn't
+# match the ptype slot — Wint-conversion / hard
+# incompatible-pointer-conversion.
+#
+# Fix: in compile_call_expr's module-accessor branch, look up
+# the resolved candidate's ptypes and box each arg through
+# box_expr_to_poly when the target ptype is poly.
+#
+# Companion: scan_new_calls' #304 widening also gained a
+# parallel branch for module candidates (`<Mod>_cls_<m>` stored
+# in @meth_*) so the per-class unify reaches them.
+#
+# Surfaced via Roundhouse's `ActiveRecord.adapter.update(table,
+# @id, attrs)` — `@id` widened to poly across heterogeneous
+# subclasses, but the call site emitted `lv_id` (sp_RbVal) into
+# `InMemoryAdapter.update`'s pre-widening `mrb_int lv_id` slot.
+
+module Backend
+  class << self
+    attr_accessor :db
+  end
+end
+
+module Storage
+  module_function
+  def fetch(id)
+    # Just round-trip the id through to_s + length so the
+    # method body works for both int and String inputs.
+    id.to_s.length
+  end
+end
+
+Backend.db = Storage
+
+# Two call sites with different types — without #304 widening
+# reaching the module candidate, only the first caller's type
+# pinned the ptype; the second hit a C arg-type mismatch. With
+# the widening + boxing fix, the ptype unifies to poly and both
+# call sites box their arg through sp_box_int / sp_box_str.
+puts Backend.db.fetch(42)          # 2
+puts Backend.db.fetch("alpha")     # 5

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

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

data/vendor/spinel/test/module_class_new.rb

@@ -0,0 +1,17 @@
+# Test: class defined inside module and instantiated through M::C.new
+
+module M
+  class C
+    def initialize
+      puts "init"
+    end
+
+    def step
+      puts "step"
+    end
+  end
+end
+
+puts "start"
+obj = M::C.new
+obj.step

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

@@ -0,0 +1,3 @@
+start
+init
+step

data/vendor/spinel/test/module_cls_method_string_return.rb

@@ -0,0 +1,53 @@
+# Issue #127: a module-level singleton method (`module M; def self.X; ... end; end`)
+# whose body returns a non-int value used to be typed as `mrb_int` at every
+# call site. Capturing to a local emitted `mrb_int = const char *` (compile
+# error under -Werror); inline `puts M.X` compiled but printed the pointer
+# as an integer. The class form (same shape inside `class C`) already worked.
+# Fix is in `infer_constant_recv_type`: walk `@meth_return_types` for
+# `<Module>_cls_<method>` the same way the class branch walks `@cls_cmeth_returns`.
+
+# 1. Module + def self + String return + local capture — the failing shape.
+module M1
+  def self.greet
+    "hello"
+  end
+end
+
+s = M1.greet
+puts s                              # hello
+
+# 2. Module + def self + String return + inline puts — same root, different consumer.
+module M2
+  def self.greet
+    "world"
+  end
+end
+
+puts M2.greet                       # world
+
+# 3. Module + def self + Float return — non-int isn't string-specific.
+module M3
+  def self.pi
+    3.14
+  end
+end
+
+puts M3.pi                          # 3.14
+
+# 4. Class + def self + String return — the path that already worked. Regression guard.
+class C1
+  def self.greet
+    "from class"
+  end
+end
+
+t = C1.greet
+puts t                              # from class
+
+# 5. Top-level def returning String — separate inference path. Regression guard.
+def top_greet
+  "top"
+end
+
+u = top_greet
+puts u                              # top

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

@@ -0,0 +1,5 @@
+hello
+world
+3.14
+from class
+top

data/vendor/spinel/test/module_const_array_widen.rb

@@ -0,0 +1,36 @@
+# Issue #333: a module-level array constant initialized as an empty
+# literal (`LOG = []`) was typed as `sp_IntArray *`, regardless of
+# how it was used. A later `LOG << some_hash` then emitted
+# `sp_IntArray_push(cst_M_LOG, hash_ptr)`, mistyping the pointer as
+# mrb_int.
+#
+# Fix: extend the existing `refine_module_ivar_types` pass (which
+# already handled `@slots = {}` shape per #303) to also walk
+# `ConstantWriteNode` declarations like `LOG = []`. The companion
+# scanner `scan_module_const_writes` walks the module's class
+# methods for `LOG << v` / `LOG[k] = v` / `LOG.push(v)` shapes
+# rooted at a `ConstantReadNode` receiver. Body locals (`entry =
+# {...}; LOG << entry`) are also declared in the temporary scope so
+# `infer_type` resolves the pushed value's actual hash/obj type
+# instead of the int default.
+#
+# Surfaced via Roundhouse's `module Broadcasts; LOG = []; ... LOG <<
+# entry` pattern.
+
+module Broadcasts
+  module_function
+  LOG = []
+
+  def record(action)
+    entry = { action: action, target: "x" }
+    LOG << entry
+  end
+
+  def size
+    LOG.length
+  end
+end
+
+Broadcasts.record(:append)
+Broadcasts.record(:replace)
+puts Broadcasts.size           # 2

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

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

data/vendor/spinel/test/module_dispatch_param_widen.rb

@@ -0,0 +1,55 @@
+# Issue #304: module-dispatch ternary call sites
+# (`Disp.adapter.method(args)` where Disp.adapter resolves to N
+# candidate classes via the module-singleton-accessor table) used
+# to leave the candidates' class-method params at their pre-widen
+# narrow type even when the only caller passed a poly value. The
+# emitted ternary would type-mismatch each arm.
+#
+# Two fixes: (1) module_sentinel now distinguishes class candidates
+# (was returning 0 for class names looked up against the module
+# table only — every ternary arm ended up testing `slot == 0` and
+# the dispatch always picked the first candidate); (2) scan_new_calls
+# walks the `Disp.adapter.update(@id)` chain shape and unifies the
+# args' types into every candidate's `@cls_cmeth_ptypes`.
+#
+# Sister to #207 / #286 / #287 — same family of "widening must
+# propagate across the dispatch path."
+
+class A
+  def self.update(id)
+    id
+  end
+end
+
+class B
+  def self.update(id)
+    id
+  end
+end
+
+module Disp
+  class << self
+    attr_accessor :adapter
+  end
+end
+
+class C
+  def initialize
+    @id = 0
+  end
+  def write_str(s); @id = s; end   # widens @id to poly per #247
+  def save
+    Disp.adapter.update(@id)         # ternary-dispatched: poly arg
+  end
+end
+
+if ARGV.length > 0
+  Disp.adapter = A
+else
+  Disp.adapter = B
+end
+
+c = C.new
+c.write_str("hi")
+c.save                              # no output expected; just compile
+puts "ok"

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

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

data/vendor/spinel/test/module_function_namespace.rb

@@ -0,0 +1,58 @@
+# `module_function` in a module body installs the subsequent
+# `def name` as both an instance method (for include-mixin)
+# and a class method (`Mod.name`). Spinel only models the
+# class-method form here.
+#
+# The namespace-resolution bug surfaces independently of
+# `module_function`: any method body inside a module needs
+# `current_lexical_scope_name` set so that bare class refs
+# (`Box.new`) walk up via `resolve_const_read_name` to find
+# the qualified `Outer_Box`.
+#
+# Both fixes ride together: register `def name` after
+# `module_function` as `Mod_cls_name`, and pin
+# `@current_method_name` while iterating top-level methods so
+# the body's class-ref lookups peel `<Mod>_cls_<m>` correctly.
+
+module Outer
+  module Helper
+    module_function
+    def small;  [1, 2, 3]; end
+    def medium; [4, 5, 6, 7]; end
+  end
+
+  class Conf
+    def initialize(flag)
+      @flag = flag
+      @arr = []
+      @arr << 0    # force heap layout (sp_Outer_Conf *)
+    end
+    attr_reader :flag
+  end
+
+  class Box
+    def initialize(conf)
+      @c = conf
+      @arr = []
+      @arr << 0
+    end
+    attr_reader :c
+  end
+
+  module Builder
+    # `def self.X` form — the bare `Box.new` inside walks the
+    # lexical scope to resolve `Outer_Box`.
+    def self.make(conf)
+      Box.new(conf)
+    end
+  end
+end
+
+# module_function dispatch.
+puts Outer::Helper.small.length    # 3
+puts Outer::Helper.medium.length   # 4
+
+# Module class method body that references a sibling class
+# bare-named — used to fail with "unknown type name 'sp_Box'".
+b = Outer::Builder.make(Outer::Conf.new(true))
+puts b.c.flag                       # true

data/vendor/spinel/test/module_ivar_hash.rb

@@ -0,0 +1,61 @@
+# Issue #303: a module ivar initialized to an empty hash literal
+# (`@slots = {}`) used to freeze its inferred type as `str_int_hash`
+# (the empty-hash default) even when the module's class methods
+# wrote a sym → string mapping into it. Result: the storage decl
+# said `sp_StrIntHash *` but every `set` / `get` site emitted
+# typed-mismatched calls (sym key into string-key hash, string
+# value into int-value hash).
+#
+# Fix: a refinement pass in generate_code (after param inference
+# stabilizes) walks each module's class-method bodies for
+# `@<iname>[k] = v` writes and picks the most specific hash shape
+# from the observed key + value types. Same idea for arrays via
+# `@<iname> << v` / `@<iname>.push(v)`.
+
+module M
+  @slots = {}
+
+  def self.set(k, v)
+    @slots[k] = v
+    nil
+  end
+
+  def self.get(k)
+    @slots[k] || ""
+  end
+
+  def self.size
+    @slots.length
+  end
+end
+
+M.set(:foo, "bar")
+M.set(:baz, "qux")
+puts M.get(:foo)         # bar
+puts M.get(:baz)         # qux
+puts M.get(:missing)     # (empty default)
+puts M.size              # 2
+
+# Empty array literal — same refinement applies via `<<` writes.
+module N
+  @items = []
+
+  def self.add(s)
+    @items << s
+  end
+
+  def self.read(i)
+    @items[i]
+  end
+
+  def self.size
+    @items.length
+  end
+end
+
+N.add("alpha")
+N.add("beta")
+N.add("gamma")
+puts N.size              # 3
+puts N.read(0)           # alpha
+puts N.read(2)           # gamma

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

@@ -0,0 +1,7 @@
+bar
+qux
+
+2
+3
+alpha
+gamma

data/vendor/spinel/test/module_relative_constant_path.rb

@@ -0,0 +1,26 @@
+# Test: relative ConstantPath class/module definitions inside a module.
+
+module M
+  class A
+  end
+
+  class A::B
+    def value
+      10
+    end
+  end
+
+  module N
+  end
+
+  module N::P
+    class C
+      def value
+        30
+      end
+    end
+  end
+end
+
+puts M::A::B.new.value
+puts M::N::P::C.new.value

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

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

data/vendor/spinel/test/module_singleton_accessor.rb

@@ -0,0 +1,65 @@
+# Issue #126 Stage 1: a module value assigned to a module-level
+# `class << self; attr_accessor :x; end` accessor used to read back
+# as 0. The whole `module ... class << self; ... end ... end`
+# block was silently dropped (no `PM_SINGLETON_CLASS_NODE` parser
+# support), and the entire bare identifier path for module names as
+# rvalues didn't exist.
+#
+# Stage 1 handles the static-fold case: a single assignment of a
+# constant-resolvable RHS (typically a module/class name) is folded
+# at codegen, and read sites substitute the resolved constant in a
+# `<recv>.<method>` chain. Polymorphic / multi-write slots fall
+# through to the un-folded path (Stage 2).
+
+# 1. Module assigned to a module-level singleton accessor — the
+#    issue's exact reproducer.
+module SqliteAdapter
+  def self.answer
+    42
+  end
+end
+
+module ActiveRecord
+  class << self
+    attr_accessor :adapter
+  end
+end
+
+ActiveRecord.adapter = SqliteAdapter
+puts ActiveRecord.adapter.answer    # 42
+
+# 2. The string-returning downstream method that surfaced the type
+#    mismatch in the issue. Verifies the chain return type
+#    threads through correctly (string, not int).
+module Greeter
+  def self.greet
+    "hello"
+  end
+end
+
+module Service
+  class << self
+    attr_accessor :greeter
+  end
+end
+
+Service.greeter = Greeter
+puts Service.greeter.greet          # hello
+
+# 3. Class assigned to a module-level singleton accessor — same
+#    constant-fold path applies to user-defined classes as long as
+#    the reachable methods on the resolved name are class methods.
+class CounterClass
+  def self.count
+    7
+  end
+end
+
+module Holder
+  class << self
+    attr_accessor :counter
+  end
+end
+
+Holder.counter = CounterClass
+puts Holder.counter.count           # 7

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

@@ -0,0 +1,3 @@
+42
+hello
+7

data/vendor/spinel/test/module_singleton_accessor_poly.rb

@@ -0,0 +1,62 @@
+# Issue #126 Stage 2: a module-level singleton accessor that's
+# written with two or more distinct module/class names goes through
+# a runtime sentinel switch instead of being constant-folded.
+# `resolve_module_singleton_accessors` records the union of all
+# constant RHSes; the write site emits `slot = SP_MOD_<X>;` (using
+# the module's `module_sentinel` integer); the chain dispatch
+# emits an if-cascade over the slot.
+
+# 1. Two adapters reassigned — same shape as a Rails-style
+#    runtime adapter swap.
+module SqliteAdapter
+  def self.name; "sqlite"; end
+end
+
+module PgAdapter
+  def self.name; "postgres"; end
+end
+
+module ActiveRecord
+  class << self
+    attr_accessor :adapter
+  end
+end
+
+ActiveRecord.adapter = SqliteAdapter
+puts ActiveRecord.adapter.name      # sqlite
+
+ActiveRecord.adapter = PgAdapter
+puts ActiveRecord.adapter.name      # postgres
+
+ActiveRecord.adapter = SqliteAdapter
+puts ActiveRecord.adapter.name      # sqlite
+
+# 2. Three candidates with conditional assignment driving which
+#    sentinel ends up in the slot.
+module A
+  def self.tag; "A"; end
+end
+module B
+  def self.tag; "B"; end
+end
+module C
+  def self.tag; "C"; end
+end
+
+module Pick
+  class << self
+    attr_accessor :slot
+  end
+end
+
+[1, 2, 3, 1].each do |n|
+  if n == 1
+    Pick.slot = A
+  elsif n == 2
+    Pick.slot = B
+  else
+    Pick.slot = C
+  end
+  puts Pick.slot.tag
+end
+# A B C A

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

@@ -0,0 +1,7 @@
+sqlite
+postgres
+sqlite
+A
+B
+C
+A

data/vendor/spinel/test/multi_arg_block_call.rb

@@ -0,0 +1,56 @@
+# Multi-argument `block.call(a, b, ...)` on the proc-object path.
+#
+# Pre-fix, `compile_proc_literal` hardcoded the lambda's signature
+# as `static mrb_int <fn>(void *_cap, mrb_int lv_<bp>)` — a single
+# `mrb_int` slot — and the call site always lowered to
+# `sp_proc_call(lv_<rname>, <arg0>)`, so any second/third positional
+# arg was silently dropped.
+#
+# Fix collects every block param at proc-literal time and emits
+# `(void *_cap, mrb_int lv_<bp1>, mrb_int lv_<bp2>, ...)`, then
+# dispatches the call site to `sp_proc_call_N` (added to the
+# runtime: cast the stored function pointer to the matching N-arg
+# signature and invoke).
+#
+# Out of scope: arity-mismatched calls (`proc { |a| } .call(1, 2)`)
+# stay UB on the C side. Spinel's static dispatch enforces match in
+# the test cases below.
+
+# 1. Basic: forwarded `&block` invoked with 2 args.
+class App
+  def run(&block)
+    block.call(10, 20)
+  end
+end
+
+App.new.run { |a, b| puts a + b }
+
+# 2. 3-arg block.call.
+class Wider
+  def go(&block)
+    block.call(1, 2, 3)
+  end
+end
+
+Wider.new.go { |x, y, z| puts x + y + z }
+
+# 3. Same proc invoked twice with different concrete args.
+class Twice
+  def both(&block)
+    block.call(100, 1)
+    block.call(200, 2)
+  end
+end
+
+Twice.new.both { |a, b| puts a * b }
+
+# 4. 0-param block called with one arg. Extra arg is silently dropped
+# (matches CRuby semantics). Exercises the `_unused` fallback path
+# that the multi-param refactor must leave intact.
+class Drop
+  def go(&block)
+    block.call(99)
+  end
+end
+
+Drop.new.go { puts "called" }

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

@@ -0,0 +1,5 @@
+30
+6
+100
+400
+called

data/vendor/spinel/test/multi_arg_yield.rb

@@ -0,0 +1,70 @@
+# Multi-argument `yield` in a method body (issue #98).
+#
+# Pre-fix, every `yield` lowered against a single-arg `_block`
+# function pointer (`void (*_block)(mrb_int, void*)`), so any
+# `yield x, y[, ...]` emitted `_block(x, y, _benv)` against the
+# wrong signature and `cc` rejected it. The yield-inlined path
+# (`compile_stmt_with_block`'s YieldNode branch) had a parallel
+# bug: smaller-arity yields in a multi-arity method only assigned
+# the args that were passed, so unset block-local C vars leaked
+# whatever value the previous yield had set.
+#
+# Fix scans each yield-using method's body for the max yield arity
+# and threads that count through `yield_params_suffix*` (so the
+# function-pointer signature gets N `mrb_int` slots) and through
+# `compile_yield_stmt` (function-pointer-path emit). The inlined
+# path is fixed by zeroing remaining `lv_<bp>` slots after each
+# yield's args are assigned.
+
+# 1. Basic 2-arg yield.
+def add_pair
+  yield 1, 2
+end
+
+add_pair { |a, b| puts a + b }
+
+# 2. 3-arg yield with block returning to a local.
+def sum_triple
+  yield 10, 20, 30
+end
+
+sum_triple { |a, b, c| puts a + b + c }
+
+# 3. Mixed-arity yields in the same method. The smaller yields
+#    must not leak values from the larger ones. Pre-fix, the second
+#    yield's `b` would carry 999 from the first yield; post-fix it's
+#    0. Test uses `b.to_i` so the CRuby-side `nil` and Spinel-side
+#    mrb_int 0 both produce the same numeric value.
+def mixed_yield
+  yield 100, 999
+  yield 200
+end
+
+total = 0
+mixed_yield { |a, b| total = total + a + b.to_i }
+puts total
+
+# 4. Multi-arg yield from a class instance method.
+class Dispatcher
+  def emit
+    yield 100, 200
+    yield 300, 400
+  end
+end
+
+Dispatcher.new.emit { |x, y| puts x + y }
+
+# 5. Three different yield arities in one method. Max-arity detection
+#    must find 3 so the function-pointer signature has 3 slots; the
+#    smaller yields must zero-pad their unused slots. Test uses
+#    `b.to_i` / `c.to_i` so CRuby's `nil` for missing block params
+#    and Spinel's `mrb_int 0` produce the same numeric sum.
+def varied
+  yield 1, 2, 3
+  yield 10, 20
+  yield 100
+end
+
+acc = 0
+varied { |a, b, c| acc = acc + a + b.to_i + c.to_i }
+puts acc

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

@@ -0,0 +1,6 @@
+3
+60
+1299
+300
+700
+136