rubyduino 0.1.1

data/vendor/spinel/test/stringio.rb

@@ -0,0 +1,84 @@
+require "stringio"
+
+# Basic write operations
+s = StringIO.new
+s.puts "hello"
+s.print "world"
+s.write "!"
+puts s.string
+puts s.pos
+puts s.size
+
+# Rewind and read
+s.rewind
+puts s.read
+puts s.pos
+
+# Initialize with string and read lines
+s2 = StringIO.new("abc\ndef\nghi")
+puts s2.gets
+puts s2.gets
+puts s2.eof?
+puts s2.gets
+puts s2.eof?
+
+# Seek and tell
+s3 = StringIO.new("hello world")
+s3.seek(6)
+puts s3.read
+puts s3.tell
+
+# Truncate
+s4 = StringIO.new
+s4.write "hello world"
+s4.truncate(5)
+puts s4.string
+
+# putc
+s5 = StringIO.new
+s5.putc(65)
+s5.putc(66)
+puts s5.string
+
+# Rewind, read with length
+s6 = StringIO.new("abcdefghij")
+puts s6.read(5)
+puts s6.read(3)
+
+# eof? and close
+s7 = StringIO.new("x")
+puts s7.eof?
+s7.read
+puts s7.eof?
+s7.close
+puts s7.closed?
+
+# Empty puts
+s8 = StringIO.new
+s8.puts
+s8.puts "line2"
+puts s8.string.length
+
+# getc and getbyte
+s9 = StringIO.new("AB")
+puts s9.getc
+puts s9.getbyte
+
+# flush, sync, isatty
+s10 = StringIO.new
+s10.flush
+puts s10.sync
+puts s10.isatty
+
+# StringIO stored in an instance variable
+class StringIOHolder
+  def initialize
+    @io = StringIO.new("abc")
+  end
+
+  def value
+    @io.string
+  end
+end
+
+puts StringIOHolder.new.value

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

@@ -0,0 +1,27 @@
+hello
+world!
+12
+12
+hello
+world!
+12
+abc
+def
+false
+ghi
+true
+world
+11
+hello
+AB
+abcde
+fgh
+false
+true
+true
+7
+A
+66
+true
+false
+abc

data/vendor/spinel/test/strip_nullable_int_cast.rb

@@ -0,0 +1,24 @@
+# `compile_typed_call_args` casts an int arg to an object-pointer
+# parameter via `(sp_<base> *)<expr>`. The base name was derived
+# from the raw param-type string. When the param type is nullable
+# (e.g. `obj_Foo?`, set when the writer-scan sees both `Foo.new`
+# and `nil` writes), the cast came out as `(sp_Foo? *)expr` and
+# gcc rejected the stray `?`.
+#
+# Repro: a setter-shaped method whose param is widened to
+# `obj_Foo?` by mixed Foo + nil writes, then called with an int-
+# typed argument (a method that returns int). The int-arg path
+# fires the cast.
+
+class Foo; end
+class C
+  def take(f)
+    @f = f
+  end
+  def get_int; 42; end
+end
+c = C.new
+c.take(Foo.new)
+c.take(nil)
+c.take(c.get_int)
+puts "ok"

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

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

data/vendor/spinel/test/struct.rb

@@ -0,0 +1,25 @@
+# Test Struct
+
+Point = Struct.new(:x, :y)
+
+p1 = Point.new(3, 4)
+puts p1.x       # 3
+puts p1.y       # 4
+
+p1.x = 10
+puts p1.x       # 10
+
+# Struct with methods
+Color = Struct.new(:r, :g, :b)
+
+c = Color.new(255, 128, 0)
+puts c.r        # 255
+puts c.g        # 128
+puts c.b        # 0
+
+# Struct synthetic constructor path should also handle iv_ prefixed names.
+Pair = Struct.new(:x, :iv_x)
+p2 = Pair.new(3, 4)
+puts p2.x + p2.iv_x   # 7
+p2.iv_x = 6
+puts p2.x + p2.iv_x   # 9

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

