rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/test/mutable_str_force_encoding_return.rb

@@ -0,0 +1,21 @@
+# Sequel to #441. The original fix gated force_encoding/encode/b
+# return-type inference on `recv == "string"`, which left the
+# `sp_String *` (mutable_str) receiver case unfixed. Codegen for
+# mutable_str dispatches the inner call against `rc + "->data"`,
+# so force_encoding's body emits `return lv_out->data` — a
+# `const char *`. The function signature still committed to
+# mrb_int from the default infer_call_type fallback, tripping
+# the C compile with int-from-pointer.
+#
+# Add the mutable_str arm: return "string" (the body's `->data`
+# value type), keeping the C signature aligned with the emitted
+# return expression.
+
+def build_via_mutable
+  out = String.new
+  out << "ab"
+  out << "cd"
+  out.force_encoding("UTF-8")
+end
+
+puts build_via_mutable

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

@@ -0,0 +1 @@
+abcd

data/vendor/spinel/test/mutable_str_into_str_array.rb

@@ -0,0 +1,46 @@
+# Pushing a mutable String builder (String.new + <<) into a str_array
+# must snapshot its buffer into a sweep-owned (0xfe) copy, not store the
+# sp_String pointer / alias its object-owned ->data buffer. The builder
+# is otherwise unreferenced after the push, so a GC collects it and frees
+# the buffer, leaving the array element dangling; the next mark walk
+# faults scanning it (the #1071 / #1314 use-after-free class). Pre-fix
+# this also emitted `sp_StrArray_push(arr, sp_String *)`, an
+# incompatible-pointer-type the -Werror test build rejects outright.
+
+# 1. `<<` (statement form) — many builders pushed under GC churn.
+arr = []
+i = 0
+while i < 4000
+  s = String.new
+  s << "item "
+  s << i.to_s
+  arr << s
+  i = i + 1
+end
+puts arr.length                 #=> 4000
+puts arr[0]                     #=> item 0
+puts arr[4000 - 1]             #=> item 3999
+
+# 2. `push` (expression form).
+arr2 = []
+k = 0
+while k < 2000
+  b = String.new
+  b << "k="
+  b << k.to_s
+  arr2.push(b)
+  k = k + 1
+end
+puts arr2.length                #=> 2000
+puts arr2[1000]                #=> k=1000
+
+# 3. Sum the lengths back (reads every element after GC).
+total = 0
+j = 0
+while j < arr.length
+  total = total + arr[j].length
+  j = j + 1
+end
+puts total                      #=> 34890
+
+puts "done"

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

@@ -0,0 +1,7 @@
+4000
+item 0
+item 3999
+2000
+k=1000
+34890
+done

data/vendor/spinel/test/mutex_synchronize_block.rb

@@ -0,0 +1,29 @@
+m = Mutex.new
+m.synchronize { puts "locked" }
+puts "done"
+
+x = m.synchronize { 21 * 2 }
+puts x
+puts(m.synchronize { "result" })
+
+require "monitor"
+mon = Monitor.new
+mon.synchronize { puts "monitor" }
+
+class Counter
+  def initialize
+    @lock = Mutex.new
+    @count = 0
+  end
+  def bump
+    @lock.synchronize { @count = @count + 1 }
+  end
+  def count
+    @count
+  end
+end
+c = Counter.new
+c.bump
+c.bump
+c.bump
+puts c.count

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

@@ -0,0 +1,6 @@
+locked
+done
+42
+result
+monitor
+3

data/vendor/spinel/test/narrow_and_predicate.rb

@@ -0,0 +1,23 @@
+# Step 3 narrow extension. `if v.is_a?(C) && other_cond` should
+# narrow `v` to C inside the then-arm just like the bare
+# `if v.is_a?(C)` form. parse_is_a_predicate previously only
+# matched a CallNode directly; an AndNode wrapping was rejected
+# and the narrow was lost. Without the narrow, a call-site inside
+# the then-arm widens the callee param with the unnarrowed type
+# (typically poly) instead of the asserted concrete type.
+
+def consume(s)
+  s.length
+end
+
+class C
+  attr_accessor :n
+  def initialize; @n = 1; end
+end
+
+arr = ["hello", C.new]
+v = arr[0]
+allow = true
+if v.is_a?(String) && allow
+  puts consume(v)
+end

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

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

