rubyduino 0.1.1

data/vendor/spinel/test/inspect.rb

@@ -0,0 +1,86 @@
+# Primitives: .inspect as a method call
+
+# Integer
+puts 5.inspect
+puts (-42).inspect
+puts 0.inspect
+
+# Float
+puts 1.5.inspect
+puts 1.0.inspect
+puts (-3.25).inspect
+
+# String
+puts "hi".inspect
+puts "".inspect
+puts "a\nb".inspect
+puts "tab\there".inspect
+puts "quote\"inside".inspect
+puts "back\\slash".inspect
+
+# Symbol (regression)
+puts :foo.inspect
+
+# Boolean
+puts true.inspect
+puts false.inspect
+
+# nil
+puts nil.inspect
+
+# Interpolation via explicit .inspect call
+x = 42
+puts "got #{x.inspect}"
+
+# Kernel#p equivalence: p obj == puts(obj.inspect) for scalars
+p 5
+p 1.0
+p "hi"
+p :foo
+p true
+p nil
+
+# Arrays: .inspect + p
+p []
+p [1, 2, 3]
+p [-5, 0, 42]
+p [99]
+p [1.5, 2.0]
+p [1.0]
+p ["hello", "world"]
+p [""]
+p [:foo, :bar]
+
+# Heterogeneous / mixed-type arrays (poly_array)
+p [1, "x"]
+p [nil, :sym, 1.5]
+p [1, "two", :three, 4.0, true]
+p [false, nil]
+
+# Mixed arrays as a receiver (inspect / to_s as methods)
+mx = [1, "x"]
+puts mx.inspect
+puts mx.to_s
+
+# Array#inspect as a method call
+arr = [1, 2, 3]
+puts arr.inspect
+
+# Array#to_s is aliased to Array#inspect in CRuby
+puts arr.to_s
+
+# Interpolation uses to_s
+puts "got #{arr.inspect}"
+
+# From a method returning an array
+def make_arr; [10, 20, 30]; end
+p make_arr
+
+# puts on arrays: flatten, element-per-line (not inspect)
+puts [1, 2, 3]
+puts []
+puts ["a", "b"]
+puts [:x, :y]
+puts [1.5, 2.0]
+
+puts "done"

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

@@ -0,0 +1,52 @@
+5
+-42
+0
+1.5
+1.0
+-3.25
+"hi"
+""
+"a\nb"
+"tab\there"
+"quote\"inside"
+"back\\slash"
+:foo
+true
+false
+nil
+got 42
+5
+1.0
+"hi"
+:foo
+true
+nil
+[]
+[1, 2, 3]
+[-5, 0, 42]
+[99]
+[1.5, 2.0]
+[1.0]
+["hello", "world"]
+[""]
+[:foo, :bar]
+[1, "x"]
+[nil, :sym, 1.5]
+[1, "two", :three, 4.0, true]
+[false, nil]
+[1, "x"]
+[1, "x"]
+[1, 2, 3]
+[1, 2, 3]
+got [1, 2, 3]
+[10, 20, 30]
+1
+2
+3
+a
+b
+x
+y
+1.5
+2.0
+done

data/vendor/spinel/test/instance_eval_trampoline.rb

