rubyduino 0.1.1

data/vendor/spinel/test/issue207_factory_pattern.rb

@@ -0,0 +1,35 @@
+# Issue #207: factory class method (`def self.from_raw`) using
+# implicit `new`, calling a setter on the new instance whose value
+# came from a poly-hash-returning fetch. Several composing gaps:
+#
+#   1. Bare `new` inside a `def self.<m>` body must resolve to
+#      <CurrentClass>.new (returning obj_<CurrentClass>).
+#   2. The class method's parameter type must widen from the
+#      class-constant call site (`T.from_raw(p)` → params: obj_P).
+#   3. The setter's poly arg must widen the receiving ivar's slot
+#      type (sp_RbVal field, not mrb_int).
+#   4. The fetch's nil-default param must widen from the call-site
+#      string default ("" → string?).
+
+class P
+  def initialize(h)
+    @h = h
+  end
+  def fetch(key, default = nil)
+    return @h[key] if @h.key?(key)
+    default
+  end
+end
+
+class T
+  attr_accessor :title
+  def self.from_raw(params)
+    instance = new
+    instance.title = params.fetch(:title, "")
+    instance
+  end
+end
+
+p = P.new({title: "hello", count: 42})
+t = T.from_raw(p)
+puts t.title

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

@@ -0,0 +1 @@
+hello

data/vendor/spinel/test/issue207_full_repro.rb

@@ -0,0 +1,52 @@
+# Issue #207: full Sam Ruby repro — Rails-style ActiveRecord
+# Parameters wrapper with symbolize_keys recursion plus a typed
+# Params factory using fetch.
+#
+# This combines several fixes that had to land together:
+#
+# - Implicit `new` inside `def self.<m>` resolves to the enclosing
+#   class's constructor (#207 partial fix).
+# - cls method body return inference picks up locals (#207 partial
+#   fix).
+# - attr_writer call inside cls method body widens the ivar slot.
+# - Class-constant call sites (T.from_raw(p)) widen the cls method's
+#   parameter types.
+# - Static is_a? / kind_of? on a known-concrete-type receiver
+#   eliminates the unreachable arm so the dead recursion call
+#   doesn't land in C and trip the type checker.
+
+class Parameters
+  def initialize(hash = {})
+    @hash = symbolize_keys(hash)
+  end
+
+  def symbolize_keys(input)
+    out = {}
+    input.each do |k, v|
+      sym = k.is_a?(Symbol) ? k : k.to_s.to_sym
+      out[sym] = v.is_a?(Hash) ? symbolize_keys(v) : v
+    end
+    out
+  end
+
+  def fetch(key, default = nil)
+    sym = key.to_sym
+    return @hash[sym] if @hash.key?(sym)
+    default
+  end
+end
+
+class ArticleParams
+  def title; @title; end
+  def title=(value); @title = value; end
+
+  def self.from_raw(params)
+    instance = new
+    instance.title = params.fetch(:title, "")
+    instance
+  end
+end
+
+p = Parameters.new({title: "hello"})
+ap = ArticleParams.from_raw(p)
+puts ap.title

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

@@ -0,0 +1 @@
+hello

data/vendor/spinel/test/issue208_inherited_class_method.rb

@@ -0,0 +1,24 @@
+# Issue #208: a class method (`def self.<name>`) defined on the
+# parent class must dispatch when called via the subclass. Spinel
+# previously emitted "cannot resolve call to '<method>' on
+# class_<Subclass>" and substituted 0 because cls_cmethod lookup
+# only walked the immediate class.
+
+class Base
+  def self.all
+    [42, 1, 7]
+  end
+end
+
+# Single level
+class Leaf < Base; end
+puts Leaf.all.size                   # 3
+
+# Multi level
+class Mid < Base; end
+class Deep < Mid; end
+puts Mid.all.size                    # 3
+puts Deep.all.size                   # 3
+
+# Direct call on the defining class still works
+puts Base.all.size                   # 3

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

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

