rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/test/int_int_hash_literal.rb

@@ -0,0 +1,13 @@
+# Int-keyed, int-valued hash literals build a native IntIntHash
+# (previously misrouted to StrIntHash, passing int keys as char* and
+# crashing). Reads, []= writes, and length all work.
+h = {1 => 10, 2 => 20, 3 => 30}
+puts h[1]
+puts h[2]
+puts h[3]
+h[4] = 40
+puts h[4]
+puts h.length
+h[2] = 222
+puts h[2]
+puts h.length

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

@@ -0,0 +1,7 @@
+10
+20
+30
+40
+4
+222
+4

data/vendor/spinel/test/int_int_hash_missing_key_nil.rb

@@ -0,0 +1,10 @@
+h = {1 => 10, 2 => 20}
+p h[99]
+p h[99].nil?
+p h[99].inspect
+p(h[99] || 42)
+v = h[99]
+p v.nil?
+p(v || 7)
+p h[1]
+p(h[1] + 1)

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

@@ -0,0 +1,8 @@
+nil
+true
+"nil"
+42
+true
+7
+10
+11

data/vendor/spinel/test/int_opt_p_inspect.rb

@@ -0,0 +1,8 @@
+# `p` and inspect on a nullable int (int?) print "nil" for the
+# missing/zero-sentinel case, not blank or the raw sentinel.
+p 0.nonzero?
+p 42.nonzero?
+p [].first
+x = 0.nonzero?
+p x
+puts 0.nonzero?.inspect

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

@@ -0,0 +1,5 @@
+nil
+42
+nil
+nil
+nil

data/vendor/spinel/test/int_overflow_promote.rb

@@ -0,0 +1,41 @@
+# Existing bigint pattern detection catches `x *= y inside while`
+# (and similar shapes); the result should be the full arbitrary-
+# precision Ruby answer rather than a wrapped int64. Surface
+# guard for the `sp_bigint_to_s` fast-path bug fixed alongside
+# `--int-overflow=promote`: values just past 2^63 used to print
+# wrapped because the fast path always cast through int64.
+# Without the fix `2**63` printed as `-9223372036854775808` even
+# though the bigint internally held the correct unsigned value.
+#
+# The linear-sum / non-multiplicative shapes that require the new
+# `promote` mode to escape mrb_int width are exercised manually
+# (the test harness here always builds with the raise/wrap
+# helpers, not promote, so an analyzer-side rewrite of int
+# locals isn't visible to it).
+
+# 2**63 -- exact boundary where the old fast path wrapped.
+m = 1
+i = 0
+while i < 63
+  m = m * 2
+  i = i + 1
+end
+puts m
+
+# 2**100 -- deeper into multi-limb territory.
+m = 1
+i = 0
+while i < 100
+  m = m * 2
+  i = i + 1
+end
+puts m
+
+# Factorial of 25 -- classic bigint, well past int64.
+n = 1
+i = 1
+while i <= 25
+  n = n * i
+  i = i + 1
+end
+puts n

data/vendor/spinel/test/int_overflow_raises.rb

@@ -0,0 +1,34 @@
+# Integer arithmetic that overflows mrb_int (int64) raises
+# RangeError rather than silently wrapping. spinel uses
+# `__builtin_add_overflow` / `_sub_overflow` / `_mul_overflow`
+# at the codegen-emit step for binary `+ - *` on int operands;
+# the helpers (defined as statement-expression macros in
+# sp_runtime.h) raise on overflow and otherwise reduce to the
+# bare arithmetic op. BIGINT.md option β.
+#
+# Non-overflowing arithmetic must still produce the expected
+# native-int result, and `rescue` must catch the raise so the
+# program can continue.
+
+# Sanity: non-overflowing arithmetic still works.
+puts 100 + 200
+puts 1000 - 500
+puts 6 * 7
+
+# Each of the three operators raises on overflow.
+[:plus, :minus, :mul].each do |op|
+  begin
+    huge = 9_223_372_036_854_775_000
+    case op
+    when :plus
+      x = huge + 9_223_372_036_854_775_000
+    when :minus
+      x = -huge - 9_223_372_036_854_775_000
+    when :mul
+      x = huge * 1000
+    end
+    puts "no raise from #{op}: #{x}"
+  rescue RangeError => e
+    puts "#{op}: caught #{e.message}"
+  end
+end

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

@@ -0,0 +1,6 @@
+300
+500
+42
+plus: caught integer overflow in +
+minus: caught integer overflow in -
+mul: caught integer overflow in *

data/vendor/spinel/test/int_round_large_precision.rb

