rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/auto_unbox_poly_to_int_local.rb

@@ -1,36 +0,0 @@
-# Auto-unbox poly RHS into a primitive int local slot. Common
-# case: `lv = arr[i]` where arr's element dispatch returns poly
-# (heterogeneous element types) but the local was already inferred
-# as int from a prior write. Spinel previously emitted
-# `lv = <sp_RbVal>;` and the C compile failed (`incompatible
-# types when assigning to type 'mrb_int' from type 'sp_RbVal'`).
-#
-# Repro: an ivar widened to poly via two distinct array shapes
-# (an int_array and a poly_array). The local `pixel` was first
-# set from an int_array (so its declared C type is mrb_int),
-# then a second write reassigns from the poly slot. Without
-# auto-unbox, the second assignment fails.
-
-class C
-  def make_int_arr
-    @arr = [10, 20, 30]
-  end
-  def make_poly_arr
-    @arr = [nil] * 3
-    @arr[0] = 99
-    @arr[1] = "x"
-    @arr[2] = :y
-  end
-  def first_int
-    @arr[0]
-  end
-end
-
-c = C.new
-c.make_int_arr
-pixel = c.first_int   # int from int_array
-puts pixel.to_s
-
-c.make_poly_arr
-pixel = c.first_int   # poly from poly_array, must auto-unbox
-puts pixel.to_s

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

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

data/vendor/spinel/test/bare_return_in_cls_method.rb

@@ -1,46 +0,0 @@
-# Issue #314 follow-up: a class method whose return type was
-# inferred as `obj_<C>` (because every explicit return path
-# produced a value of that class) lowered a bare `return` to
-# `return self;` — but class methods have no `self` C param, so
-# gcc complained `'self' undeclared`.
-#
-# Fix: thread a `@current_method_has_self` flag through the
-# instance-method / class-method / top-level / constructor-
-# synthesis emit paths. compile_return_stmt's bare-return-with-
-# obj_<C>-return path emits `return self;` only when has_self=1,
-# otherwise `return c_return_default(...);` (which knows about
-# value vs pointer object types).
-#
-# Companion to b9d6303 (#337) which added the obj_<C> branch for
-# constructor synthesis.
-#
-# Surfaced via Roundhouse's `InMemoryAdapter.update` — a module
-# class method whose return type was inferred as obj_HWIA via
-# the `attrs.each` last-expression, with an early `return if
-# row.nil?` lowering to broken `return self;`.
-
-class Holder
-  attr_reader :id
-  def initialize(id)
-    @id = id
-  end
-
-  def self.maybe(id)
-    if id < 0
-      return       # ← bare return; bug emitted `return self;`
-    end
-    Holder.new(id)
-  end
-end
-
-# Pushing into a [Holder] array forces Holder out of the value-type
-# bucket so `Holder.maybe` returns `sp_Holder *` (pointer) and the
-# bare-return shape exercises the pointer fallback.
-holders = [Holder.new(0)]
-
-a = Holder.maybe(42)
-holders << a
-puts a.id                 # 42
-
-b = Holder.maybe(-1)
-puts b.nil?               # true

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

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

data/vendor/spinel/test/bare_return_in_poly_method.rb

@@ -1,26 +0,0 @@
-# Issue #383: bare `return` (no value) in a method whose declared
-# return type is `sp_RbVal` (poly) emitted literal `return 0;`
-# instead of `return sp_box_nil();` — gcc errors `incompatible
-# types when returning type 'int' but 'sp_RbVal' was expected`.
-# The implicit end-of-function fallthrough already emitted the
-# correct boxed nil; only bare-return statements were missed.
-#
-# Sister to the void-initialize and obj_<C>-class-method fixes
-# (#337 / #314 follow-up). compile_return_stmt's bare-return
-# path now has a poly arm that emits `sp_box_nil()`.
-
-class Adapter
-  def self.lookup(key)
-    return unless key == "x"     # poly-returning fn, bare return
-    if key.length > 5
-      "long-string"
-    else
-      [1, 2, 3]
-    end
-  end
-end
-
-# Heterogeneous return types collapse to poly; the bare-return
-# branch needs to box nil into the same slot.
-puts Adapter.lookup("x").to_s
-puts Adapter.lookup("none").to_s

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

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