@@ -0,0 +1,88 @@
+# Inline-at-call-site arity-0 instance-eval trampoline.
+#
+# Full Ruby instance-eval is dynamic — `self` is rebound at runtime,
+# so AOT compilation needs static type information to resolve method
+# dispatch inside the block. Spinel's compromise: detect the exact
+# DSL trampoline shape `def m(&b); instance_eval(&b); end` at compile
+# time, and inline the block body at the call site with `self`
+# rebound to the receiver. Receiverless calls inside the spliced
+# body dispatch to the receiver's class via static type inference
+# (the new `@instance_eval_self_var` / `@instance_eval_self_type`).
+#
+# Anything other than the arity-0 single-statement shape falls
+# through to the previous silent no-op — by design.
+
+# 1. Basic trampoline: `recv.configure { add 10 }` rebinds self to
+#    the Builder instance, so `add(10)` resolves as Builder#add.
+class Builder
+  def initialize
+    @sum = 0
+  end
+
+  def add(n)
+    @sum = @sum + n
+  end
+
+  def total
+    @sum
+  end
+
+  def configure(&block)
+    instance_eval(&block)
+  end
+end
+
+b = Builder.new
+b.configure do
+  add(10)
+  add(20)
+  add(12)
+end
+puts b.total              #=> 42
+
+# 2. Multiple statements inside the block — each receiverless call
+#    dispatches against the rebound class, including reads.
+class Counter
+  def initialize
+    @n = 0
+  end
+
+  def bump
+    @n = @n + 1
+  end
+
+  def get
+    @n
+  end
+
+  def with(&block)
+    instance_eval(&block)
+  end
+end
+
+c = Counter.new
+c.with do
+  bump
+  bump
+  bump
+end
+puts c.get                #=> 3
+
+# 3. Nested trampolines compose: an outer Builder#configure block
+#    contains an inner Counter#with block. The splicer save/restores
+#    @instance_eval_self_var / @instance_eval_self_type, so the
+#    outer self is restored after the inner block returns.
+b2 = Builder.new
+c2 = Counter.new
+b2.configure do
+  add(7)
+  c2.with do
+    bump
+    bump
+  end
+  add(35)
+end
+puts b2.total             #=> 42
+puts c2.get               #=> 2
+
+puts "done"

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

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

data/vendor/spinel/test/int_bracket_skip_sym_idx.rb

@@ -0,0 +1,40 @@
+# Issue #314 (Roundhouse warnings family): `Integer#[idx]` codegen
+# fired for ANY `[]` call on an int-typed receiver, including the
+# common shape:
+#
+#   def self.from_raw(row)
+#     instance.id = row[:id] || 0
+#     ...
+#   end
+#
+# where `row` is an unpinned param whose type defaults to "int". The
+# `row[:id]` then lowered to `(row >> SPS_id) & 1` — shifting a
+# 64-bit int by the symbol's interned id (commonly >= 64) is
+# undefined behavior under -Wshift-count-overflow, and even when it
+# happens to compile the value is garbage.
+#
+# Fix: gate the bit-extract on the index's inferred type. A non-int
+# / non-poly index (typically a Symbol or String literal) is hash /
+# array subscript, never Integer-bit indexing — fall through to
+# the unresolved-call placeholder so the C compile sees the right
+# diagnostic instead of a warning + UB.
+
+# Genuine bit indexing — must still work.
+n = 0b1010
+puts n[0]                # 0
+puts n[1]                # 1
+puts n[2]                # 0
+puts n[3]                # 1
+
+# Hash-subscript shape on an unpinned param — the bug's repro.
+# Without the fix, `row[:k]` emits `(row >> SPS_k) & 1` and gcc/
+# clang flag the shift count. With the fix, this falls through to
+# the unresolved-call placeholder (the param type is unknown to
+# spinel here, since the function is never called), which is the
+# correct behavior — compilation succeeds without the bogus
+# bit-extract.
+def from_raw(row)
+  row[:id] || 0
+end
+
+puts "compiled-cleanly"

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

@@ -0,0 +1,5 @@
+0
+1
+0
+1
+compiled-cleanly

data/vendor/spinel/test/int_keyed_hash_lookup_as_array.rb