@@ -0,0 +1,11 @@
+# Integer#round/ceil/floor/truncate(ndigits) must use exact integer
+# arithmetic: a double-based implementation loses precision above 2^53
+# and casting pow(10,-nd) is undefined once 10^(-nd) > INT64_MAX.
+p 1000000000000000005.round(-1)   # 1000000000000000010 (>2^53: float would drop the 5)
+p 9007199254740993.round(-3)      # 9007199254741000
+p 9007199254740993.floor(-3)      # 9007199254740000
+p 9007199254740993.ceil(-3)       # 9007199254741000
+p 9007199254740993.truncate(-3)   # 9007199254740000
+p(-1000000000000000005.round(-1)) # -1000000000000000010
+p 123.round(-20)                  # 0  (10^20 unrepresentable -> 0, no UB)
+p 123.ceil(-20)                   # 0

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

@@ -0,0 +1,8 @@
+1000000000000000010
+9007199254741000
+9007199254740000
+9007199254741000
+9007199254740000
+-1000000000000000010
+0
+0

data/vendor/spinel/test/integer_argument_error.rb

@@ -0,0 +1,116 @@
+# Integer(s) raises ArgumentError on unparseable input, matching
+# CRuby semantics. Previously spinel emitted bare strtoll(s, NULL, 10)
+# which silently returned 0 for invalid input — that meant
+# `Integer(s) rescue 0` always took the main branch and the rescue
+# never fired.
+#
+# Test uses same-type rescue fallbacks (int + int) to avoid the
+# int+string type-mismatch issue (a separate poly-boxing PR). For
+# the bare-rescue path, e.g. `rescue ArgumentError => e`, we use
+# `puts e` directly — exception .message dispatch lives on a
+# separate exception-bindings PR.
+
+# Valid inputs unchanged
+a = (Integer("42") rescue -1)
+puts a
+b = (Integer("0") rescue -1)
+puts b
+c = (Integer("-7") rescue -1)
+puts c
+d = (Integer("+5") rescue -1)
+puts d
+
+# Whitespace handling per CRuby (leading/trailing whitespace ok).
+# Includes \t \n \r \v \f — all should be skipped (isspace covers
+# them; the previous manual `c == ' ' || c == '\t' || c == '\n' ||
+# c == '\r'` check missed \v and \f).
+e = (Integer("  -7  ") rescue -1)
+puts e
+e_tab = (Integer("\t42\t") rescue -1)
+puts e_tab
+e_nl = (Integer("\n42\n") rescue -1)
+puts e_nl
+e_cr = (Integer("\r42\r") rescue -1)
+puts e_cr
+e_vt = (Integer("\v42\v") rescue -1)
+puts e_vt
+e_ff = (Integer("\f42\f") rescue -1)
+puts e_ff
+e_mix = (Integer("  \t\n -7 \r\f ") rescue -1)
+puts e_mix
+
+# Sign handling
+sign_pos_zero = (Integer("+0") rescue -1); puts sign_pos_zero
+sign_neg_zero = (Integer("-0") rescue -1); puts sign_neg_zero
+sign_plus_sp  = (Integer("+ 7") rescue -1); puts sign_plus_sp   # space between sign and digit → invalid
+sign_minus_sp = (Integer("- 7") rescue -1); puts sign_minus_sp
+sign_double   = (Integer("++7") rescue -1); puts sign_double    # double-sign → invalid
+sign_bare     = (Integer("+")   rescue -1); puts sign_bare      # bare sign → invalid
+
+# Edge magnitudes within mrb_int range
+ll_max = (Integer("9223372036854775807")  rescue -1); puts ll_max   # LLONG_MAX
+ll_min = (Integer("-9223372036854775808") rescue -1); puts ll_min   # LLONG_MIN
+
+# Invalid inputs now raise (caught by rescue, returns -1)
+f = (Integer("xyz") rescue -1); puts f
+g = (Integer("") rescue -1); puts g
+h = (Integer("   ") rescue -1); puts h
+ii = (Integer("12abc") rescue -1); puts ii
+j = (Integer("12.5") rescue -1); puts j
+
+# Trailing-junk variants
+trail_junk      = (Integer("42x") rescue -1);          puts trail_junk
+trail_junk_ws   = (Integer("42 x") rescue -1);         puts trail_junk_ws       # whitespace then junk
+trail_nl_junk   = (Integer("42\n garbage") rescue -1); puts trail_nl_junk
+trail_only_ws   = (Integer("42 ") rescue -1);          puts trail_only_ws       # bare trailing whitespace OK
+
+# Leading-junk variants
+lead_junk    = (Integer("x42") rescue -1);    puts lead_junk
+lead_ws_junk = (Integer(" x 42") rescue -1);  puts lead_ws_junk
+
+# Hex prefixes ("0x10") and underscore separators ("12_345") are
+# CRuby-supported but Spinel's base-10 strtoll path doesn't parse
+# them. Documented in the PR's "Out of scope" — not exercised here
+# because the test compares spinel output against MRI directly,
+# and we'd diverge.
+
+# Bare rescue catches and lets us see the error message.
+# Also exercises the GC-root path: the message is allocated via
+# sp_sprintf (str-heap) and stored in sp_exc_msg; reading it from
+# `err` after a hypothetical mid-flight collection would dangle
+# without sp_mark_in_flight_exceptions marking the slot.
+begin
+  Integer("nope")
+rescue ArgumentError => err
+  puts "msg: #{err}"
+end
+
+# Stress the GC-root fix: many raises in succession force allocator
+# churn. Each `Integer("bad...")` builds an sp_sprintf-allocated
+# message and stores it in sp_exc_msg before longjmping. Pre-fix
+# (without sp_mark_in_flight_exceptions), a sweep landing between
+# raise and rescue would reap the message; the rescue handler would
+# read garbage. Post-fix, the marker keeps each message live until
+# the handler returns and sp_exc_top decrements.
+i = 0
+ok = 0
+while i < 100
+  caught = 0
+  begin
+    Integer("bad")
+  rescue ArgumentError
+    caught = 1
+  end
+  ok += caught
+  i += 1
+end
+puts "stress ok: #{ok}"
+
+# Pre-existing endless_method_rescue.rb shape continues to work.
+# Integer("abc") now raises but the rescue catches and returns 0,
+# so the observed behaviour is unchanged.
+def parse_int(s) = Integer(s) rescue 0
+puts parse_int("42")
+puts parse_int("abc")
+puts parse_int("0")
+puts parse_int("-7")

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