data/vendor/spinel/test/issue219_aref_chain.rb

@@ -0,0 +1,36 @@
+# Issue #219: chained calls on a user-defined `[]` operator's
+# result silently lost their coercion (`.to_i` / `.length`) because
+# infer_type's `mname == "[]"` branch handled built-in collection
+# receivers but fell through to "int" for obj receivers.
+# `bag[:id].to_i` then routed through compile_int_method_expr's
+# `to_i` (which is identity) and the underlying `const char *`
+# leaked through.
+
+class Bag
+  def initialize(h); @h = h; end
+  def [](k); @h[k.to_sym]; end
+end
+
+bag = Bag.new({id: "42"})
+
+# .to_i: infers as int via String#to_i
+puts bag[:id].to_i              # 42
+puts bag[:id].to_i + 1          # 43
+
+# .length: routes through String#length
+puts bag[:id].length            # 2
+
+# Chained into a method expecting mrb_int
+class M
+  def self.find(id); id + 1; end
+end
+puts M.find(bag[:id].to_i)      # 43
+
+# Integer-valued bag — .to_s works the other direction (already
+# worked before the fix; pinning regression).
+class IntBag
+  def initialize(h); @h = h; end
+  def [](k); @h[k]; end
+end
+ib = IntBag.new({n: 42})
+puts ib[:n].to_s                # "42"

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

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

data/vendor/spinel/test/issue224_bare_new_inherited.rb

@@ -0,0 +1,66 @@
+# Issue #224: bare `new` inside an inherited class method body must
+# resolve to the *calling subclass*, not the parent class that
+# defined the method. Sister to issue #208 (which fixed cls method
+# dispatch up the inheritance chain); once `Article.create` runs
+# `Base.create`'s body, the bare `new` *inside* that body should
+# also dispatch to Article's constructor.
+#
+# Pre-fix the basic case warned "cannot resolve call to 'x' on
+# obj_Base" and emitted 0 (because new resolved statically to
+# Base.new, returning an obj_Base which has no `x` method); the
+# variant with attrs args produced a C-level type mismatch
+# (`sp_Base_new(lv_attrs)` calling Base's 0-arg new with an extra
+# pointer arg).
+
+# Basic: bare `new`, no args.
+class Base
+  def self.create
+    new
+  end
+end
+
+class Article < Base
+  def initialize
+    @x = "hello"
+  end
+  def x; @x; end
+end
+
+puts Article.create.x                  # hello
+
+# Variant: bare `new(args)`, attrs hash. The cls method param `attrs`
+# widens from the call site `Article.create({title: ...})` to a
+# typed hash; the bare `new(attrs)` propagates that ptype to
+# Article's `initialize` so the synthetic `sp_Article_new` signature
+# matches.
+class Base2
+  def self.create(attrs)
+    instance = new(attrs)
+    instance
+  end
+end
+
+class Article2 < Base2
+  def initialize(attrs)
+    @title = attrs[:title]
+  end
+  def title; @title; end
+end
+
+puts Article2.create({title: "hello"}).title     # hello
+
+# Multi-level: bare `new` resolves to the leaf class.
+class Mid < Base; end
+class Deep < Mid
+  def initialize
+    @x = "deep"
+  end
+  def x; @x; end
+end
+puts Deep.create.x                     # deep
+
+# Direct call on the defining class still works (Base has no
+# initialize so Article-via-Base.create wouldn't make sense, but
+# Article2.create directly uses Base2.create's body via the
+# synthetic copy and exercises the same path twice).
+puts Article2.create({title: "world"}).title     # world

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

@@ -0,0 +1,4 @@
+hello
+hello
+deep
+world

data/vendor/spinel/test/issue229_uncalled_cls_method.rb

