rubyduino 0.1.1

data/vendor/spinel/test/ivar_float_array.rb

@@ -0,0 +1,59 @@
+# Regression: instance variables initialized via Array.new(n, FILL) must be
+# typed by inspecting the fill argument, not always returned as "int_array".
+#
+# infer_ivar_init_type's CallNode/"new" branch used to unconditionally return
+# "int_array" for Array.new(...). That mistyped class fields as the
+# containing class's pointer; pointer-type fills additionally lost their GC
+# scan function, which would let live elements be swept.
+#
+# We now check the fill type and use the appropriate typed array container
+# (FloatArray for float fills, StrArray for string, sym_array (IntArray
+# internally) for symbol, PtrArray for object/pointer fills).
+#
+# Use float values whose fractional part is non-zero so Spinel's float-puts
+# matches CRuby's.
+
+class Box
+  attr_accessor :nums
+  def initialize
+    @nums = Array.new(3, 0.5)
+  end
+end
+
+class SymHolder
+  attr_accessor :tags
+  def initialize
+    @tags = Array.new(2, :alpha)
+  end
+end
+
+class Marker
+  attr_accessor :id
+  def initialize(id)
+    @id = id
+  end
+end
+
+class ObjHolder
+  attr_accessor :marks
+  def initialize
+    @marks = Array.new(3, Marker.new(42))
+  end
+end
+
+b = Box.new
+puts b.nums[0]      # 0.5
+puts b.nums[1]      # 0.5
+puts b.nums[2]      # 0.5
+puts b.nums.length  # 3
+
+s = SymHolder.new
+puts s.tags[0]      # alpha
+puts s.tags[1]      # alpha
+puts s.tags.length  # 2
+
+m = ObjHolder.new
+puts m.marks[0].id  # 42
+puts m.marks[1].id  # 42  (Array.new(n, obj) shares the same obj)
+puts m.marks[2].id  # 42
+puts m.marks.length # 3

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

@@ -0,0 +1,11 @@
+0.5
+0.5
+0.5
+3
+alpha
+alpha
+2
+42
+42
+42
+3

data/vendor/spinel/test/ivar_op_assign_bitwise_and_shift.rb

@@ -0,0 +1,22 @@
+# Statement-form `@x OP= v` for the bitwise / shift / multiplicative
+# operators. The pre-fix codegen only handled `+=` and `-=`; every
+# other op-assign was silently dropped, so `@a &= 0x80` left @a
+# untouched. Walks all the operators that map onto C `OP=` directly.
+
+class C
+  attr_reader :a
+  def initialize; @a = 0xff; end
+  def m_amp; @a &= 0x80; end
+  def m_or;  @a |= 0x01; end
+  def m_xor; @a ^= 0xff; end
+  def m_lsh; @a <<= 1; end
+  def m_rsh; @a >>= 1; end
+  def m_mul; @a *= 2; end
+end
+
+c = C.new; c.m_amp; puts "amp: #{c.a}"
+c = C.new; c.m_or;  puts "or: #{c.a}"
+c = C.new; c.m_xor; puts "xor: #{c.a}"
+c = C.new; c.m_lsh; puts "lsh: #{c.a}"
+c = C.new; c.m_rsh; puts "rsh: #{c.a}"
+c = C.new; c.m_mul; puts "mul: #{c.a}"

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

@@ -0,0 +1,6 @@
+amp: 128
+or: 255
+xor: 0
+lsh: 510
+rsh: 127
+mul: 510

data/vendor/spinel/test/ivar_or_write_basic.rb

@@ -0,0 +1,57 @@
+class T
+  def initialize
+    @str = nil
+    @hits = 0
+    @marker = "init"
+  end
+
+  def cache
+    @str ||= compute
+  end
+
+  def compute
+    @hits += 1
+    "hello"
+  end
+
+  def get
+    @str
+  end
+
+  def hits
+    @hits
+  end
+end
+
+t = T.new
+puts t.get.nil? ? "nil-before" : "not-nil-before"
+puts t.cache
+puts t.get
+puts t.cache
+puts t.get
+puts "hits=#{t.hits}"
+
+class U
+  def initialize
+    @v = nil
+    @hits = 0
+    @log = []
+  end
+
+  def value
+    @v ||= 42
+  end
+
+  def hits
+    @hits
+  end
+
+  def log_size
+    @log.size
+  end
+end
+
+u = U.new
+puts u.value
+puts u.value
+puts u.value

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

@@ -0,0 +1,9 @@
+nil-before
+hello
+hello
+hello
+hello
+hits=1
+42
+42
+42

data/vendor/spinel/test/ivar_polymorphic.rb