@@ -0,0 +1,8 @@
+3
+4
+10
+255
+128
+0
+7
+9

data/vendor/spinel/test/struct_inherit.rb

@@ -0,0 +1,28 @@
+class Point < Struct.new(:x, :y, keyword_init: true)
+  def distance
+    (x * x + y * y)
+  end
+
+  def to_s
+    "(#{x}, #{y})"
+  end
+end
+
+p1 = Point.new(x: 3, y: 4)
+puts p1.x         # 3
+puts p1.y         # 4
+puts p1.distance  # 25
+p1.x = 10
+puts p1.x         # 10
+
+class Entry < Struct.new(:name, :value, keyword_init: true)
+  def display
+    "#{name}=#{value}"
+  end
+end
+
+e = Entry.new(name: "foo", value: 42)
+puts e.name    # foo
+puts e.value   # 42
+
+puts "done"

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

@@ -0,0 +1,7 @@
+3
+4
+25
+10
+foo
+42
+done

data/vendor/spinel/test/struct_kw.rb

@@ -0,0 +1,16 @@
+# Test Struct with keyword_init
+
+Session = Struct.new(
+  :pid, :name, :status,
+  keyword_init: true
+)
+
+s = Session.new(pid: 123, name: "test", status: "running")
+puts s.pid     # 123
+puts s.name    # test
+puts s.status  # running
+
+s.status = "done"
+puts s.status  # done
+
+puts "done"

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

@@ -0,0 +1,5 @@
+123
+test
+running
+done
+done

data/vendor/spinel/test/subclass_inherits_module_parent.rb

@@ -0,0 +1,40 @@
+# `class Sub < Base` inside `module M` used to record `cls_parents`
+# as bare "Base" rather than "M_Base", so emit_class_fields' lookup
+# of the parent missed and Sub came out as an empty struct — every
+# field inherited from Base was dropped on the C side.
+
+module M
+  class Base
+    def initialize(x)
+      @x = x
+    end
+  end
+
+  class Sub < Base
+    def double
+      @x * 2
+    end
+    def x_plus(n)
+      @x + n
+    end
+  end
+
+  class Plain
+    def initialize
+      @y = 99
+    end
+  end
+
+  class PlainSub < Plain
+    def boost
+      @y + 1
+    end
+  end
+end
+
+s = M::Sub.new(7)
+puts s.double
+puts s.x_plus(100)
+
+ps = M::PlainSub.new
+puts ps.boost

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

@@ -0,0 +1,3 @@
+14
+107
+100

data/vendor/spinel/test/super_arg_cross_class_cast.rb

@@ -0,0 +1,39 @@
+# Two subclasses each call `super` from `initialize` forwarding a
+# differently-typed arg. The parent's param-type inference picks one
+# concrete C type, so the other subclass's super-forwarded arg ends
+# up with a mismatching C type at the call site without an explicit
+# cast.
+
+class Box
+  def initialize(v)
+    @v = v
+  end
+end
+
+class StrBox < Box
+  def initialize(s)
+    super
+    @len = s.length
+  end
+
+  def len
+    @len
+  end
+end
+
+class IntBox < Box
+  def initialize(n)
+    super
+    @doubled = n * 2
+  end
+
+  def doubled
+    @doubled
+  end
+end
+
+s = StrBox.new("hello")
+puts s.len
+
+n = IntBox.new(7)
+puts n.doubled

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

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

data/vendor/spinel/test/super_forwarding.rb

@@ -0,0 +1,25 @@
+# Bare `super` (no args, no parens) inside a constructor parses as
+# `ForwardingSuperNode`, not `SuperNode`. Without the
+# ForwardingSuperNode case, the call to the parent's `initialize`
+# was silently dropped — the parent's ivar setup never ran and the
+# child object was left in a half-initialized state.
+
+class Base
+  def initialize(x)
+    @x = x
+    @y = x * 10
+  end
+end
+
+class Child < Base
+  attr_reader :x, :y, :z
+  def initialize(x)
+    super              # bare — forwards x to Base#initialize
+    @z = x + 1
+  end
+end
+
+c = Child.new(3)
+puts c.x   # 3
+puts c.y   # 30
+puts c.z   # 4

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

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

