rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/ptr_array_to_poly_array_at_call.rb

@@ -0,0 +1,39 @@
+# #582 (Sam Ruby). Function param inferred as poly_array because
+# one caller passes a heterogeneous literal `[A.new, "x"]`, but
+# another caller passes a homogeneous PtrArray-shaped
+# `[A.new, A.new]` (sp_PtrArray of obj_A). The two array layouts
+# are incompatible at the C boundary (sp_PtrArray slots are raw
+# `void *`, sp_PolyArray slots are tagged sp_RbVal), so the
+# call site needs a conversion: allocate a fresh PolyArray and
+# box each PtrArray element via sp_box_obj.
+#
+# Fix: in compile_expr_for_expected_type, detect
+# `*_ptr_array → poly_array` at the call boundary and emit an
+# inline conversion loop. Element class id comes from the
+# ptr_array's elem type (`obj_A` → cls_id for A).
+
+class A
+  attr_reader :tag
+  def initialize(t = "default"); @tag = t; end
+end
+
+def take(arr)
+  arr.first
+end
+
+a_arr = [A.new("homogeneous"), A.new("entry2")]
+mixed = [A.new("mixed_a"), "x"]
+r1 = take(a_arr)
+r2 = take(mixed)
+# r1 should be an A instance (poly value carrying the A boxed via the conversion).
+# Verify by reading back the tag via runtime cls_id check.
+if r1.is_a?(A)
+  puts r1.tag
+else
+  puts "NOT_A"
+end
+if r2.is_a?(A)
+  puts r2.tag
+else
+  puts "NOT_A"
+end

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

@@ -0,0 +1,2 @@
+homogeneous
+mixed_a

data/vendor/spinel/test/public_send.rb

@@ -0,0 +1,12 @@
+# Issue #735. `recv.public_send(:meth, args)` should be identical to
+# `recv.send(:meth, args)` in spinel (visibility is not modeled in
+# static dispatch). The parser textually rewrites `.send(:foo)` and
+# `.__send__(:foo)` to `.foo`; now `.public_send(:foo)` (and the
+# string-form variant) take the same shortcut.
+
+puts "hello".public_send(:upcase)
+puts "world".public_send("upcase")
+puts 42.public_send(:to_s)
+
+# __send__ also keeps working (existing path).
+puts "x".__send__(:upcase)

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

@@ -0,0 +1,4 @@
+HELLO
+WORLD
+42
+X

data/vendor/spinel/test/puts_class_value.rb

@@ -0,0 +1,10 @@
+# `puts` on a value-type sp_Class (from `obj.class`) should render
+# the class name, not `printf("%lld", (long long)struct_value)`.
+class Counter
+  def initialize; @count = 0; end
+  def increment; self; end
+end
+
+c = Counter.new
+puts c.increment.class
+puts Counter

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

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

data/vendor/spinel/test/puts_nil.rb

@@ -0,0 +1,7 @@
+# `puts nil` (a nil literal) and `puts nil.itself` print a single empty
+# line, not `0`. (A nil-*typed* method/ivar that carries a real value is
+# deliberately left on the value path, so this gates on the syntactic
+# form, not the inferred type.)
+puts nil
+puts nil.itself
+puts "end"

data/vendor/spinel/test/raise_reraise_in_def.rb

@@ -0,0 +1,44 @@
+# Phase 1A: bare `raise` (re-raise) inside a def's rescue clause.
+# Pre-fix the codegen routed the surrounding begin/rescue's body
+# through compile_body_into which uses compile_expr for the last
+# stmt; compile_expr's raise arm ignored the 2-arg form and emitted
+# `sp_raise(<class_expr>)` -- passing an sp_Class compound literal to
+# sp_raise(const char *), C compile fail. Fix: expr-form raise now
+# mirrors compile_control_call_stmt's 2-arg handling
+# (sp_raise_cls("ClassName", msg)).
+
+def helper
+  begin
+    raise StandardError, "inner"
+  rescue => e
+    raise
+  end
+end
+
+begin
+  helper
+rescue => e
+  puts "outer: #{e.class}: #{e.message}"
+end
+
+# Variant: 2-arg raise as the only statement (no rescue, propagates).
+def thrower
+  raise ArgumentError, "from thrower"
+end
+
+begin
+  thrower
+rescue ArgumentError => e
+  puts "caught: #{e.message}"
+end
+
+# Variant: 1-arg raise (string only) in def + outer rescue.
+def thrower2
+  raise "plain message"
+end
+
+begin
+  thrower2
+rescue => e
+  puts "got: #{e.class}: #{e.message}"
+end