@@ -0,0 +1,87 @@
+# Issue #130: instance variable assigned different definite-typed values
+# across methods used to either fail to compile (-Wint-conversion under
+# -Werror), silently coerce (Integer→Float when slot won inference as Float),
+# or segfault. Fix is in scan_ivars: when both writes are definite-literal
+# and types disagree, widen the slot to poly. Write sites then box every
+# concrete-typed RHS to sp_RbVal; read sites already use sp_poly_puts and
+# friends.
+#
+# Variant 3 of the issue (ternary RHS with mixed types in a single-write
+# slot) is a different root — the slot widens to "int" because IfNode
+# isn't a definite-literal — and is filed separately.
+
+# 1. String + Integer — variant 1 from the issue. Original symptom:
+#    -Wint-conversion warning, indeterminate runtime output.
+class C1
+  def set_int; @x = 42; end
+  def set_str; @x = "hello"; end
+  def show; puts @x; end
+end
+
+c1 = C1.new
+c1.set_int; c1.show                  # 42
+c1.set_str; c1.show                  # hello
+
+# 2. Integer + Float — variant 2. Original symptom: silent coercion;
+#    `42` printed as `42.0` because the slot won inference as Float.
+class C2
+  def set_int; @x = 42; end
+  def set_float; @x = 3.14; end
+  def show; puts @x; end
+end
+
+c2 = C2.new
+c2.set_int; c2.show                  # 42
+c2.set_float; c2.show                # 3.14
+
+# 3. String + Symbol — already widened to poly in pre-#130 inference but
+#    didn't compile because write sites weren't boxed. Pins the boxing fix.
+class C3
+  def set_str; @x = "hello"; end
+  def set_sym; @x = :world; end
+  def show; puts @x; end
+end
+
+c3 = C3.new
+c3.set_str; c3.show                  # hello
+c3.set_sym; c3.show                  # world
+
+# 4. Three concrete types in different methods — slot stays poly across
+#    each disagreement.
+class C4
+  def set_int; @x = 100; end
+  def set_str; @x = "txt"; end
+  def set_float; @x = 2.5; end
+  def show; puts @x; end
+end
+
+c4 = C4.new
+c4.set_int; c4.show                  # 100
+c4.set_str; c4.show                  # txt
+c4.set_float; c4.show                # 2.5
+
+# 5. Single-type ivar — regression guard. The pre-#130 happy path stays
+#    happy. No widening, slot stays mrb_int.
+class C5
+  def set; @x = 42; end
+  def show; puts @x; end
+end
+
+c5 = C5.new
+c5.set; c5.show                      # 42
+
+# 6. Initialize sets one type, another method sets another. Constructor
+#    body has its own ivar-write emit path (separate from the general
+#    InstanceVariableWriteNode case); this pins both paths box correctly.
+class C6
+  def initialize
+    @x = 42
+  end
+  def set_str; @x = "hello"; end
+  def show; puts @x; end
+end
+
+c6 = C6.new
+c6.show                              # 42
+c6.set_str
+c6.show                              # hello

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

@@ -0,0 +1,12 @@
+42
+hello
+42
+3.14
+hello
+world
+100
+txt
+2.5
+42
+42
+hello

data/vendor/spinel/test/ivar_ternary_mixed.rb