@@ -0,0 +1,76 @@
+# Issue #229: an unused class method whose body has bare `new(args)`
+# against a defining class with different `initialize` arity used to
+# emit a body that wouldn't C-compile. Sister to issue #224 (which
+# fixed bare-`new` *dispatch* for reachable inherited cls methods);
+# this is the unreached-emit complement. The fix DCEs cls methods
+# with no call site so unreachable bodies never have to type-check.
+#
+# Three Sam-Ruby-filed variants exercise here: solo class (arity
+# mismatch), 3-class inheritance with one leaf called (multiple
+# dead bodies multiply), and default-arg initialize (type mismatch).
+
+# Variant 1: solo class. Base.create is defined but never called.
+# Pre-fix: `sp_Base_cls_create` emits `return sp_Base_new(lv_attrs)`
+# against a 0-arg `sp_Base_new(void)` and `cc` rejects.
+class Base
+  def initialize
+    @x = 1
+  end
+  def x; @x; end
+
+  def self.create(attrs)
+    new(attrs)
+  end
+end
+
+b = Base.new
+puts b.x                               # 1
+
+# Variant 2: 3-class inheritance, only the leaf is called.
+# Pre-fix all three (Base2/Mid/Leaf) emitted cls_create bodies;
+# only Leaf's compiled. With DCE, only Leaf::create is live.
+class Base2
+  def initialize
+    @v = 0
+  end
+
+  def self.create(attrs)
+    new(attrs)
+  end
+end
+
+class Mid < Base2
+end
+
+class Leaf < Mid
+  def initialize(x)
+    @x = x
+  end
+  def x; @x; end
+end
+
+# `Leaf.create(42)` runs the body propagated from Base2.create:
+# `instance = new(attrs)` => `Leaf.new(42)` => Leaf#initialize(42).
+puts Leaf.create(42).x                 # 42
+
+# Variant 3: default-arg initialize. `sp_Base3_new` is synthesized
+# as `sp_Base3_new(sp_StrIntHash *)` from the default literal, but
+# the uncalled `Base3.create` can't infer its `attrs` ptype so the
+# body's `sp_Base3_new(lv_attrs)` had `lv_attrs : mrb_int` against
+# the declared `sp_StrIntHash *`. DCE drops the body entirely.
+class Base3
+  def initialize(attrs = {})
+    @v = attrs.length
+  end
+  def v; @v; end
+
+  def self.create(attrs)
+    new(attrs)
+  end
+end
+
+# Demonstrate Base3 still works for the *called* path: explicit
+# `Base3.new` is live, so `sp_Base3_new` is emitted and called.
+# Only `Base3.create` (the uncalled cls method) drops.
+b3 = Base3.new
+puts b3.v                              # 0

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

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

data/vendor/spinel/test/issue235_chain_tail_widening.rb

@@ -0,0 +1,48 @@
+# Issue #235 follow-up to #234: chained `@a = @b = expr` only widened
+# the chain *head*. The tail (and intermediate participants in
+# longer chains) relied on scan_ivars's dual-definite-literal gate,
+# which fires for literal RHS but not for CallNode/expression RHS.
+# A `@a = @b = make_int` with `@a`/`@b` previously string-typed left
+# `@b`'s slot at `const char *` while compile_chained_ivar_writes
+# emitted `iv_b = _t1;` with `_t1 : mrb_int`. Same C error shape
+# #234 was fixing for the head, just on the tail.
+
+class C
+  def initialize
+    @a = "hello"
+    @b = "world"
+  end
+
+  def make_int
+    42
+  end
+
+  # CallNode RHS — bypasses scan_ivars's literal-gate widening so
+  # the chain-drill path is the only thing that can widen `@b`.
+  def reset_call
+    @a = @b = make_int
+  end
+
+  # 3-chain with CallNode RHS — every intermediate must widen.
+  def reset_three(c)
+    @a = @b = @c = c.length
+  end
+
+  def show
+    puts @a
+    puts @b
+  end
+end
+
+c = C.new
+c.reset_call
+c.show                  # 42 / 42
+
+c2 = C.new
+c2.reset_three("ab")
+c2.show                 # 2 / 2
+
+# 3-chain that adds an `@c` slot to the picture too. After
+# reset_three sets @c, calling show wouldn't read it (no accessor),
+# but the struct emit needs to type-check.
+puts "ok"

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

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