data/vendor/spinel/test/negative_range_slice.rb

@@ -0,0 +1,32 @@
+# #496. `a[1..-2]` returned [] in spinel where CRuby returns
+# [a[1], a[2], a[3]]. Codegen emitted `sp_IntArray_slice(arr, 1,
+# -2 - 1 + 1)` (length = -2), and the runtime's `len <= 0` early
+# return produced an empty array. Fix: new `_slice_range` /
+# `_sub_range_r` runtime helpers take (start, end, exclusive)
+# and normalize negative end against the collection length
+# before computing slice length.
+#
+# Test covers the four receiver shapes that route through the
+# fixed emit sites: int_array, float_array, str_array, and
+# string. Exclusive (`...`) and inclusive (`..`) forms both
+# exercise negative endpoints.
+
+a = [0, 1, 2, 3, 4]
+p a[1..-2]   # inclusive: [1, 2, 3]
+p a[1...-1]  # exclusive: [1, 2, 3]
+p a[-3..-1]  # both negative: [2, 3, 4]
+p a[0..-1]   # whole array: [0, 1, 2, 3, 4]
+p a[2..-3]   # single element (-3 -> 2, so a[2..2]): [2]
+p a[-4..-2]  # negative start, negative end: [1, 2, 3]
+
+f = [0.5, 1.5, 2.5, 3.5]
+p f[1..-2]   # [1.5, 2.5]
+
+s_arr = ["a", "b", "c", "d", "e"]
+p s_arr[1..-2]   # ["b", "c", "d"]
+
+s = "hello"
+p s[1..-2]   # "ell"
+p s[1...-1]  # "ell"
+p s[-3..-1]  # "llo"
+p s[-4..-2]  # negative start + end: "ell"

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

@@ -0,0 +1,12 @@
+[1, 2, 3]
+[1, 2, 3]
+[2, 3, 4]
+[0, 1, 2, 3, 4]
+[2]
+[1, 2, 3]
+[1.5, 2.5]
+["b", "c", "d"]
+"ell"
+"ell"
+"llo"
+"ell"

data/vendor/spinel/test/nested_array_eq.rb

@@ -0,0 +1,22 @@
+# Array#== on an array of arrays/objects (a ptr_array) had no deep
+# comparison -- the dispatch covered int/str/float/poly arrays but not
+# ptr_array, so `[[1]] == [[1]]` fell through to FALSE. Compare
+# element-wise inline using each element's statically-known type.
+
+p([[1]] == [[1]])                         #=> true
+p([[1, 2], [3]] == [[1, 2], [3]])         #=> true
+p([[1]] == [[2]])                         #=> false
+p([[1], [2]] == [[1]])                    #=> false (length)
+p([["a"], ["b"]] == [["a"], ["b"]])       #=> true
+p([["a"]] == [["b"]])                     #=> false
+p([[1.0]] == [[1.0]])                     #=> true
+p([[1]] != [[2]])                         #=> true
+p([[1]] != [[1]])                         #=> false
+
+x = [[1, 2, 3]]
+y = [[1, 2, 3]]
+p(x == y)                                 #=> true
+x[0] << 4
+p(x == y)                                 #=> false
+
+puts "done"

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

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

data/vendor/spinel/test/nested_yield_with_block_param.rb