data/vendor/spinel/test/raise_unless_isa_narrow.rb

@@ -0,0 +1,72 @@
+# #493. `raise ... unless x.is_a?(C)` (and the equivalent
+# `if !x.is_a?(C); raise ...; end` shape) is a definite-throw
+# type assertion: when control reaches the statement after the
+# guard, `x` is provably of class `C`. The repro from the issue:
+#
+#   def process(x)
+#     raise TypeError, "expected A" unless x.is_a?(A)
+#     puts x.body
+#   end
+#
+# pre-fix emitted a full cls_id-switch over every class with a
+# same-named field after the guard (sp_box_int for B#body's int,
+# sp_box_str for A#body's string, then sp_poly_puts on the boxed
+# result). post-fix the guard's narrow flows through to a single
+# cls_id arm and the field read lowers to a direct
+# `((sp_A *)lv_x.v.p)->iv_body` chain.
+#
+# Implementation: the analyze-side body walkers
+# (scan_new_calls / collect_return_types_nid /
+# scan_cls_method_calls) plus the codegen-side compile_body_return
+# now push a sibling-scope type narrow when a stmt's
+# parse_raise_guard_narrow recognizes the shape; the narrow stays
+# pushed for the remainder of the StatementsNode. infer_type at
+# codegen consults the narrow stack before honouring the
+# pre-narrow @nd_inferred_type cache for `LV(narrowed).attr_reader`
+# call shapes, so attr_reader resolution returns the narrowed
+# class's static ivar type rather than the wider pre-narrow poly.
+
+class A
+  attr_accessor :body
+  def initialize; @body = "from-A"; end
+end
+
+class B
+  attr_accessor :body
+  def initialize; @body = 42; end
+end
+
+def pick(n)
+  n > 0 ? A.new : B.new
+end
+
+def process_unless(x)
+  raise "expected A" unless x.is_a?(A)
+  puts x.body
+end
+
+def process_if_negated(x)
+  if !x.is_a?(A)
+    raise "expected A"
+  end
+  puts x.body
+end
+
+# Both spellings should resolve identically -- single A#body
+# dispatch, no boxing through sp_RbVal.
+process_unless(pick(1))
+process_if_negated(pick(1))
+
+# Multiple guards in sequence accumulate narrows.
+class S
+  attr_accessor :name
+  def initialize; @name = "sized"; end
+end
+
+def render(s, t)
+  raise "expected S" unless s.is_a?(S)
+  raise "expected S" unless t.is_a?(S)
+  puts s.name + "/" + t.name
+end
+
+render(S.new, S.new)

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

@@ -0,0 +1,3 @@
+from-A
+from-A
+sized/sized

data/vendor/spinel/test/range_and_array_range_args.rb

@@ -0,0 +1,43 @@
+# Cluster of "Range struct passed where mrb_int expected" C errors:
+#   #1247 rand(range) / rand(float)
+#   #1234 Range#cover? with a Range argument
+#   #1228 Range#first(n) / #last(n) / #count
+#   #1240 Array#values_at with a Range argument
+#   #1224 Array#fill(value, range)
+# Each used to either emit a C type error (sp_Range fed to an mrb_int
+# operand) or silently return the wrong value.
+
+# #1247 — rand with a range / float arg. Values are nondeterministic,
+# so assert membership rather than the value.
+vi = rand(1..6)
+puts(vi >= 1 && vi <= 6)
+puts vi.class
+vf = rand(1.0..10.0)
+puts(vf >= 1.0 && vf < 10.0)
+puts vf.class
+
+# #1234 — cover? with a Range argument
+puts (1..10).cover?(5..8)
+puts (1..10).cover?(5..12)
+puts (1..10).cover?(5)
+
+# #1228 — first(n) / last(n) / count
+p (1..10).first(3)
+p (1..10).last(3)
+p (1...10).last(3)
+p (1..10).first(20)
+puts (1..10).count
+puts (1...10).count
+
+# #1240 — values_at with a Range argument
+p [10, 20, 30, 40, 50].values_at(1..3)
+p [10, 20, 30, 40, 50].values_at(0, 2, 4)
+p ["a", "b", "c", "d"].values_at(1..2)
+
+# #1224 — fill(value, range)
+a = [1, 2, 3, 4, 5]
+a.fill(0, 2..4)
+p a
+b = [1, 2, 3, 4, 5]
+b.fill(9, 1...3)
+p b

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