data/vendor/spinel/test/issue236_chain_empty_literal.rb

@@ -0,0 +1,84 @@
+# Issue #236 follow-up to #234: chained `@a = @b = {}` (or `[]`)
+# with slots promoted to a typed container (e.g. `str_str_hash`)
+# emitted a default `sp_StrIntHash *` temp and assigned it to both
+# slots, mismatching the promoted slot's pointer type. The fix
+# detects empty-literal RHS in compile_chained_ivar_writes and,
+# when every chain participant agrees on the same promoted type,
+# emits the slot-typed constructor for the temp so the assignment
+# type-checks and Ruby's "one shared object" semantic is preserved
+# (both slots receive the same pointer).
+
+# Hash: both slots promoted to str_str_hash via @h["k"] = "v" writes.
+class HashOwner
+  def initialize
+    @a = {}
+    @a["seed"] = "value"
+    @b = {}
+    @b["seed"] = "value"
+  end
+
+  def reset
+    @a = @b = {}
+  end
+
+  # Sharing test: write to @a, observe through @b. Pre-fix this
+  # wouldn't compile; if the chain helper accidentally regressed to
+  # per-slot constructors, sharing would be lost and @b would still
+  # report length 0 after the @a write.
+  def post_reset_share_check
+    @a["after"] = "ok"
+    puts @b.length            # 1 if shared, 0 if separate objects
+    puts @b["after"]          # "ok" if shared
+  end
+end
+
+ho = HashOwner.new
+ho.reset
+ho.post_reset_share_check
+
+# Array: both slots promoted to str_array via push("x"/"y").
+class ArrayOwner
+  def initialize
+    @a = []
+    @a.push("x")
+    @b = []
+    @b.push("y")
+  end
+
+  def reset
+    @a = @b = []
+  end
+
+  def post_reset_share_check
+    @a.push("z")
+    puts @b.length            # 1 if shared
+    puts @b[0]                # "z" if shared
+  end
+end
+
+ao = ArrayOwner.new
+ao.reset
+ao.post_reset_share_check
+
+# Three-chain to confirm the consensus check covers length-3 chains.
+class ThreeChain
+  def initialize
+    @a = {}; @a["s"] = "v"
+    @b = {}; @b["s"] = "v"
+    @c = {}; @c["s"] = "v"
+  end
+
+  def reset
+    @a = @b = @c = {}
+  end
+
+  def show
+    puts @a.length
+    puts @b.length
+    puts @c.length
+  end
+end
+
+tc = ThreeChain.new
+tc.reset
+tc.show

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

@@ -0,0 +1,7 @@
+1
+ok
+1
+z
+0
+0
+0

data/vendor/spinel/test/issue239_cls_method_default_args.rb

@@ -0,0 +1,41 @@
+# Issue #239: `def self.method` with default arguments must accept
+# call sites that omit the optional args. The default-arg fill
+# existed for instance-method codegen (`def method(a, b = nil)`
+# called as `c.method("a")` works) and for top-level `def`
+# methods, but `def self.x` on both modules and classes missed the
+# synthesis — call sites emitted with too few args, failing the C
+# compile with `too few arguments to function call`. Sister to #229
+# (cls method DCE) — both about `def self.method` codegen gaps.
+
+# Module form: cls method lives in @meth_* under "<Mod>_cls_<m>".
+# Two gaps: the dispatch path used the un-typed compile_call_args
+# instead of compile_call_args_with_defaults, AND param types
+# weren't widened from `<Mod>.<m>(args)` call sites (issue #207's
+# logic only walked @cls_cmeth_*).
+module M
+  def self.greet(name, msg = "default")
+    name + "/" + msg
+  end
+end
+
+puts M.greet("a")            # a/default
+puts M.greet("a", "world")   # a/world
+
+# Class form: cls method lives in @cls_cmeth_*. Defaults weren't
+# stored at all (no @cls_cmeth_defaults table parallel to
+# @cls_meth_defaults).
+class C
+  def self.greet(name, msg = "fromcls")
+    name + "/" + msg
+  end
+end
+
+puts C.greet("b")            # b/fromcls
+puts C.greet("b", "explicit")  # b/explicit
+
+# Inheritance + default: subclass inherits the default through
+# the propagate_inherited_class_methods synthetic copy.
+class Sub < C
+end
+
+puts Sub.greet("c")          # c/fromcls

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