data/vendor/spinel/test/bound_method_array.rb

@@ -1,22 +0,0 @@
-# An array of Methods naturally infers as a ptr_array of
-# obj_Method, since Method is just a regular user class as
-# far as the type system is concerned. Each entry survives the
-# round-trip through sp_PtrArray_get and dispatches to its captured
-# (self, fn) pair.
-
-class C
-  def double(x); x * 2; end
-  def triple(x); x * 3; end
-  def quad(x);   x * 4; end
-
-  def fns
-    [method(:double), method(:triple), method(:quad)]
-  end
-end
-
-c = C.new
-fns = c.fns
-puts fns.length
-puts fns[0].call(5)
-puts fns[1].call(5)
-puts fns[2].call(5)

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

@@ -1,4 +0,0 @@
-3
-10
-15
-20

data/vendor/spinel/test/bound_method_basic.rb

@@ -1,27 +0,0 @@
-# `method(:foo)` inside a class body must yield a value that survives
-# being stored in an ivar / passed across a method-call boundary, then
-# called with `bm.call(x)` or `bm[x]`. Spinel's pre-fix path treated
-# `method(:foo)` as a compile-time alias only — the variable held a
-# placeholder int and the call body silently miscompiled to `return 0`.
-
-class C
-  def initialize
-    @bm = method(:double)
-  end
-
-  def double(x)
-    x * 2
-  end
-
-  def via_call(x)
-    @bm.call(x)
-  end
-
-  def via_bracket(x)
-    @bm[x]
-  end
-end
-
-c = C.new
-puts c.via_call(7)
-puts c.via_bracket(20)

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

@@ -1,2 +0,0 @@
-14
-40

data/vendor/spinel/test/call_op_write.rb

@@ -1,51 +0,0 @@
-# CallOperatorWriteNode -- `obj.attr += val`, `obj.attr -= val`, etc.
-#
-# CRuby evaluates the receiver exactly once even though the source
-# `obj.bar += v` expands conceptually to `obj.bar = obj.bar + v`.
-# The temp pattern in compile_call_assign_typed mirrors that.
-#
-# Spinel restriction: only typed instance receivers with
-# attr_accessor (or struct field) on the class are supported. For
-# everything else the codegen exits with a precise error rather
-# than emit silently-wrong C.
-
-class Counter
-  attr_accessor :n
-  def initialize
-    @n = 0
-  end
-end
-
-c = Counter.new
-c.n += 5
-puts c.n            # 5
-c.n += 10
-puts c.n            # 15
-c.n -= 3
-puts c.n            # 12
-c.n *= 2
-puts c.n            # 24
-c.n /= 4
-puts c.n            # 6
-c.n |= 1
-puts c.n            # 7
-c.n &= 5
-puts c.n            # 5
-c.n ^= 4
-puts c.n            # 1
-c.n <<= 3
-puts c.n            # 8
-c.n >>= 1
-puts c.n            # 4
-
-# String-valued attr -- `+=` becomes string concat.
-class Greeting
-  attr_accessor :msg
-  def initialize
-    @msg = "hello"
-  end
-end
-
-g = Greeting.new
-g.msg += " world"
-puts g.msg          # hello world

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

@@ -1,11 +0,0 @@
-5
-15
-12
-24
-6
-7
-5
-1
-8
-4
-hello world

data/vendor/spinel/test/chained_attr_setter.rb

@@ -1,55 +0,0 @@
-# `@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

@@ -1,28 +0,0 @@
-# `@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

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

data/vendor/spinel/test/chained_ivar_write_split.rb

@@ -1,26 +0,0 @@
-# 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

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

data/vendor/spinel/test/chained_ivar_write_subclass.rb

@@ -1,26 +0,0 @@
-# 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

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

data/vendor/spinel/test/chained_or_assign_collection_array_nested.rb

@@ -1,32 +0,0 @@
-# 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

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

data/vendor/spinel/test/chained_or_assign_collection_element.rb

@@ -1,29 +0,0 @@
-# `(@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

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

data/vendor/spinel/test/chained_or_assign_collection_poly_array.rb

@@ -1,25 +0,0 @@
-# `(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

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