data/vendor/spinel/test/sym_case.rb

@@ -0,0 +1,15 @@
+# Symbol in case/when
+def classify(sym)
+  case sym
+  when :red then "warm"
+  when :orange then "warm"
+  when :blue then "cool"
+  when :green then "cool"
+  else "unknown"
+  end
+end
+
+puts classify(:red)     # warm
+puts classify(:orange)  # warm
+puts classify(:blue)    # cool
+puts classify(:purple)  # unknown

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

@@ -0,0 +1,4 @@
+warm
+warm
+cool
+unknown

data/vendor/spinel/test/sym_poly_hash_merge.rb

@@ -0,0 +1,47 @@
+# `Hash#merge` on a Symbol-keyed hash with heterogeneous values
+# (Symbol => {Integer | String | Boolean | nil}) -- spinel
+# represents this as `sym_poly_hash`. Before this change spinel had
+# no dispatcher for non-mutating `merge` on sym_poly_hash, so the
+# call lowered to an empty hash and every subsequent lookup returned
+# nil.
+#
+# The poly-receiver `[]` arm covers the case where a local's static
+# type was widened to poly (e.g. by an `is_a?` branch) even though
+# the runtime value is a sym_poly_hash. `opt[:k]` then dispatches
+# via the emit_poly_builtin_dispatch helper rather than the typed
+# sym_poly_hash branch above.
+
+DEFAULTS = { a: 1, b: "two", c: true, d: nil, e: 16 }
+
+# 1. Non-mutating merge: result has overrides from b, other keys
+#    preserved from a.
+m = DEFAULTS.merge({ a: 99, b: "TWO" })
+puts m[:a]              # 99 (overridden)
+puts m[:b]              # TWO
+puts m[:c]              # true (preserved)
+puts m[:e]              # 16
+
+# 2. Original receiver is unchanged.
+puts DEFAULTS[:a]       # 1
+
+# 3. Symbol-key `[]` lookup on a poly-typed local. The is_a?(String)
+#    branch widens `opt`s static type to poly; the merge-result is
+#    boxed back into the same slot. spinel must dispatch the
+#    subsequent `opt[:k]` reads via the poly builtin path.
+def lookup(opt)
+  # Mixed-value override hash so spinel infers sym_poly_hash for the
+  # `is_a?(String)` boxed branch (and the explicit-Hash call site too).
+  opt = { a: 7, c: false } if opt.is_a?(String)
+  merged = DEFAULTS.merge(opt)
+  return merged[:a], merged[:b], merged[:e]
+end
+
+a, b, e = lookup("string-input")
+puts a                  # 7  (from the boxed hash inside the if branch)
+puts b                  # two
+puts e                  # 16
+
+a, b, e = lookup({ a: 100, b: "B", e: 99 })
+puts a                  # 100
+puts b                  # B
+puts e                  # 99

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

@@ -0,0 +1,11 @@
+99
+TWO
+true
+16
+1
+7
+two
+16
+100
+B
+99

data/vendor/spinel/test/symbol_ivar_reassign.rb

@@ -0,0 +1,25 @@
+# Reassigning an instance variable to a different symbol used to demote
+# its type to `poly` because `infer_ivar_init_type` reported `:foo` as
+# `string` while `infer_type` reported it as `symbol`. The mismatch
+# tripped `update_ivar_type`'s "old != new_type" branch, widening the
+# field to `sp_RbVal`. Subsequent assignments emitted `self->s = SPS_bar`
+# (sp_sym = mrb_int) into an `sp_RbVal` slot — a C type error.
+
+class C
+  def initialize
+    @s = :foo
+  end
+
+  def reset
+    @s = :bar
+  end
+
+  def show
+    @s
+  end
+end
+
+c = C.new
+puts c.show
+c.reset
+puts c.show

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

@@ -0,0 +1,2 @@
+foo
+bar

data/vendor/spinel/test/three_level_array_outer_index.rb