@@ -0,0 +1,5 @@
+a/default
+a/world
+b/fromcls
+b/explicit
+c/fromcls

data/vendor/spinel/test/issue_266_def_length_inference.rb

@@ -0,0 +1,63 @@
+# Issue #266 regression: defining `def length` on a class flipped
+# Spinel's inference for IntArray params on unrelated class methods to
+# poly. Cause was `infer_cls_meth_param_from_body` committing a param
+# to `obj_<C>` whenever the only methods called on it (here `.length`)
+# matched a user class — even though IntArray (and every other built-in
+# container) also has `.length`. The body signal is too weak to commit;
+# the gate added in this fix skips the pre-typing when the called set
+# is satisfied by built-in container types, leaving call-site
+# unification to decide.
+
+class Mat
+  attr_accessor :flat, :nrows, :ncols
+  def initialize(nrows, ncols)
+    @nrows = nrows
+    @ncols = ncols
+    @flat  = Array.new(nrows * ncols, 0.0)
+  end
+end
+
+class Net
+  def backward(input_ids, logits)
+    n_pred = input_ids.length - 1
+    if n_pred <= 0
+      return 0.0
+    end
+    self.cross_entropy_grad(logits, input_ids)
+  end
+
+  def cross_entropy_grad(logits, token_ids)
+    n     = token_ids.length - 1
+    total = 0.0
+    i = 0
+    while i < n
+      target = token_ids[i + 1]
+      total += logits.flat[target]
+      i += 1
+    end
+    total
+  end
+end
+
+def make_ids(s)
+  parts = s.split(" ")
+  ids   = [parts[0].to_i]
+  k = 1
+  while k < parts.length
+    ids.push(parts[k].to_i)
+    k += 1
+  end
+  ids
+end
+
+# The class with `def length` is the trigger — pre-fix this caused
+# Net#backward and Net#cross_entropy_grad to be inferred with poly
+# `input_ids` / `token_ids` params and then mis-compile.
+class Bag
+  attr_accessor :data
+  def initialize(data); @data = data; end
+  def length;           0;             end
+end
+
+prompt = make_ids("0 1 2")
+puts Net.new.backward(prompt, Mat.new(3, 4))

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

@@ -0,0 +1 @@
+0.0

data/vendor/spinel/test/ivar_and_write_basic.rb

@@ -0,0 +1,34 @@
+class T
+  def initialize
+    @ready = false
+    @count = 0
+  end
+
+  def maybe_inc
+    @ready &&= step
+  end
+
+  def arm
+    @ready = true
+  end
+
+  def step
+    @count += 1
+    true
+  end
+
+  def state
+    "ready=#{@ready} count=#{@count}"
+  end
+end
+
+t = T.new
+puts t.state
+t.maybe_inc
+puts t.state
+t.arm
+puts t.state
+t.maybe_inc
+puts t.state
+t.maybe_inc
+puts t.state

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

@@ -0,0 +1,5 @@
+ready=false count=0
+ready=false count=0
+ready=true count=0
+ready=true count=1
+ready=true count=2

data/vendor/spinel/test/ivar_c_keyword.rb

@@ -0,0 +1,14 @@
+# Test: ivar naming remains safe for C keywords and iv_ prefix collisions.
+
+class KeywordIvar
+  def initialize
+    @if = 40
+    @iv_if = 1
+  end
+
+  def value
+    @if + @iv_if + 1
+  end
+end
+
+puts KeywordIvar.new.value

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

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