rubyduino 0.1.1

data/vendor/spinel/test/case_string_when_sym_no_match.rb

@@ -0,0 +1,59 @@
+# Issue #378: `case <string> when :sym_literal` (and the
+# symmetric `case <symbol> when "string_literal"`) used to lower
+# to `strcmp(str, SPS_<sym>) == 0` / `mrb_int == const char *` —
+# C type errors on every such arm because `compile_expr` on a
+# SymbolNode returns the `sp_sym` numeric id (a long long), and
+# strcmp expects `const char *`.
+#
+# CRuby semantics: `:sym === "string"` is false (Symbol#=== only
+# matches Symbols), and `"string" === :sym` is also false. The
+# fix emits a literal `0` for these cross-type when arms — the
+# C compiles, and the runtime pick correctly falls through to
+# the else clause to match CRuby.
+
+def lookup(name)
+  case name
+  when :id
+    1
+  when :body
+    2
+  else
+    -1
+  end
+end
+
+# String case-expr against symbol when-arms — every arm misses,
+# else clause runs.
+puts lookup("id")     # -1 (not 1)
+puts lookup("body")   # -1 (not 2)
+puts lookup("nope")   # -1
+
+def reverse(sym)
+  case sym
+  when "id"
+    1
+  when "body"
+    2
+  else
+    -1
+  end
+end
+
+# Symbol case-expr against string when-arms — symmetric: every
+# arm misses, else runs.
+puts reverse(:id)     # -1
+puts reverse(:body)   # -1
+
+# Sanity: matching arms still work.
+def lookup_sym(s)
+  case s
+  when :id
+    1
+  when :body
+    2
+  else
+    -1
+  end
+end
+puts lookup_sym(:id)   # 1
+puts lookup_sym(:body) # 2

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

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

data/vendor/spinel/test/case_when_class.rb

@@ -0,0 +1,70 @@
+# Issue #67: `case obj when SomeClass` lowered the predicate to an
+# `mrb_int` and then compared it against the bare class identifier
+# (`Var`, `List`), which weren't declared in C. Two pieces:
+#
+# - The case-temp now keeps the predicate's pointer type
+#   (`sp_<Cls> *`) so the value is comparable as-is.
+# - `compile_when_conds` resolves `when ClassName` against an
+#   obj-typed predicate at compile time using
+#   `is_class_or_ancestor` — same-class or ancestor matches; an
+#   unrelated when-class folds to a literal `0`. Nullable predicate
+#   types (`obj_<Cls>?`) match only when the value is non-NULL.
+#
+# Subclass matching against a parent-typed predicate (where the
+# instance is actually a child class) needs a runtime cls_id check
+# and stays out of scope here.
+
+class Var; end
+class List; end
+
+# Statement form — the issue's exact reproducer.
+node = Var.new
+case node
+when Var
+  puts "var"
+when List
+  puts "list"
+end
+# => var
+
+# Statement form, the other arm wins.
+items = List.new
+case items
+when Var
+  puts "var2"
+when List
+  puts "list2"
+end
+# => list2
+
+# Expression form — same dispatch, value-returning.
+n = Var.new
+label = case n
+        when Var  then "v"
+        when List then "l"
+        else            "?"
+        end
+puts label
+# => v
+
+# Else clause when no when arm matches.
+class Other; end
+class Sentinel; end
+o = Other.new
+case o
+when Var      then puts "x"
+when List     then puts "y"
+when Sentinel then puts "z"
+else               puts "default"
+end
+# => default
+
+# Inheritance: when arm names an ancestor of the predicate's class.
+class Animal; end
+class Dog < Animal; end
+d = Dog.new
+case d
+when Animal then puts "ancestor"
+else             puts "else"
+end
+# => ancestor

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

@@ -0,0 +1,5 @@
+var
+list2
+v
+default
+ancestor

data/vendor/spinel/test/chained_attr_setter.rb