@@ -0,0 +1,87 @@
+# `[a, b, c, d].map { (0...M).map { (0..N).map { ... } } }` builds a
+# 3-level Array<Array<IntArray>>. The outer .map's receiver is an
+# array literal; spinel's compile_map_expr stored that receiver in a
+# C-stack temp without registering it with the GC. When the block
+# body's nested allocations crossed the GC threshold (~272 inner
+# rows triggered the first sp_gc_collect), the unrooted receiver was
+# freed mid-loop and the next iteration's `sp_IntArray_length(rc)`
+# read the len of whatever IntArray reused that heap slot — usually
+# the most recent inner (0..N).map result, length N+1.
+#
+# Symptom on master: `TBL.length` printed 8 instead of 4, and every
+# `TBL[X]` returned the same recycled inner row regardless of X.
+# The fix roots the receiver temp when its static type is a
+# GC-allocated pointer.
+#
+# A second related fix in compile_bracket_assign covers
+# `recv[start, len] = src` where recv is statically poly_array and
+# src is poly (e.g. `@bg_pixels[xfine, 8] = @bg_pattern_lut[idx]`
+# when bg_pattern_lut comes from a poly_array<poly_array<int_array>>
+# constant). Without the dispatch the slice assignment silently
+# became `recv[start] = len` and dropped the rhs entirely.
+
+# Inner range is sized large enough (>= ~272) that an inner GC
+# triggers during the outer .map's iteration. Using runtime-bound
+# indices (i, j, k) to read TBL[a][b][c] avoids spinel emitting the
+# `int >> literal_index & 1` bit-index warning branch (spinel
+# can't statically tell that TBL[a] is always an array, so it
+# generates both branches; the int-branch shift count >= 64
+# triggers -Werror in the test runner with literal indices).
+TBL = [10, 20, 30, 40].map do |a|
+  (0...500).map do |i|
+    (0..7).map do |j|
+      a + i + j
+    end
+  end
+end
+
+puts TBL.length          # 4
+puts TBL[0].length       # 500
+
+a0 = 0
+a1 = 1
+a2 = 2
+a3 = 3
+i0 = 0
+i499 = 499
+j0 = 0
+j7 = 7
+
+puts TBL[a0].length        # 500
+puts TBL[a0][i0].length    # 8
+puts TBL[a0][i0][j0]       # 10
+puts TBL[a1][i0][j0]       # 20
+puts TBL[a3][i0][j7]       # 47
+puts TBL[a2][i499][j0]     # 529
+puts TBL[a3][i499][j7]     # 546
+
+# Slice assign with poly_array recv + poly src — the
+# `@buf[start, len] = @table[a][i]` shape that @bg_pixels falls
+# into in optcarrot once TILE_LUT is no longer split.  @table is
+# poly_array<poly_array<int_array>>, so @table[a][i] is `poly`
+# (sp_RbVal).  @buf is sized via `[nil] * N` so it's poly_array
+# (sp_PolyArray *).  Without the dispatch fix the bracket-assign
+# falls through to single-elem write `@buf[start] = len`,
+# silently dropping the rhs.
+class Slicer
+  def initialize
+    @table = [10, 20, 30].map { |a| (0...4).map { |i| (0..3).map { |j| a + i + j } } }
+    @buf = [nil] * 7
+    @buf[0] = -1; @buf[1] = -1; @buf[2] = -1; @buf[3] = -1
+    @buf[4] = -1; @buf[5] = -1; @buf[6] = -1
+  end
+  def fill(a, i); @buf[1, 4] = @table[a][i]; end
+  def get(k); @buf[k]; end
+end
+
+s = Slicer.new
+s.fill(2, 1)
+puts s.get(0)            # -1
+puts s.get(1)            # 31
+puts s.get(2)            # 32
+puts s.get(3)            # 33
+puts s.get(4)            # 34
+puts s.get(5)            # -1
+s.fill(0, 0)
+puts s.get(1)            # 10
+puts s.get(4)            # 13

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

@@ -0,0 +1,17 @@
+4
+500
+500
+8
+10
+20
+47
+529
+546
+-1
+31
+32
+33
+34
+-1
+10
+13