@@ -0,0 +1,33 @@
+# Issue #664: `outer { |x| yield x*2 }` appearing inside an already-
+# inlined caller (`inner` itself yields) previously emitted `lv_x` and
+# `_block` references in a scope where neither existed — `inner` got
+# inlined into main and the codegen left the nested `outer { ... }`
+# call site dangling. Fix routes nested user-yield calls through
+# compile_nested_yield_call_inline so the inner block's body's yield
+# substitutes back to the outer-most caller's block.
+
+def outer
+  yield 1
+end
+
+def inner
+  outer do |x|
+    yield x * 2
+  end
+end
+
+inner { |v| puts v.to_s }
+
+# Multi-arg yield path. inner forwards a 2-tuple, outer's block param
+# captures and re-yields one of them. Exercises both args + offsets.
+def add_one
+  yield 10
+end
+
+def double_then_emit
+  add_one do |n|
+    yield n + 5
+  end
+end
+
+double_then_emit { |r| puts r.to_s }

data/vendor/spinel/test/nil_default_param_widens_to_poly.rb

@@ -0,0 +1,26 @@
+# `def f(x = nil)` should keep nil observable at the no-arg call
+# site, even when other call sites supply a non-nullable scalar
+# (symbol / int / float / bool). Pre-fix the per-call-site
+# unifier picked the typed `at` over the `nil` default, so the
+# param's C storage was the scalar type and `f()` defaulted the
+# missing arg to that scalar's zero value (`sp_sym 0`, `mrb_int
+# 0`, etc.) — the user's `x.nil?` branch became dead code.
+# Issue #634 shape A.
+
+def f(x = nil)
+  if x.nil?
+    "branch: nil"
+  else
+    "branch: not-nil (#{x.to_s})"
+  end
+end
+
+puts f()
+puts f(:foo)
+
+def g(n = nil)
+  n.nil? ? "no-int" : "int=#{n.to_s}"
+end
+
+puts g()
+puts g(42)

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

@@ -0,0 +1,4 @@
+branch: nil
+branch: not-nil (foo)
+no-int
+int=42

data/vendor/spinel/test/nil_guard_narrows_int_or_nil.rb

@@ -0,0 +1,40 @@
+# #550. Mirror of d3ee2b2 (#493) for the nil-vs-not case on
+# int|nil locals. After `return -1 if h.nil?`, the rest of the
+# scope sees `h` as non-nil; for a local whose writer was a
+# known int-or-nil source (String#index, rindex, find_index),
+# the non-nil arm is mrb_int. The function's return type
+# narrows accordingly, and the trailing `h + 1` lowers via
+# integer arithmetic on the unboxed payload instead of routing
+# through sp_poly_add.
+#
+# Cascade: the 0210389 String#index return-type change widened
+# all downstream consumers to sp_RbVal. Before this fix, every
+# `h = s.index(needle); ...; h + 1` had to be hand-wrapped in a
+# pure-int helper (Tep.str_find) to avoid the poly widening.
+# With the nil-guard narrow, the idiomatic form works directly.
+#
+# Discriminator: `lookup` consumes find_or_neg's return as an
+# int-typed array index. Pre-fix the function returns sp_RbVal
+# and arr[poly] does not compile cleanly (spinel emits no
+# implicit poly->int unbox at the index site). Post-fix the
+# return is mrb_int and arr[i] is direct integer indexing.
+
+ARR = [10, 20, 30, 40, 50, 60]
+
+def find_or_neg(s, needle)
+  h = s.index(needle)
+  return -1 if h.nil?
+  h + 1
+end
+
+def lookup(s, needle)
+  i = find_or_neg(s, needle)
+  return 0 if i < 0
+  ARR[i]
+end
+
+puts find_or_neg("abcdef", "b")
+puts find_or_neg("abcdef", "z")
+puts lookup("abcdef", "b")
+puts lookup("abcdef", "a")
+puts lookup("abcdef", "z")

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

@@ -0,0 +1,5 @@
+2
+-1
+30
+20
+0

data/vendor/spinel/test/not_match_op.rb

@@ -0,0 +1,8 @@
+# Issue #732. `str !~ /pattern/` should return true when no match
+# and false when there is a match. spinel used to emit the unresolved-
+# call warning and return 0; now `!~` is the negation of `=~`.
+
+puts "hello" !~ /xyz/
+puts "hello" !~ /llo/
+puts "abc 123" !~ /\d+/
+puts "abc" !~ /\d+/

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

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

data/vendor/spinel/test/nullable_hash_recv_bracket.expected

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