@@ -0,0 +1,36 @@
+42
+0
+-7
+5
+-7
+42
+42
+42
+42
+42
+-7
+0
+0
+-1
+-1
+-1
+-1
+9223372036854775807
+-9223372036854775808
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+-1
+42
+-1
+-1
+msg: invalid value for Integer(): "nope"
+stress ok: 100
+42
+0
+0
+-7

data/vendor/spinel/test/integer_extra_methods.rb

@@ -0,0 +1,12 @@
+# Issues #875 #876 #873 #860 #894:
+# Integer methods that were not dispatched - magnitude (alias for abs),
+# modulo (alias for %), remainder (truncated division remainder, differs
+# from % for mixed-sign), size (bytes per mrb_int = 8), gcdlcm.
+puts (-42).magnitude
+puts 7.modulo(3)
+puts (-7).modulo(3)
+puts 7.remainder(3)
+puts (-7).remainder(3)
+puts 12.gcdlcm(18).inspect
+puts 1.size
+puts 256.size

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

@@ -0,0 +1,8 @@
+42
+1
+2
+1
+-1
+[6, 36]
+8
+8

data/vendor/spinel/test/integer_pow_negative_exponent.rb

@@ -0,0 +1,17 @@
+# Integer ** with a negative exponent has no Rational result in Spinel, so it
+# raises RangeError instead of returning (1/2). Non-negative integer ** and
+# Float ** are unchanged. See docs/INCOMPATIBILITIES.md.
+puts 2 ** 10
+puts 0 ** 0
+puts 3 ** 4
+puts(2.0 ** -1)
+begin
+  puts 2 ** -1
+rescue RangeError => e
+  puts "raised: #{e.message}"
+end
+begin
+  2 ** -3
+rescue StandardError => e
+  puts "is_standard_error: #{e.is_a?(StandardError)}"
+end

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

@@ -0,0 +1,6 @@
+1024
+1
+81
+0.5
+raised: negative exponent
+is_standard_error: true

data/vendor/spinel/test/integer_times_as_expr.rb

@@ -0,0 +1,9 @@
+# Issue #877: Integer#times / #upto / #downto in expression
+# position return self (per MRI). Pre-fix, the expression form
+# emitted 0; the statement form already iterated correctly.
+x = 5.times { }
+puts x
+y = 1.upto(5) { }
+puts y
+z = 5.downto(1) { }
+puts z

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

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

data/vendor/spinel/test/interp_array_container.rb