@@ -0,0 +1,55 @@
+# `@a = obj.attr = val` and similar chains used to mistype the
+# outer LHS. `infer_call_type` had no special case for an
+# attr-writer CallNode (`obj.attr = val`), so it fell through to
+# the int default. Codegen was emitting the right C-level
+# assignment expression `(rc->iv_attr = arg)` (which evaluates
+# to the rhs in C), but the surrounding LHS was declared as
+# `mrb_int`, so `outer = (rc->iv_attr = obj_value)` typed the
+# outer slot as int and any later use went through the wrong
+# dispatch.
+#
+# Fix: when `infer_call_type` sees a CallNode whose name ends
+# with `=` (and isn't `==` / `<=` / etc.), and the receiver is
+# obj-typed and has an attr_writer for the slot, return the rhs
+# argument's type. Ruby semantics: an assignment expression
+# evaluates to the rhs.
+
+class Box
+  def initialize(n); @n = n; @arr = []; @arr << n; end
+  attr_reader :n
+end
+
+class Holder
+  attr_writer :box
+end
+
+# Simple chain — the result of `h.box = Box.new(...)` should be
+# a Box, not an int.
+h = Holder.new
+b = (h.box = Box.new(42))
+puts b.n   # 42
+
+# Optcarrot-shape chain: `@a = obj.x = expr`. Both `@a` and
+# `obj.x` get the same Box; reading either back gives the
+# same value.
+class Apu
+  def initialize(n); @n = n; @arr = []; @arr << n; end
+  attr_reader :n
+end
+
+class Cpu
+  attr_writer :apu
+  attr_reader :apu
+end
+
+class Nes
+  def initialize
+    @cpu = Cpu.new
+    @apu = @cpu.apu = Apu.new(99)
+  end
+  attr_reader :apu, :cpu
+end
+
+n = Nes.new
+puts n.apu.n        # 99
+puts n.cpu.apu.n    # 99

data/vendor/spinel/test/chained_ivar_op_assign_emits_inner_write.rb

@@ -0,0 +1,28 @@
+# `@b = @a &= 0x80` parses as InstanceVariableWriteNode whose value
+# is an InstanceVariableOperatorWriteNode. Without an inner-write
+# emitter, the `@a &= ...` evaporated and `@b = ...` saw `0` —
+# both ivars ended up wrong. Verifies the chained form against the
+# parens-rewrite (`@b = (@a = @a & 0x80)`) and the manual two-stmt
+# split — all three should produce the same `@a=128 @b=128`.
+
+class C
+  attr_reader :a, :b
+  def initialize
+    @a = 0xff
+    @b = 0
+  end
+  def m_chain
+    @b = @a &= 0x80
+  end
+  def m_paren
+    @b = (@a = @a & 0x80)
+  end
+  def m_split
+    @a = @a & 0x80
+    @b = @a
+  end
+end
+
+c1 = C.new; c1.m_chain; puts "chain: a=#{c1.a} b=#{c1.b}"
+c2 = C.new; c2.m_paren; puts "paren: a=#{c2.a} b=#{c2.b}"
+c3 = C.new; c3.m_split; puts "split: a=#{c3.a} b=#{c3.b}"

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

@@ -0,0 +1,3 @@
+chain: a=128 b=128
+paren: a=128 b=128
+split: a=128 b=128

data/vendor/spinel/test/chained_ivar_write_call_rhs.rb

@@ -0,0 +1,30 @@
+# Chained `@a = @b = foo` where the rhs is a method call with a side
+# effect. The naive per-slot lowering re-evaluates the rhs once per
+# target, calling foo() N times instead of once. The chain handler
+# must evaluate the rhs once into a temp and store from the temp into
+# each ivar slot.
+
+$count = 0
+
+def foo
+  $count = $count + 1
+  $count
+end
+
+class C
+  def initialize
+    @a = "hello"
+    @b = 42
+  end
+
+  def reset
+    @a = @b = foo
+  end
+
+  attr_reader :a, :b
+end
+
+c = C.new
+c.reset
+puts $count
+puts c.b

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

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

data/vendor/spinel/test/chained_ivar_write_split.rb

@@ -0,0 +1,26 @@
+# Chained `@a = @b = ... = literal` where the targets have different
+# concrete slot types (here: a string ivar and an int ivar). Without
+# splitting the chain into per-target writes, the outer assignment's
+# RHS picks up the inner ivar's recorded type, and the C compiler
+# rejects the cross-typed slot store.
+
+class C
+  def initialize
+    @a = "hello"
+    @b = 42
+  end
+
+  def reset
+    @a = @b = nil
+  end
+
+  def show
+    puts @a
+    puts @b
+  end
+end
+
+c = C.new
+c.show
+c.reset
+puts "reset ok"

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

@@ -0,0 +1,3 @@
+hello
+42
+reset ok

data/vendor/spinel/test/chained_ivar_write_subclass.rb

@@ -0,0 +1,26 @@
+# Issue #238 follow-up to #235: chained `@a = @b = nil` in a parent
+# class, with concrete writes in a subclass that pin the slots to
+# typed pointers (string + int). Without restricting the
+# chain-head bypass to `at == "int"`, the parent's nil-chain forces
+# "nil" into the slot type each iteration of the inference fixpoint
+# while the subclass's typed write cascades back up — the slot
+# ping-pongs between obj_X and obj_X? and lands on poly, which
+# then rejects the typed-pointer store as a C type error.
+
+class Base
+  def reset
+    @a = @b = nil
+  end
+end
+
+class Sub < Base
+  def initialize
+    @a = "hello"
+    @b = 42
+  end
+  attr_reader :a, :b
+end
+
+s = Sub.new
+puts s.a
+puts s.b

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

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