@@ -0,0 +1,19 @@
+# A Hash literal whose keys are the consecutive non-negative
+# integers 0..N-1 lowers to an internal Array. The runtime has no
+# `int_<X>_hash` slot, so a literal like
+#
+#   {0 => [...], 1 => [...]}
+#
+# previously fell through to the str_int_hash default and the
+# `[]` lookup miscompiled (warning: cannot resolve call to
+# 'length' on int — emitting 0 — followed by a runtime segfault
+# when the lookup chain dereferences the literal `0` as a pointer).
+#
+# Detection is AST-shape-only (IntegerNode keys with literal values
+# 0,1,...N-1 in source order). Any deviation (gap key, duplicate
+# key, non-integer key, splat) opts back into the regular
+# str_int_hash codegen, so existing hash literals are unchanged.
+
+TBL = {0 => [3, 7, 2, 6], 1 => [4, 0, 5, 1]}
+puts TBL[0].length      # 4
+puts TBL[1][2]          # 5

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

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

data/vendor/spinel/test/intarray_slice_assign_from_intarray_ptr_array_first.rb

@@ -0,0 +1,25 @@
+# `arr[start, len] = src` slice-assign where `src` came from
+# `<X>_ptr_array.first` (or `.last`). Spinel's compile_bracket_assign
+# already had a same-prefix slice-assign path for `int_array[i, n] =
+# int_array`, but `infer_type` for `.first` / `.last` fell through
+# to "int" on a `_ptr_array` receiver, so the slice-assign branch's
+# `infer_type(arg_ids[2]) == "int_array"` test missed and the call
+# silently lowered to `arr[start] = len` (using arg_ids[1] as the
+# value, dropping arg_ids[2] entirely).
+
+class C
+  def initialize
+    buf = (0...32).to_a
+    @banks = (0...2).map { buf.slice!(0, 8) }
+    @ref = [0] * 24
+    @ref[5, 8] = @banks.first
+    @ref[15, 8] = @banks.last
+  end
+
+  def show
+    @ref.each { |x| print x, " " }
+    puts
+  end
+end
+
+C.new.show

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

@@ -0,0 +1 @@
+0 0 0 0 0 0 1 2 3 4 5 6 7 0 0 8 9 10 11 12 13 14 15 0 

data/vendor/spinel/test/integer_div.rb

@@ -0,0 +1,21 @@
+# basic
+puts 7.div(2)
+puts 10.div(5)
+
+# exact
+puts 6.div(3)
+
+# negative — floor division rounds toward -infinity
+puts((-7).div(2))
+puts 7.div(-2)
+puts((-7).div(-2))
+
+# zero dividend
+puts 0.div(3)
+
+# one
+puts 1.div(1)
+puts((-1).div(1))
+
+# large
+puts 1000001.div(1000)

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

@@ -0,0 +1,10 @@
+3
+2
+2
+-4
+-4
+3
+0
+1
+-1
+1000

data/vendor/spinel/test/integer_div_by_zero.rb

@@ -0,0 +1,80 @@
+# Integer division / modulo / divmod / ceildiv by zero raises
+# ZeroDivisionError. Previously these operations triggered C
+# undefined behaviour (SIGFPE on x86) outside the longjmp net the
+# rescue keyword unwinds — see the now-stale comment in
+# test/endless_method_rescue.rb.
+#
+# Test uses `puts e` directly (which prints the message string in
+# spinel) rather than e.message — the .message dispatch lives on a
+# separate exception-bindings PR. The semantic test (raises and is
+# catchable) is independent.
+
+# Bare / catches as ZeroDivisionError
+begin
+  x = 10 / 0
+  puts "no raise: #{x}"
+rescue ZeroDivisionError => e
+  puts "caught div: #{e}"
+end
+
+# Bare % catches as ZeroDivisionError
+begin
+  x = 10 % 0
+  puts "no raise: #{x}"
+rescue ZeroDivisionError => e
+  puts "caught mod: #{e}"
+end
+
+# divmod (covers the inline-/ in compile_int_method_expr)
+begin
+  10.divmod(0)
+  puts "no raise"
+rescue ZeroDivisionError => e
+  puts "caught divmod: #{e}"
+end
+
+# ceildiv (was silently returning 0)
+begin
+  x = 10.ceildiv(0)
+  puts "no raise: #{x}"
+rescue ZeroDivisionError => e
+  puts "caught ceildiv: #{e}"
+end
+
+# pow with mod=0 (was silently returning 0)
+begin
+  x = 2.pow(10, 0)
+  puts "no raise: #{x}"
+rescue ZeroDivisionError => e
+  puts "caught powmod: #{e}"
+end
+
+# /= compound assignment
+begin
+  x = 10
+  x /= 0
+  puts "no raise: #{x}"
+rescue ZeroDivisionError => e
+  puts "caught /=: #{e}"
+end
+
+# %= compound assignment
+begin
+  x = 10
+  x %= 0
+  puts "no raise: #{x}"
+rescue ZeroDivisionError => e
+  puts "caught %=: #{e}"
+end
+
+# Bare rescue also catches (no class filter at all).
+begin
+  10 / 0
+rescue => e
+  puts "bare-rescue: #{e}"
+end
+
+# Float division by zero is NOT affected — IEEE 754 returns
+# Infinity / NaN. Spinel matches CRuby; no exception is raised.
+puts (1.0 / 0.0).infinite?
+puts (0.0 / 0.0).nan?

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