@@ -0,0 +1,108 @@
+# Issue #131: a single-write ivar whose RHS is a ternary (or if-as-
+# expression) with branches of different concrete types used to type
+# the slot from `infer_ivar_init_type`'s default fallback ("int") and
+# emit a raw `(cond ? then : else)` C ternary into a typed slot —
+# pointer/integer mismatch warning, segfault at runtime.
+#
+# Fix: `infer_ivar_init_type` recurses into IfNode branches with strict
+# unification (no "int is default" escape hatch); `box_expr_to_poly`
+# always per-branch boxes IfNode in poly contexts. Slot widens to poly
+# for mixed-type branches; same-type branches infer as that type and
+# the existing path applies.
+
+# 1. Ternary mixing String and Integer — variant 3 from #130.
+#    Was: -Wconditional-type-mismatch and segfault.
+class C1
+  def init(use_str)
+    @x = use_str ? "hello" : 42
+  end
+  def show; puts @x; end
+end
+
+c1 = C1.new
+c1.init(false); c1.show              # 42
+c1.init(true);  c1.show              # hello
+
+# 2. Same shape with Integer/Float — silent-coerce in pre-fix codegen.
+class C2
+  def init(use_int)
+    @x = use_int ? 100 : 1.5
+  end
+  def show; puts @x; end
+end
+
+c2 = C2.new
+c2.init(true);  c2.show              # 100
+c2.init(false); c2.show              # 1.5
+
+# 3. Mixed-type ternary combined with later concrete write — must
+#    interact with #130's multi-write widening: poly + concrete = stay poly.
+class C3
+  def init(use_str)
+    @x = use_str ? "hello" : 42
+  end
+  def overwrite_sym
+    @x = :sym
+  end
+  def show; puts @x; end
+end
+
+c3 = C3.new
+c3.init(true);  c3.show              # hello
+c3.overwrite_sym; c3.show            # sym
+c3.init(false); c3.show              # 42
+
+# 4. Same-type ternary — regression guard. Both branches int, slot
+#    stays mrb_int, no boxing overhead.
+class C4
+  def init(big)
+    @x = big ? 1000 : 1
+  end
+  def show; puts @x; end
+end
+
+c4 = C4.new
+c4.init(true);  c4.show              # 1000
+c4.init(false); c4.show              # 1
+
+# 5. Same-type-string ternary — regression guard. Slot stays string.
+class C5
+  def init(loud)
+    @x = loud ? "HEY" : "hi"
+  end
+  def show; puts @x; end
+end
+
+c5 = C5.new
+c5.init(true);  c5.show              # HEY
+c5.init(false); c5.show              # hi
+
+# 6. if-as-expression form (statement-style) with mixed types.
+#    Same AST shape (IfNode) as ternary, just multi-line surface syntax.
+class C6
+  def init(use_str)
+    @x = if use_str
+           "world"
+         else
+           99
+         end
+  end
+  def show; puts @x; end
+end
+
+c6 = C6.new
+c6.init(true);  c6.show              # world
+c6.init(false); c6.show              # 99
+
+# 7. Ternary with nil branch — should widen to nullable string,
+#    not poly. Let the existing nullable widening flow through.
+class C7
+  def init(have)
+    @x = have ? "yes" : nil
+  end
+  def show; puts @x.nil? ? "nope" : @x; end
+end
+
+c7 = C7.new
+c7.init(true);  c7.show              # yes
+c7.init(false); c7.show              # nope

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

@@ -0,0 +1,15 @@
+42
+hello
+100
+1.5
+hello
+sym
+42
+1000
+1
+HEY
+hi
+world
+99
+yes
+nope

data/vendor/spinel/test/ivar_writer_heterogeneity.rb

@@ -0,0 +1,34 @@
+# Issue #247: when two writers in different methods of the same class
+# disagree on the value type, spinel used to narrow the slot to
+# whichever writer's update_ivar_type call ran last — and the loser's
+# emit site silently miscompiled. Here writer 1 in initialize assigns
+# an int (via SymIntHash#[]) and writer 2 in write_any assigns a
+# string param; the slot must widen to poly so both store cleanly.
+
+class C
+  def initialize(h)
+    @id = h[:id]
+  end
+
+  def id; @id; end
+
+  def write_any(value)
+    @id = value
+  end
+end
+
+c = C.new({id: 42})
+c.write_any("string")
+puts c.id
+
+# Ensure the int-writer side still works when we don't re-write to a
+# different type — the slot stays as observed.
+class D
+  def initialize(h)
+    @v = h[:v]
+  end
+  def v; @v; end
+end
+
+d = D.new({v: 7})
+puts d.v

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

@@ -0,0 +1,2 @@
+string
+7

data/vendor/spinel/test/known_constants.rb

@@ -0,0 +1,25 @@
+# Issue #75: the codegen now rejects an unknown constant reference
+# with a "uninitialized constant <Name>" error instead of either
+# leaking the bare identifier into the C output (`p Foo`) or
+# silently lowering to `0` (`p Foo.bar`). This regression test pins
+# the legitimate constant references that look superficially like
+# the failing cases but resolve to known names — the fix shouldn't
+# reject any of them.
+
+# User-defined class — `find_class_idx` resolves it.
+class Box
+  def initialize(v); @v = v; end
+  attr_reader :v
+end
+
+puts Box.new(7).v          # 7
+
+# User-defined constant.
+N = 42
+puts N                     # 42
+
+# Built-in module-like receiver (Math).
+puts Math.sqrt(16).to_i    # 4
+
+# ARGV / STDOUT pass through.
+puts ARGV.length           # 0

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

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

data/vendor/spinel/test/kw_nil_default_string_call.rb

@@ -0,0 +1,6 @@
+def show(x: nil)
+  puts x
+end
+
+show(x: "hi")
+show(x: nil)

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

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

data/vendor/spinel/test/kwargs.rb

@@ -0,0 +1,21 @@
+# Test keyword arguments and splat
+
+def greet(name:, greeting: "Hello")
+  puts greeting
+  puts name
+end
+
+greet(name: "world")
+greet(name: "Ruby", greeting: "Hi")
+
+# Rest args (splat)
+def sum(*nums)
+  total = 0
+  nums.each do |n|
+    total += n
+  end
+  total
+end
+
+puts sum(1, 2, 3)    # 6
+puts sum(10, 20)     # 30

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