data/vendor/spinel/test/toplevel_ivar_array.rb

@@ -0,0 +1,19 @@
+# Top-level instance variables: `@x` at script scope binds to the
+# main object, the same as inside an instance method. Spinel currently
+# emits `self->iv_x = ...` for ivar access but the script's top-level
+# function has no `self` parameter, so the C compiler errors with
+# `use of undeclared identifier 'self'`. The ivar read also falls
+# through type inference and gets defaulted to `int`, producing a
+# bogus "cannot resolve call to 'push' on int" warning before the
+# hard error.
+
+@n = 0
+@n = @n + 1
+@n = @n + 1
+puts @n
+
+@arr = []
+@arr.push(7)
+@arr.push(8)
+puts @arr.length
+@arr.each { |v| puts v }

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

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

data/vendor/spinel/test/truncate_module_method.rb

@@ -0,0 +1,46 @@
+# Issue #314: a user-defined module method named `truncate` was
+# matched by `infer_method_name_type`'s Float#truncate(n) → Float
+# arm purely on the method name, ignoring the receiver. Result: a
+# `ViewHelpers.truncate(s, length: 100)` call site (which returns
+# a string) inferred as float at the caller, and a poly-arg call
+# like `html_escape(truncate(s, length: 100))` boxed the string
+# return through `sp_box_float(const char *)` — invalid C.
+#
+# Surfaced via Roundhouse's emitted real-blog views; minimal repro
+# extracted from `app/views/articles/_article.rb`'s
+# `io << ViewHelpers.html_escape(ViewHelpers.truncate(article.body,
+# length: 100))` line.
+#
+# Fix: gate the rule on a Float receiver. Float#truncate(n) keeps
+# its float typing; module-method `truncate` falls through to the
+# user-method-return lookup so it picks up the actual declared
+# return type.
+
+module M
+  def self.html_escape(s)
+    return "" if s.nil?
+    s.to_s
+  end
+
+  def self.truncate(s, length: 30, omission: "...")
+    return "" if s.nil?
+    str = s.to_s
+    return str if str.length <= length
+    cutoff = length - omission.length
+    cutoff = 0 if cutoff < 0
+    "#{str[0, cutoff]}#{omission}"
+  end
+end
+
+# Force html_escape to take poly so the call site exercises the
+# arg-boxing path that picked sp_box_float pre-fix.
+puts M.html_escape(42)                                   # 42
+puts M.html_escape("hello")                              # hello
+puts M.html_escape(M.truncate("short text", length: 100)) # short text
+puts M.html_escape(M.truncate("a very long text indeed", length: 10)) # a very ...
+
+# Float#truncate(n) must still type as float — covers the rule's
+# original purpose.
+f = 1.234
+puts f.truncate(2)                                       # 1.23
+puts f.truncate(2) + 0.001                               # 1.2309999999999999

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

@@ -0,0 +1,6 @@
+42
+hello
+short text
+a very ...
+1.23
+1.2309999999999999

data/vendor/spinel/test/unbox_poly_index_in_dispatch.rb

@@ -0,0 +1,20 @@
+# `emit_poly_builtin_dispatch` referenced `arg_types` out of scope.
+# Without the fix, `(poly_recv)[poly_idx]` produced
+# `sp_PolyArray_get(arr, sp_RbVal_idx)` — passing sp_RbVal where
+# mrb_int is expected and failing the C compile.
+#
+# Trigger: poly recv (from heterogeneous Hash) + poly idx (also).
+
+class C
+  def initialize
+    @bag  = { "arr" => [100, 200, 300, 400], "lbl" => "x" }
+    @keys = { "i" => 2, "s" => "lbl" }
+  end
+  def at(k)
+    arr = @bag["arr"]      # poly
+    idx = @keys[k]         # poly
+    arr[idx]               # poly recv + poly idx
+  end
+end
+
+puts C.new.at("i").to_s    # use .to_s (handled separately) instead of .to_i

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

@@ -0,0 +1 @@
+300