@@ -0,0 +1,10 @@
+caught div: divided by 0
+caught mod: divided by 0
+caught divmod: divided by 0
+caught ceildiv: divided by 0
+caught powmod: divided by 0
+caught /=: divided by 0
+caught %=: divided by 0
+bare-rescue: divided by 0
+1
+true

data/vendor/spinel/test/interp_method_widening.rb

@@ -0,0 +1,39 @@
+# Method called only inside string interpolation should still anchor its
+# parameter type. Pre-fix: scan_features didn't visit EmbeddedStatementsNode
+# bodies, so `cap(name)` inside `"#{...}"` was the only call site for `cap`,
+# its `s` param defaulted to int, and codegen produced a C compile error.
+
+def cap(s)
+  s + "_cap"
+end
+
+name = "frob"
+puts "lv_#{cap(name)}"
+
+# Same shape with two args, one of which is also a method call
+def join_with(a, b)
+  a + "_" + b
+end
+
+x = "hello"
+y = "world"
+puts "wrapped(#{join_with(x, y)})"
+
+# Nested interpolation containing a method call whose param widens to int
+def inc(n)
+  n + 1
+end
+
+puts "next=#{inc(10)}"
+
+# Method whose param widens to bool via interpolated boolean call
+def bang(p)
+  if p
+    "YES"
+  else
+    "no"
+  end
+end
+
+flag = true
+puts "answer: #{bang(flag)}"

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

@@ -0,0 +1,4 @@
+lv_frob_cap
+wrapped(hello_world)
+next=11
+answer: YES

data/vendor/spinel/test/interp_symbol.rb

@@ -0,0 +1,18 @@
+# InterpolatedSymbolNode -- `:"foo_#{x}"`.
+#
+# Lowered to InterpolatedStringNode + sp_intern at codegen side.
+# The parser emits InterpolatedSymbolNode with parts; codegen
+# treats it like InterpolatedStringNode then routes through
+# the intern helper for symbol identity.
+
+x = "world"
+sym = :"hello_#{x}"
+puts sym                # hello_world
+
+n = 42
+sym2 = :"item_#{n}"
+puts sym2               # item_42
+
+# Symbol passed through a method
+def kind(s) = s.to_s
+puts kind(:"prefix_#{x}")   # prefix_world

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

@@ -0,0 +1,3 @@
+hello_world
+item_42
+prefix_world

data/vendor/spinel/test/introspect.rb