data/vendor/spinel/test/chained_or_assign_collection_str_keys.rb

@@ -1,24 +0,0 @@
-# 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

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

data/vendor/spinel/test/class_constant_sym_array.rb

@@ -1,19 +0,0 @@
-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_var_write.rb

@@ -1,19 +0,0 @@
-# ClassVariableWriteNode -- `@@var = value`.
-#
-# Spinel stores cvars as per-(class, name) C globals named
-# `cvar_<ClassName>_<var>`. The static declaration is emitted at
-# file scope alongside constants; ClassVariableReadNode (next
-# commit) consumes the same storage.
-#
-# This commit's test only exercises the write side -- a follow-up
-# Read commit prints @@count to verify round-trip.
-
-class Counter
-  @@count = 0
-end
-
-class Other
-  @@count = 99    # independent slot from Counter's @@count
-end
-
-puts "ok"

data/vendor/spinel/test/cls_ivar_type_parent_defer.rb

@@ -1,32 +0,0 @@
-# When the same ivar is registered on both a child class and a
-# parent, the C struct embeds the parent's field at the parent's
-# recorded type (`emit_class_fields` skips own copies that are also
-# in the parent chain). `cls_ivar_type` used to return the child's
-# own-table entry — letting downstream emit sites disagree with
-# the actual struct field type.
-
-class Parent
-  def initialize
-    @x = 0
-    @x = "s"      # heterogeneous int+string → @x widens to poly
-  end
-end
-
-class Child < Parent
-  def initialize
-    super
-    @x = 7        # write through the inherited (poly) slot
-  end
-  def read_x
-    @x
-  end
-end
-
-c = Child.new
-# Reading back via a Child-defined method that emits `self->iv_x`.
-# Without the fix, cls_ivar_type(Child, "@x") returned the int from
-# Child's own table; the struct field is sp_RbVal (Parent's poly);
-# the read miscompiled / yielded a garbage int. With the fix the
-# emit goes through the poly read path and unboxes correctly.
-v = c.read_x
-puts v        # 7

data/vendor/spinel/test/cls_method_object.rb

@@ -1,31 +0,0 @@
-# `Klass.method(:cls_meth)` returns a Method object that wraps a
-# class method (`def self.foo`).  Spinel previously only handled
-# instance-receiver `obj.method(:bar)`, so the class-receiver form
-# fell through to the unresolved-call fallback (emitting `0`) and
-# the captured "Method" was actually an int.  Subsequent
-# `.call(args)` then warned `cannot resolve call to 'call' on int`
-# and returned 0.
-#
-# Repro: capture two class methods on the same class, then call
-# both via `.call`.  The wrapping must:
-#   - infer the result as `obj_Method` (not int),
-#   - mark the underlying cls method as live (so the adapter
-#     trampoline's `sp_<Klass>_cls_<m>` reference resolves at
-#     link time — without the live-mark the body is DCE'd and the
-#     C link fails),
-#   - bind through an adapter that absorbs the dispatch ABI's
-#     `void *self` slot (class methods have no `self *` param).
-
-class CPU
-  def self.poke_nop(addr, data)
-    addr + data
-  end
-  def self.poke_log(addr, data)
-    addr * 2 + data
-  end
-end
-
-m1 = CPU.method(:poke_nop)
-m2 = CPU.method(:poke_log)
-puts m1.call(10, 5)
-puts m2.call(10, 5)

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

@@ -1,2 +0,0 @@
-15
-25

data/vendor/spinel/test/comparable.rb

@@ -1,21 +0,0 @@
-class Temperature
-  attr_reader :degrees
-  def initialize(d)
-    @degrees = d
-  end
-  def <=>(other)
-    @degrees - other.degrees
-  end
-  def <(other); (self <=> other) < 0; end
-  def >(other); (self <=> other) > 0; end
-  def ==(other); (self <=> other) == 0; end
-end
-
-t1 = Temperature.new(100)
-t2 = Temperature.new(200)
-t3 = Temperature.new(100)
-puts t1 < t2    # true
-puts t2 > t1    # true
-puts t1 == t3   # true
-puts t1 > t2    # false
-puts "done"

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

@@ -1,5 +0,0 @@
-true
-true
-true
-false
-done