@@ -0,0 +1,6 @@
+Hello
+world
+Hi
+Ruby
+6
+30

data/vendor/spinel/test/kwargs_param.rb

@@ -0,0 +1,26 @@
+# KeywordRestParameterNode -- def f(**kw)
+#
+# Declares a method that captures all keyword arguments into a single
+# sym_poly_hash slot. The full body-access path (kw[:key], kw.length)
+# is deferred until a real program needs it; this test verifies the declaration
+# alone compiles and the existing **nil form still works.
+#
+# Forwarding usage (**kw → another method's **kw slot) is exercised by
+# test/forwarding_args.rb, which routes through cluster A3 + B1.
+
+# Declaration compiles; body never reads kw, so no kwargs runtime path
+# is needed. Validates that adding the param slot doesn't break
+# bootstrap or alter the C signature for callers that don't pass kwargs.
+def silent(a, **kw)
+  a + 1
+end
+puts silent(2).to_s   #=> 3
+
+# `def f(**nil)` is the explicit "rejects keyword args" form.
+# Verifies the existing NoKeywordsParameterNode handling still works
+# after the parser's PARAMETERS_NODE flattener gained the keyword_rest
+# emission (cluster A1).
+def strict(a, b, **nil)
+  a + b
+end
+puts strict(2, 3).to_s   #=> 5

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

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

data/vendor/spinel/test/kwargs_param_widen.rb

@@ -0,0 +1,73 @@
+# Issue #314 (B): a module class method's required keyword params
+# never widened from the "int" default at scan_new_calls time. The
+# AST presents kwargs as a single trailing KeywordHashNode, and the
+# existing positional-only widening loop unified the hash type into
+# `ptypes[0]` and never touched the per-kwarg slots.
+#
+# Two complementary fixes:
+#  1. widen_ptypes_from_args helper that walks KeywordHashNode
+#     children, mapping each `key: value` pair to the matching
+#     keyword param's slot in the callee's ptypes array.
+#  2. compile_call_args_with_defaults / compile_call_args_splat
+#     emit-side: replace the hardcoded `sp_box_str(...)` for poly
+#     kwargs with `box_expr_to_poly(...)` so the box helper is
+#     picked from the arg's actual source type.
+#
+# Surfaced via Roundhouse's emitted real-blog `form_with(model:,
+# model_name:, action:, method:, opts:)` shape — minimal repro
+# extracted with two distinct obj types passed to the same kwarg.
+
+# Article/Comment have an array ivar so neither qualifies for the
+# value-type optimization — instances stay heap-allocated and the
+# captured-by-poly boxing site (`sp_box_obj`) sees a real pointer.
+# (Pure-int/string-ivar classes flowing into a poly param at a call
+# site is a separate, orthogonal value-type-exclusion concern that
+# surfaces only with inline `X.new(...)` directly inside a poly-
+# typed call slot — not exercised by this issue's Roundhouse trigger,
+# where the receiver is always a previously-allocated local.)
+
+class Article
+  def initialize(id, name); @id = id; @name = name; @tags = []; end
+  def kind; "article-" + @name; end
+end
+
+class Comment
+  def initialize(body); @body = body; @replies = []; end
+  def kind; "comment-" + @body; end
+end
+
+module M
+  def self.render(model:, label:)
+    "[#{label}] #{model.kind}"
+  end
+end
+
+# Pre-allocate (matches the Roundhouse `lv_article` shape — locals
+# carry `sp_<C> *`, not struct-by-value).
+a = Article.new(7, "alpha")
+c = Comment.new("hello")
+
+# Two call sites with different obj types for `model:`. The widening
+# pass must collapse them to poly so the call-site box helper picks
+# sp_box_obj (not the pre-fix sp_box_str).
+puts M.render(model: a, label: "art")     # [art] article-alpha
+puts M.render(model: c, label: "com")     # [com] comment-hello
+
+# Module-inner class constructor inside a module class method
+# body. infer_function_body_call_types now pins
+# @current_method_name so resolve_const_read_name's
+# `<Mod>_cls_<m>` peel resolves `Inner` to `M_Inner` — pre-fix
+# the find_class_idx lookup returned -1 and skipped the
+# constructor-arg widening of N::Inner.@x.
+module N
+  class Inner
+    def initialize(x); @x = x; end
+    def show; "inner=#{@x.kind}"; end
+  end
+
+  def self.make(model:)
+    Inner.new(model).show
+  end
+end
+
+puts N.make(model: a)                     # inner=article-alpha

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

@@ -0,0 +1,3 @@
+[art] article-alpha
+[com] comment-hello
+inner=article-alpha