data/vendor/spinel/test/nullable_hash_recv_bracket.rb

@@ -0,0 +1,33 @@
+class Router
+  def self.match_pattern(s)
+    return nil if s == ""
+    h = {}
+    h["k"] = s
+    h
+  end
+end
+
+r = Router.match_pattern("hello")
+if r
+  puts r["k"]
+end
+
+r2 = Router.match_pattern("")
+if r2
+  puts "yes"
+else
+  puts "no"
+end
+
+# Same shape, nilable str_int_hash return
+def maybe_count(n)
+  return nil if n <= 0
+  h = {}
+  h["x"] = n
+  h
+end
+
+c = maybe_count(5)
+if c
+  puts c["x"]
+end

data/vendor/spinel/test/nullable_obj_nil_compare.rb

@@ -0,0 +1,92 @@
+# Issue #423. `if c != nil` (or `while c != nil`) on a nullable
+# user-class local emitted the body unconditionally -- the `!=
+# nil` comparison was constant-folded to TRUE, the surrounding
+# `if` was collapsed (compile_if_stmt's "static TRUE fold"), and
+# the body ran even when c was NULL. Found in tep's route
+# dispatch loop: `while route != nil && !served` entered with
+# route = NULL after a no-match POST and segfaulted.
+#
+# Root cause: `compile_eq`'s cross-type fold treated `obj_<C>? ==
+# nil` and `obj_<C>? != nil` as type-strict pairs (LHS is obj,
+# RHS is nil-typed; the existing fold returned "FALSE" / "TRUE"
+# because "obj vs nil are different types, always unequal").
+# That's right for a non-nullable `obj_<C>` -- the C pointer is
+# never NULL by design -- but wrong for `obj_<C>?` where NULL is
+# the runtime nil sentinel.
+#
+# Fix: in compile_eq's cross-type-prim-vs-obj branch, when
+# other_t == "nil", check is_nullable_type on the obj side. If
+# nullable, emit the actual pointer comparison (`obj == NULL` /
+# `obj != NULL`); fall through to the original FALSE/TRUE fold
+# only for non-nullable obj types.
+#
+# Coverage:
+#   - if c != nil / if c / if !c.nil? on a function returning
+#     nil-or-Foo: all three forms agree.
+#   - while c != nil on the same shape: loop terminates instead
+#     of spinning forever.
+#   - non-nullable obj_<C> (c = Foo.new) still folds to TRUE for
+#     != nil (no pointer-vs-NULL emit needed; the value is never
+#     NULL).
+
+class Box
+  attr_accessor :tag
+  def initialize(tag)
+    @tag = tag
+  end
+end
+
+def find_or_nil(want)
+  if want == "yes"
+    return Box.new("found")
+  end
+  nil
+end
+
+# 1. nil branch -- all three forms should agree.
+c = find_or_nil("no")
+puts "c=" + (c.nil? ? "nil" : "non-nil")     # c=nil
+
+if c != nil
+  puts "ne-nil: ENTERED"
+else
+  puts "ne-nil: skipped"                      # skipped (correct)
+end
+
+if c
+  puts "tr: ENTERED"
+else
+  puts "tr: skipped"                          # skipped
+end
+
+if !c.nil?
+  puts "not-nilq: ENTERED"
+else
+  puts "not-nilq: skipped"                    # skipped
+end
+
+# 2. non-nil branch -- all three forms enter the body.
+d = find_or_nil("yes")
+puts "d=" + (d.nil? ? "nil" : "non-nil")     # d=non-nil
+
+if d != nil
+  puts "d-ne-nil: ENTERED"                    # ENTERED
+else
+  puts "d-ne-nil: skipped"
+end
+
+# 3. while loop terminates instead of spinning.
+n = 0
+while c != nil
+  n += 1
+  break if n > 3
+end
+puts "n=" + n.to_s                            # n=0
+
+# 4. non-nullable obj (Foo.new is always non-nil) still folds.
+e = Box.new("eager")
+if e != nil
+  puts "e-ne-nil: ENTERED"                    # ENTERED (non-nullable, always true)
+else
+  puts "e-ne-nil: skipped"
+end

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