@@ -0,0 +1,41 @@
+# String interpolation of typed-array containers.
+#
+# `93d04586` fixed Symbol interpolation (`"#{:foo}"` -> `"foo"`).
+# This extends the same idea to typed array containers: `#{arr}`
+# previously fell through the default int path and printed the
+# pointer as a long long (e.g. "4318536016") instead of CRuby's
+# `Array#to_s` shape.
+#
+# Each Array variant has an existing `sp_*Array_inspect` runtime
+# helper that emits the bracketed form `[elem, elem, ...]` byte-
+# identical to CRuby; we just route to it from compile_interpolated.
+
+# int_array
+ints = [1, 2, 3]
+puts "ints: #{ints}"
+
+# str_array
+strs = ["a", "b", "c"]
+puts "strs: #{strs}"
+
+# sym_array
+syms = [:x, :y, :z]
+puts "syms: #{syms}"
+
+# float_array
+floats = [1.5, 2.5, 3.5]
+puts "floats: #{floats}"
+
+# poly_array (heterogeneous)
+mix = [1, "two", :three, nil]
+puts "mix: #{mix}"
+
+# Empty arrays
+puts "empty ints: #{[]}"
+
+# Nested arrays
+puts "nested: #{[[1, 2], [3, 4]]}"
+
+# nil interpolation (CRuby: empty string, not "0")
+n = nil
+puts "n: '#{n}'"

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

@@ -0,0 +1,8 @@
+ints: [1, 2, 3]
+strs: ["a", "b", "c"]
+syms: [:x, :y, :z]
+floats: [1.5, 2.5, 3.5]
+mix: [1, "two", :three, nil]
+empty ints: []
+nested: [[1, 2], [3, 4]]
+n: ''

data/vendor/spinel/test/interpolation_multistmt.rb

@@ -0,0 +1,15 @@
+# Issue #729. `"#{stmt1; stmt2; ...; stmtN}"` should evaluate every
+# statement in source order (for side effects) and use the LAST
+# statement's value in the string. spinel used to take stmts.first,
+# silently dropping later statements -- losing both their effects on
+# locals and the correct interpolation value.
+
+y = 0
+s = "#{y = 10; y = 20; y}"
+puts s
+puts y
+
+# Side effect persists outside the interpolation.
+counter = 0
+"#{counter += 1; counter += 1; counter += 1}"
+puts counter

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

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

data/vendor/spinel/test/interpolation_symbol_name.rb

@@ -0,0 +1,23 @@
+# `"#{sym}"` should render the symbol's name, not its int id.
+# Pre-fix compile_interpolated had no symbol arm in its
+# type-dispatch switch, so the default int path emitted the raw
+# `sp_sym` value (`0`, `1`, ...) instead of routing through
+# sp_sym_to_s. Issue #633.
+
+s = :hello
+puts s
+puts "#{s}"
+puts s.to_s
+puts "x_#{s}_y"
+
+# Multiple symbols + literal mix in one interpolation.
+a = :alpha
+b = :beta
+puts "#{a}-#{b}"
+
+# Symbol from a method return; the call-site infers symbol type
+# and the same arm should fire.
+def make_sym
+  :payload
+end
+puts "tag=#{make_sym}"

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

@@ -0,0 +1,6 @@
+hello
+hello
+hello
+x_hello_y
+alpha-beta
+tag=payload

data/vendor/spinel/test/introspection_constant_path.rb

@@ -0,0 +1,60 @@
+# `is_a?` / `kind_of?` / `instance_of?` with a qualified-constant
+# argument (ConstantPathNode like `Mod::Klass`). The dynamic-arg
+# branch in compile_introspection_expr previously excluded only the
+# bare ConstantReadNode shape; a qualified constant fell through and
+# emitted compile_expr(arg) as a bare C identifier with no declaration,
+# producing "use of undeclared identifier" at C compile time. The
+# is_a? branch also didn't route kind_of? or instance_of? through
+# the same static collapse, so those names silently fell through to
+# warn_unresolved_call. Fix: resolve the constant name via the path
+# walker, and dispatch the whole introspection family uniformly.
+#
+# Coverage:
+# - Same-class match (is_a?/kind_of?/instance_of? all true)
+# - Unrelated-sibling mismatch (all false)
+# - Ancestor case (is_a?/kind_of? true; instance_of? false, exact only)
+# - Deeper constant path (Mod::Sub::Deep — three-level path walk)
+#
+# Out of scope for this PR:
+# - Class-as-local (`k = Mod::Klass; obj.is_a?(k)`) emits the const
+#   name as a bare C identifier — a separate ConstantPathNode-to-local
+#   assignment bug, distinct from the introspection-arg fix here.
+# - Built-in ancestor (`obj.is_a?(Object)`) returns false in spinel
+#   today; spinel's class registry doesn't materialize Object as an
+#   ancestor of user classes. Separate gap.
+
+module Mod
+  class Base
+    def base_name; "base"; end
+  end
+  class Klass < Base
+    def initialize(v); @v = v; end
+    def get; @v; end
+  end
+  class Other
+    def initialize(v); @v = v; end
+  end
+  module Sub
+    class Deep
+      def initialize(v); @v = v; end
+      def get; @v; end
+    end
+  end
+end
+
+k = Mod::Klass.new(7)
+puts k.is_a?(Mod::Klass)
+puts k.kind_of?(Mod::Klass)
+puts k.instance_of?(Mod::Klass)
+puts k.is_a?(Mod::Other)
+puts k.instance_of?(Mod::Other)
+puts k.is_a?(Mod::Base)
+puts k.kind_of?(Mod::Base)
+puts k.instance_of?(Mod::Base)
+puts k.get
+
+d = Mod::Sub::Deep.new(42)
+puts d.is_a?(Mod::Sub::Deep)
+puts d.kind_of?(Mod::Sub::Deep)
+puts d.instance_of?(Mod::Sub::Deep)
+puts d.get

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

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