data/vendor/spinel/test/chained_or_assign_collection_array_nested.rb

@@ -0,0 +1,32 @@
+# 4-level chained `||=` mirroring optcarrot's PPU#setup_lut
+# `@lut_update` shape:
+#
+#     (((@h[b] ||= [])[i] ||= [nil, nil])[0] ||= []) << v
+#
+# Levels 1, 2, 3 are all `||=` against poly-element receivers
+# (poly_poly_hash, then a poly value carrying a poly_array twice).
+# Pre-fix only level 1 was lowered; levels 2 and 3 fell through to
+# the int default and the chain collapsed to `0 << ...`. The fix
+# threads sp_RbVal temps through every level and promotes ArrayNode
+# rhs literals (`[]`, `[nil, nil]`) to poly_array so each
+# intermediate `cls_id == SP_BUILTIN_POLY_ARRAY` probe matches at
+# runtime.
+
+class C
+  def initialize
+    @h = {}
+  end
+  def push(b, i, v)
+    (((@h[b] ||= [])[i] ||= [nil, nil])[0] ||= []) << v
+  end
+  def count(b, i); @h[b][i][0].length; end
+end
+
+c = C.new
+c.push(0, 5, 10)
+c.push(0, 5, 20)
+c.push(0, 7, 30)
+c.push(1, 0, 100)
+puts c.count(0, 5)   # 2
+puts c.count(0, 7)   # 1
+puts c.count(1, 0)   # 1

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

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

data/vendor/spinel/test/chained_or_assign_collection_element.rb

@@ -0,0 +1,29 @@
+# `(@h[k] ||= []) << v` — chained `||=` over a Hash element with a
+# trailing method call. The parenthesised subexpression evaluates
+# to the (just-created or pre-existing) Array; `<<` then pushes
+# into it.
+#
+# Pre-fix the IndexOrWriteNode expression-form fell through to the
+# default catch-all and emitted literal `0` as the chain
+# receiver — the resulting `sp_poly_shl(0, …)` failed C compile
+# (`0` is `int`, sp_poly_shl wants `sp_RbVal`). Spinel now lowers
+# `(h[k] ||= v)` into a get-then-set temp that the chain reads.
+
+class C
+  def initialize
+    @h = {}                       # promotes to sym_poly_hash on first []=
+  end
+  def add(k, v)
+    (@h[k] ||= []) << v
+  end
+  def count(k); @h[k].length; end
+end
+
+c = C.new
+c.add(:a, 1)
+c.add(:a, 2)
+c.add(:b, 10)
+c.add(:b, 20)
+c.add(:b, 30)
+puts c.count(:a)   # 2
+puts c.count(:b)   # 3

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

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

data/vendor/spinel/test/chained_or_assign_collection_poly_array.rb

@@ -0,0 +1,25 @@
+# `(arr[idx] ||= []) << v` — chained `||=` over a poly_array
+# element. Pre-fix the IndexOrWriteNode expression-form returned
+# the int default for non-hash receivers, so the chain receiver
+# collapsed to literal `0` and `<<` failed C compile.
+# Spinel now lowers the get-then-set into an sp_RbVal temp that
+# the chain reads — same shape as the *_poly_hash arms but with
+# in-bounds + auto-grow handling for the indexed access.
+
+class C
+  def initialize
+    @a = Array.new(3) { [] }    # promotes to poly_array of empty poly_arrays
+  end
+  def push(idx, v)
+    (@a[idx] ||= []) << v
+  end
+  def count(i); @a[i].length; end
+end
+
+c = C.new
+c.push(0, 10)
+c.push(0, 20)
+c.push(1, 100)
+puts c.count(0)   # 2
+puts c.count(1)   # 1
+puts c.count(2)   # 0

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

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

data/vendor/spinel/test/chained_or_assign_collection_str_keys.rb

@@ -0,0 +1,24 @@
+# Same chained-`||=` lowering, but for `str_poly_hash` instead of
+# `sym_poly_hash`. Exercises the `const char *` key path (vs the
+# `sp_sym` integer key path) of the typed-poly-hash branch added
+# alongside the sym_poly_hash arm.
+
+class C
+  def initialize
+    @h = {}
+    @h["init"] = []      # forces str_poly_hash
+  end
+  def add(k, v)
+    (@h[k] ||= []) << v
+  end
+  def count(k); @h[k].length; end
+end
+
+c = C.new
+c.add("init", 7)         # appends to existing
+c.add("foo", 1)
+c.add("foo", 2)
+c.add("bar", 100)
+puts c.count("init")     # 1
+puts c.count("foo")      # 2
+puts c.count("bar")      # 1

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

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