@@ -0,0 +1,18 @@
+true
+Integer
+true
+Float
+true
+false
+true
+[1, 2, 3]
+[8, 9, 10]
+[7, 8, 9]
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+10
+9
+[20, 30, 40]
+[10, 30, 50]
+["b", "c"]
+[1, 2, 0, 0, 0]
+[1, 9, 9, 4, 5]

data/vendor/spinel/test/range_begin_end_polyarr_include_delete_bang.rb

@@ -0,0 +1,21 @@
+# Three small adjacent fixes:
+#   - Range#begin / Range#end (aliases of first / last)
+#   - Array#include? on poly_array
+#   - String#delete_prefix! / delete_suffix! on mutable_str
+
+puts (1..10).begin
+puts (1..10).end
+
+a = [1, "hello", 3.0]
+puts a.include?(1)
+puts a.include?("hello")
+puts a.include?(3.0)
+puts a.include?(99)
+
+s = String.new("hello world")
+s.delete_prefix!("hello ")
+puts s.to_s
+
+s2 = String.new("hello world")
+s2.delete_suffix!(" world")
+puts s2.to_s

data/vendor/spinel/test/range_bsearch.rb

@@ -0,0 +1,11 @@
+# Integer Range#bsearch in find-minimum mode: the block returns truthy
+# for the upper half; bsearch returns the smallest member where it does,
+# or nil when no member qualifies.
+p (1..100).bsearch { |x| x >= 42 }
+p (1..100).bsearch { |x| x >= 1 }
+p (1..100).bsearch { |x| x >= 100 }
+p (1..100).bsearch { |x| x >= 200 }
+p (0...10).bsearch { |x| x >= 7 }
+p (0...10).bsearch { |x| x >= 9 }
+p (0...10).bsearch { |x| x >= 10 }
+p (5..5).bsearch { |x| x >= 5 }

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

@@ -0,0 +1,8 @@
+42
+1
+100
+nil
+7
+9
+nil
+5

data/vendor/spinel/test/range_case_eq_type_mismatch.rb

@@ -0,0 +1,10 @@
+# Range#=== (and cover?/include?) on a String range with a non-String argument
+# returns false, like CRuby, rather than feeding a non-pointer to strcmp (which
+# segfaulted). String-in-string-range and numeric ranges are unaffected.
+p(('A'..'C') === 20)
+p(('A'..'C') === 'B')
+p(('A'..'C') === 'Z')
+p(('a'..'z') === 'm')
+p(('a'..'z').cover?(5))
+p((1..5) === 3)
+p((1..5) === 9)

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

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

data/vendor/spinel/test/range_each_fusion.rb