@@ -0,0 +1,35 @@
+# Test respond_to?, is_a?, class name, to_s
+
+class Animal
+  def initialize(name)
+    @name = name
+  end
+  def name; @name; end
+  def speak; "..."; end
+end
+
+class Dog < Animal
+  def speak; "Woof!"; end
+  def fetch; "ball"; end
+end
+
+d = Dog.new("Rex")
+
+# is_a?
+puts d.is_a?(Dog)      # true
+puts d.is_a?(Animal)   # true
+
+# respond_to?
+puts d.respond_to?(:speak)   # true
+puts d.respond_to?(:fetch)   # true
+puts d.respond_to?(:fly)     # false
+
+# nil?
+puts nil.nil?          # true
+puts d.nil?            # false
+puts 0.nil?            # false
+
+# Integer predicates
+puts 0.zero?           # true
+puts 5.positive?       # true
+puts (-3).negative?    # true

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

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

data/vendor/spinel/test/issue176_empty_hash_default.rb

@@ -0,0 +1,34 @@
+# Issue #176: empty-Hash default parameter `def m(h = {})` used to
+# silently corrupt the caller-supplied Hash because unify_call_types
+# widened the param type to "poly" and the poly dispatch tree had no
+# arm for SymIntHash/StrIntHash. Hash variants now escalate the
+# str_int_hash empty default to the call-site type, mirroring the
+# int_array → typed-array escalation.
+
+class A
+  def initialize(attrs = {})
+    @x = attrs[:x]
+  end
+  def x; @x; end
+end
+
+puts A.new({x: 42}).x
+
+class B
+  def initialize(attrs = {})
+    @name = attrs[:name]
+  end
+  def name; @name; end
+end
+
+puts B.new({name: "alice"}).name
+
+# String-keyed hash also works.
+class C
+  def initialize(attrs = {})
+    @v = attrs["v"]
+  end
+  def v; @v; end
+end
+
+puts C.new({"v" => 7}).v

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

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

data/vendor/spinel/test/issue203_string_new.rb

@@ -0,0 +1,27 @@
+# Issue #203: `String.new` resolved to 0 because the constructor
+# dispatch had no String arm. Code that combined the result with
+# `<<` (the Rails view-emit accumulator pattern) failed to compile.
+
+# Bare String.new — empty mutable buffer.
+io = String.new
+io << "hello"
+puts io                   # hello
+
+# Constructor with seed.
+s = String.new("foo")
+s << "bar"
+puts s                    # foobar
+
+# Empty buffer reads as length 0.
+t = String.new
+puts t.length             # 0
+
+# Canonical Rails-style accumulator.
+def render(items)
+  io = String.new
+  io << "<ul>"
+  items.each { |item| io << "<li>" << item << "</li>" }
+  io << "</ul>"
+  io
+end
+puts render(["a", "b"])   # <ul><li>a</li><li>b</li></ul>

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

@@ -0,0 +1,4 @@
+hello
+foobar
+0
+<ul><li>a</li><li>b</li></ul>

data/vendor/spinel/test/issue204_user_find_fetch.rb

@@ -0,0 +1,25 @@
+# Issue #204: user-defined `find` / `fetch` were overridden by the
+# method-name dispatch's "int" fallback even when the receiver
+# wasn't a built-in collection. The body's actual return type
+# (string here) lost; the call site mistyped the result as int.
+
+# Class method form (canonical ActiveRecord finder shape).
+class Bag
+  def self.find(id); "row-#{id}"; end
+  def self.fetch(id); "fetched-#{id}"; end
+end
+puts Bag.find(42)        # row-42
+puts Bag.fetch(99)       # fetched-99
+
+# Instance method form on a hash-wrapping class.
+class C
+  def initialize(h); @h = h; end
+  def find(key); @h[key.to_sym]; end
+  def fetch(key); @h[key.to_sym]; end
+end
+c = C.new({a: "alpha", b: "beta"})
+puts c.find(:a)          # alpha
+puts c.fetch(:b)         # beta
+
+# Built-in collection dispatch still works (regression check).
+puts ["x", "y", "z"].find { |v| v == "y" }   # y

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

@@ -0,0 +1,5 @@
+row-42
+fetched-99
+alpha
+beta
+y