data/vendor/spinel/test/class_constant_path_read.rb

@@ -0,0 +1,26 @@
+# Issue #52: reading a class-scoped constant from outside the class
+# via `ClassName::CONST` used to emit `User_MAX_NAME_LENGTH` as an
+# undeclared C identifier. Now it's emitted as `cst_User_MAX_NAME_LENGTH`
+# with a matching declaration.
+
+class User
+  MAX_NAME_LENGTH = 20
+end
+
+puts User::MAX_NAME_LENGTH    # 20
+
+# Mixed reads: class const, module const, top-level const all
+# accessible via the same path forms.
+TOP = 1
+
+module Site
+  ROOT = 2
+
+  class Page
+    LIMIT = 3
+  end
+end
+
+puts TOP                      # 1
+puts Site::ROOT               # 2
+puts Site::Page::LIMIT        # 3

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

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

data/vendor/spinel/test/class_constant_sym_array.rb

@@ -0,0 +1,19 @@
+class Parser
+  SOFT_IDENTIFIER_KEYWORDS = %i[with]
+  SHADOWED = %i[class]
+
+  def soft?(value)
+    SOFT_IDENTIFIER_KEYWORDS.include?(value)
+  end
+
+  def shadowed?(value)
+    SHADOWED.include?(value)
+  end
+end
+
+SHADOWED = %i[top]
+
+puts Parser.new.soft?(:with)        # true
+puts Parser.new.soft?(:without)     # false
+puts Parser.new.shadowed?(:class)   # true
+puts Parser.new.shadowed?(:top)     # false

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

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

data/vendor/spinel/test/class_def_order.rb

@@ -0,0 +1,66 @@
+# Issue #14: classes referenced before their definition must still
+# produce a working struct layout. Earlier classes that embed a
+# value-type instance of a later class need the later class's struct
+# to be emitted first.
+
+class Box
+  def initialize
+    @ticket = Ticket.new(7)
+  end
+  def num; @ticket.num; end
+end
+
+class Ticket
+  def initialize(num)
+    @num = num
+  end
+  def num; @num; end
+end
+
+puts Box.new.num                # 7
+
+# Multi-level chain: Outer -> Middle -> Leaf, all defined back-to-front.
+class Outer
+  def initialize
+    @mid = Middle.new
+    @leaf = Leaf.new(11)
+  end
+  def show
+    puts @mid.value
+    puts @leaf.value
+  end
+end
+
+class Middle
+  def initialize
+    @leaf = Leaf.new(3)
+  end
+  def value; @leaf.value; end
+end
+
+class Leaf
+  def initialize(v); @v = v; end
+  def value; @v; end
+end
+
+Outer.new.show                  # 3 / 11
+
+# Parent class has a value-type ivar of a class defined later: child
+# inherits the (flattened) field, so the dep walk must follow the
+# parent chain too.
+class Holder
+  def initialize
+    @item = Item.new(42)
+  end
+  def value; @item.value; end
+end
+
+class SubHolder < Holder
+end
+
+class Item
+  def initialize(v); @v = v; end
+  def value; @v; end
+end
+
+puts SubHolder.new.value        # 42

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

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

data/vendor/spinel/test/class_method_open_class_call.rb

@@ -0,0 +1,31 @@
+# `infer_call_type`'s class-body fallback used to short-circuit on
+# any call inside a class body — including those with a receiver.
+# A `recv.method(...)` whose method isn't on the enclosing class
+# resolved as the default `int`, and the receiver-aware branches
+# below (Fiber.yield → poly, infer_open_class_type → user open-
+# class return) never ran. The fix gates the fallback on
+# `recv < 0`.
+#
+# Reproducer here: an open-class method on Integer that returns a
+# hash. Without the fix, `C#wrap`'s body calls `x.to_pair` whose
+# inferred return came out as `int` (the enclosing C class has no
+# `to_pair`), but the actual emit returns `sp_SymIntHash *` →
+# "returning sp_SymIntHash * from a function with return type
+# mrb_int" -Wint-conversion error.
+
+class Integer
+  def to_pair
+    {a: self, b: self * 2, c: self * 3}
+  end
+end
+
+class C
+  def wrap(x)
+    x.to_pair
+  end
+end
+
+h = C.new.wrap(5)
+puts h[:a]   # 5
+puts h[:b]   # 10
+puts h[:c]   # 15

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

@@ -0,0 +1,3 @@
+5
+10
+15