@@ -0,0 +1,109 @@
+# Range#each over a literal numeric range should fuse to a tight C
+# for-loop with bounds inlined. Output is identical to the unfused
+# path; this test pins behavioural parity. The perf win shows up in
+# the generated C — no sp_Range struct copy on the loop's hot path.
+
+# --- Basic bounds ---
+
+# Inclusive range, accumulator
+sum = 0
+(1..10).each { |i| sum = sum + i }
+puts sum
+
+# Exclusive range — last value is excluded
+sum_excl = 0
+(1...10).each { |i| sum_excl = sum_excl + i }
+puts sum_excl
+
+# Negative bounds
+neg_sum = 0
+(-3..3).each { |i| neg_sum = neg_sum + i }
+puts neg_sum
+
+# Crosses zero, exclusive
+zero_sum = 0
+(-2...2).each { |i| zero_sum = zero_sum + i }
+puts zero_sum
+
+# --- Edge sizes ---
+
+# Single-element inclusive range
+hits = 0
+(7..7).each { |i| hits = hits + 1 }
+puts hits
+
+# Empty exclusive range (start == end, exclusive)
+empties = 0
+(5...5).each { |i| empties = empties + 1 }
+puts empties
+
+# Zero-element inclusive range at the origin
+zero_hits = 0
+(0..0).each { |i| zero_hits = zero_hits + 1 }
+puts zero_hits
+
+# Decreasing range — start > end. CRuby yields zero times; the
+# fused for-loop's `i <= hi` check is false on entry.
+dec_count = 0
+(10..1).each { |i| dec_count = dec_count + 1 }
+puts dec_count
+
+# Decreasing exclusive range — same zero-iteration shape.
+dec_excl = 0
+(10...1).each { |i| dec_excl = dec_excl + 1 }
+puts dec_excl
+
+# --- Block-param scoping ---
+
+# Block param doesn't leak when its name is distinct from outer
+# locals. (Same-name shadowing is a pre-existing spinel-wide
+# limitation in compile_each_block — both this fusion path and the
+# generic sp_Range path emit the block param as `lv_<name>`, which
+# collides with an outer `lv_<name>` of the same name. Out of scope
+# for this perf PR; see PR body.)
+outer_v = 42
+(1..5).each { |inner| outer_v = outer_v + inner }
+puts outer_v
+
+# --- Non-trivial bounds ---
+
+# Non-literal bounds (variable-bounded range) — falls back to the
+# generic sp_Range path. Behaviour must still match.
+lo = 2
+hi = 6
+var_sum = 0
+(lo..hi).each { |x| var_sum = var_sum + x }
+puts var_sum
+
+# Parens-wrapped range — `((1..5))` is a ParenthesesNode wrapping a
+# RangeNode. The fusion recognizer must unwrap parens before
+# deciding whether to inline.
+p_sum = 0
+((1..5)).each { |i| p_sum = p_sum + i }
+puts p_sum
+
+# --- Control flow inside the loop ---
+
+# `break` exits the loop early; the accumulator captures only the
+# values seen before the break.
+early = 0
+(1..100).each { |i| break if i > 5; early = early + i }
+puts early
+
+# `next` skips the body for the current iteration; even values
+# contribute, odd values are skipped.
+even_sum = 0
+(1..10).each { |i| next if i % 2 != 0; even_sum = even_sum + i }
+puts even_sum
+
+# --- Nesting ---
+
+# Nested ranges
+total = 0
+(1..3).each { |i| (1..3).each { |j| total = total + i * j } }
+puts total
+
+# Triple-nested with mixed inclusive/exclusive
+mixed = 0
+(1..2).each { |a| (1...3).each { |b| (0..1).each { |c| mixed = mixed + a * b + c } } }
+puts mixed

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

@@ -0,0 +1,16 @@
+55
+45
+0
+-2
+1
+0
+1
+0
+0
+57
+20
+15
+15
+30
+36
+22

data/vendor/spinel/test/range_each_no_block.rb

@@ -0,0 +1,5 @@
+# Range#each without a block returns an Enumerator; spinel materializes
+# the element array so chaining works.
+p((1..3).each.to_a)
+p((1...4).each.to_a)
+p((5..8).each.to_a.length)

data/vendor/spinel/test/range_equality.rb

@@ -0,0 +1,9 @@
+# Range#== / #eql? compare first, last, and exclusivity; a non-range is
+# never equal.
+p((1..5) == (1..5))
+p((1..5) == (1..6))
+p((1...5) == (1..5))
+p((1..5) == 5)
+p((1..5).eql?(1..5))
+p((1..5) != (1..6))
+p((1..5) != (1..5))

data/vendor/spinel/test/range_exclude_end_size.rb

@@ -0,0 +1,24 @@
+# Non-literal ranges: passing through a method parameter defeats
+# compile-time constant-folding, so `exclude_end?`/`size`/`count`/
+# `length` must read the runtime `excl` flag off the sp_Range struct.
+def report(r)
+  puts r.exclude_end?
+  puts r.size
+  puts r.count
+  puts r.length
+end
+
+report(1...5)
+report(1..5)
+
+# Literal ranges: compile-time receiver -- regression guard.
+puts (1...5).exclude_end?
+puts (1..5).exclude_end?
+puts (1...5).size
+puts (1..5).size
+puts (1...5).count
+puts (1..5).count
+puts (0...10).size
+puts (0..10).size
+puts (1...5).length
+puts (1..5).length

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

@@ -0,0 +1,18 @@
+true
+4
+4
+4
+false
+5
+5
+5
+true
+false
+4
+5
+4
+5
+10
+11
+4
+5

data/vendor/spinel/test/range_exclusive_nonliteral.rb