@@ -0,0 +1,8 @@
+c=nil
+ne-nil: skipped
+tr: skipped
+not-nilq: skipped
+d=non-nil
+d-ne-nil: ENTERED
+n=0
+e-ne-nil: ENTERED

data/vendor/spinel/test/nullable_poly_hash_arg_unbox.rb

@@ -0,0 +1,85 @@
+# When a `sym_poly_hash?` (or `str_poly_hash?`) survives a nil-
+# guard and its `[]` value flows into a typed-param call site,
+# analyze's cached infer for `recv[k]` falls through to int
+# (the leaf-type dispatch rejects the `?`-suffixed recv name), so
+# downstream the call site sees `at == "int"` and skips the
+# poly→int unbox. The actual C emit is sp_<*PolyHash>_get(...)
+# returning sp_RbVal — the call then passes sp_RbVal into a
+# mrb_int slot.
+#
+# Codegen-side fix: expr_emits_poly_rb_val recognizes the shape
+# at emit time (independent of analyze cache) and the unbox
+# fires in compile_expr_for_expected_type and the poly-dispatch
+# arm.
+#
+# Real repro lives in roundhouse spinel-blog main.rb:
+#   matched = Router.match(...)
+#   return if matched.nil?           # matched still : sym_poly_hash?
+#   controller = Main.instantiate_controller(matched[:controller])
+#   controller.process_action(matched[:action])
+# Both `instantiate_controller` (Symbol param) and the poly
+# dispatch of `process_action` (Symbol param) caught the bug.
+
+module Counter
+  def self.double(n)
+    n * 2
+  end
+end
+
+class A
+  def act(n)
+    n + 100
+  end
+end
+
+class B
+  def act(n)
+    n + 200
+  end
+end
+
+def fetch(present)
+  if present
+    { value: 21, label: "x" }
+  else
+    nil
+  end
+end
+
+def pick(flag)
+  if flag
+    A.new
+  else
+    B.new
+  end
+end
+
+m = fetch(true)
+if m.nil?
+  puts "missing"
+else
+  # Module class method dispatch — exercises
+  # compile_expr_for_expected_type via
+  # compile_constant_recv_expr → compile_call_args_with_defaults.
+  puts Counter.double(m[:value])
+  # Polymorphic-receiver dispatch arm — exercises
+  # compile_poly_method_call's arm-arg unbox.
+  puts pick(true).act(m[:value])
+  puts pick(false).act(m[:value])
+end
+
+# Same shape with str_poly_hash?.
+def fetch_str(present)
+  if present
+    { "k1" => 7, "k2" => "v" }
+  else
+    nil
+  end
+end
+
+s = fetch_str(true)
+if s.nil?
+  puts "missing"
+else
+  puts Counter.double(s["k1"])
+end

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

@@ -0,0 +1,4 @@
+42
+121
+221
+14

data/vendor/spinel/test/numeric_coerce.rb

@@ -0,0 +1,24 @@
+# Numeric#coerce - CRuby returns [other.cast, self.cast] where the
+# common type is Float when either operand is Float, else Integer.
+# Previously SEGV'd: int.coerce(...) fell through unresolved-call
+# emitting 0, then the destructure dereferenced as pointer.
+
+a1, b1 = 1.coerce(2.5)
+puts a1.inspect
+puts b1.inspect
+
+a2, b2 = 3.coerce(7)
+puts a2.inspect
+puts b2.inspect
+
+a3, b3 = 2.5.coerce(1)
+puts a3.inspect
+puts b3.inspect
+
+a4, b4 = 1.5.coerce(2.5)
+puts a4.inspect
+puts b4.inspect
+
+# Idiomatic use: implement a numeric op via coerce.
+x, y = 1.coerce(2.5)
+puts x + y

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

@@ -0,0 +1,9 @@
+2.5
+1.0
+7
+3
+1.0
+2.5
+2.5
+1.5
+3.5