data/vendor/spinel/test/io_pipe.rb

@@ -0,0 +1,6 @@
+r, w = IO.pipe
+puts r.class
+puts w.class
+w.write("hello")
+w.close
+puts r.read

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

@@ -0,0 +1,3 @@
+IO
+IO
+hello

data/vendor/spinel/test/is_a_descendant_runtime.rb

@@ -0,0 +1,59 @@
+# Static-vs-runtime class lattice for `is_a?` / `kind_of?` /
+# `instance_of?` when the recv's static type is a parent class but
+# the runtime instance can be any descendant. Previously spinel
+# collapsed the descendant-target case to literal FALSE because
+# is_class_or_ancestor(parent, child) returns 0; the recv's runtime
+# cls_id was never consulted.
+#
+# Fix: when the target is identical to, ancestor of, or descendant
+# of the static recv type, consult the actual cls_id slot.
+# `is_a?` / `kind_of?` use ancestor-walk (sp_class_le); `instance_of?`
+# uses exact equality.
+
+class Animal
+end
+class Dog < Animal
+end
+class Cat < Animal
+end
+class Puppy < Dog
+end
+
+# is_a? / kind_of? — recv typed Animal, target a proper descendant.
+def kind(a)
+  if a.is_a?(Dog)
+    "dog"
+  elsif a.kind_of?(Cat)
+    "cat"
+  else
+    "animal"
+  end
+end
+
+puts kind(Dog.new)      # dog
+puts kind(Cat.new)      # cat
+puts kind(Animal.new)   # animal
+puts kind(Puppy.new)    # dog (Puppy is_a? Dog)
+
+# instance_of? — recv typed Animal, target a proper descendant.
+# Pre-fix this collapsed to literal FALSE; runtime instance is
+# never consulted.
+def exact_is_dog(a)
+  a.instance_of?(Dog)
+end
+
+puts exact_is_dog(Dog.new)      # true  — runtime cls_id matches Dog
+puts exact_is_dog(Puppy.new)    # false — Puppy is_a? Dog but not instance_of? Dog
+puts exact_is_dog(Cat.new)      # false — unrelated descendant
+puts exact_is_dog(Animal.new)   # false — runtime cls_id is Animal, not Dog
+
+# instance_of? — recv typed Animal, target IS the static type.
+# Pre-fix this collapsed to literal TRUE (`cname == arg0`); a
+# parent-typed local holding a descendant should fail this.
+def exact_is_animal(a)
+  a.instance_of?(Animal)
+end
+
+puts exact_is_animal(Animal.new)  # true  — runtime cls_id matches Animal
+puts exact_is_animal(Dog.new)     # false — runtime cls_id is Dog, not Animal
+puts exact_is_animal(Puppy.new)   # false — runtime cls_id is Puppy

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

@@ -0,0 +1,11 @@
+dog
+cat
+animal
+dog
+true
+false
+false
+false
+true
+false
+false

data/vendor/spinel/test/is_a_included_module.rb

@@ -0,0 +1,28 @@
+module M
+  def foo; 42; end
+end
+
+module N
+end
+
+class C
+  include M
+end
+
+class D
+  include M
+  include N
+end
+
+c = C.new
+p c.foo
+p c.is_a?(M)
+p c.is_a?(N)
+p C.ancestors.include?(M)
+p C.ancestors.include?(N)
+
+d = D.new
+p d.is_a?(M)
+p d.is_a?(N)
+p D.ancestors.include?(M)
+p D.ancestors.include?(N)