@@ -0,0 +1,34 @@
+# Exclusive ranges (`...`) held in a variable carry exclude_end at
+# runtime via the sp_Range struct, so max / include? / to_a / each /
+# map / size / step all stop one short of the end — matching CRuby
+# and the literal-range forms.
+r = 1...5
+p r.max
+p r.min
+p r.first
+p r.last
+p r.to_a
+p r.include?(5)
+p r.include?(4)
+p r.cover?(5)
+p r.size
+p r.count
+
+sum = 0
+r.each { |i| sum += i }
+p sum
+p r.map { |i| i * 2 }
+
+# Literal exclusive forms were also affected by the shared max /
+# include? codegen path.
+p((1...5).max)
+p((1...5).include?(5))
+p((1...5).to_a)
+
+# Inclusive ranges are unchanged.
+ri = 1..5
+p ri.max
+p ri.last
+p ri.to_a
+p ri.include?(5)
+p ri.size

data/vendor/spinel/test/range_overlap_array_flatten_depth.rb

@@ -0,0 +1,14 @@
+# Range#overlap? on two numeric ranges, plus Array#flatten(n)
+# with a depth-bounded variant.
+
+puts (1..5).overlap?(4..10)
+puts (1..3).overlap?(5..10)
+puts (5..10).overlap?(1..3)
+puts (1..10).overlap?(20..30)
+
+# Depth-bounded flatten.
+puts [[1, [2, [3, [4]]]]].flatten(1).inspect
+puts [[1, [2, [3, [4]]]]].flatten(2).inspect
+puts [[1, [2, [3, [4]]]]].flatten(3).inspect
+# Unbounded still works (no arg).
+puts [[1, [2, [3]]]].flatten.inspect

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

@@ -0,0 +1,8 @@
+true
+false
+false
+false
+[1, [2, [3, [4]]]]
+[1, 2, [3, [4]]]
+[1, 2, 3, [4]]
+[1, 2, 3]

data/vendor/spinel/test/range_step.rb

@@ -0,0 +1,15 @@
+# Issue #731. `(a..b).step(k)` without a block should return an
+# IntArray of stepped values. spinel used to fall through to the
+# unresolved-call warning, then `.to_a` on the int 0 segfaulted.
+
+puts (1..10).step(3).to_a.inspect
+puts (0..20).step(5).to_a.inspect
+
+# Inclusive vs exclusive end:
+puts (1...10).step(3).to_a.inspect
+
+# step larger than range -> single element.
+puts (1..10).step(100).to_a.inspect
+
+# step exactly hits the end.
+puts (1..10).step(1).to_a.inspect

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

@@ -0,0 +1,5 @@
+[1, 4, 7, 10]
+[0, 5, 10, 15, 20]
+[1, 4, 7]
+[1]
+[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

data/vendor/spinel/test/range_string_cover.rb

@@ -0,0 +1,10 @@
+# Range#include? / cover? / === on string ranges. Spinel inlines
+# strcmp bounds for literal string-range receivers rather than
+# trying to fit the receiver into the int-only sp_Range struct.
+
+puts ("a".."z").include?("m")
+puts ("a".."z").cover?("m")
+puts ("a".."z").include?("Z")
+puts ("a".."z").cover?("a")
+puts ("a".."z").cover?("z")
+puts ("a"..."z").cover?("z")  # exclusive end

data/vendor/spinel/test/rational_complex_literals.rb

@@ -0,0 +1,27 @@
+# Issues #840 #841 #872: Imaginary, Rational literals + Integer#quo.
+# Both surface as value-type structs (sp_Complex, sp_Rational).
+# Integer#quo returns a Rational. v1 scope: literal forms +
+# .inspect/.to_s; arithmetic between mixed Integer/Rational/Complex
+# is deferred to a follow-up.
+
+# Imaginary literals
+puts 1i.inspect
+puts 2i.inspect
+puts 3.0i.inspect
+
+# Imaginary parts via .real / .imag
+puts 5i.real
+puts 5i.imaginary
+
+# Rational literals (reduced by prism)
+puts 3r.inspect
+puts 4r.inspect
+
+# Integer#quo
+puts 7.quo(2).inspect
+puts 10.quo(4).inspect
+puts 100.quo(5).inspect
+
+# numerator / denominator
+puts 7.quo(2).numerator
+puts 7.quo(2).denominator

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

@@ -0,0 +1,12 @@
+(0+1i)
+(0+2i)
+(0+3i)
+0.0
+5.0
+(3/1)
+(4/1)
+(7/2)
+(5/2)
+(20/1)
+7
+2