rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/each_cons_block_destructure.rb

@@ -0,0 +1,10 @@
+# Enumerable#each_cons block destructure on typed arrays:
+# `|a, b|` against `each_cons(2)` binds each pair element to
+# its own scalar param rather than to a sub-array.
+
+["a", "b", "c", "d"].each_cons(2) { |x, y| puts x + "," + y }
+puts "---"
+[1, 2, 3, 4, 5].each_cons(2) { |a, b| puts (a + b).to_s }
+puts "---"
+# `|pair|` (single block param) still gets the sub-array.
+[1, 2, 3, 4].each_cons(2) { |pair| puts pair.length }

data/vendor/spinel/test/each_cons_with_index_map_no_double_gets.rb

@@ -0,0 +1,21 @@
+# `.each_cons[.with_index].map { ... }` over a side-effecting inner
+# array must not re-emit the inner chain. Pre-fix compile_call_expr
+# emitted `rc` (the with_index/each_cons placeholder pair) before
+# routing to compile_map_expr's fusion path, which then re-emitted
+# the inner receiver. The inner block's side effects (`gets`, an
+# accumulator method, ...) ran twice -- consuming twice the input
+# lines or doubling the counter. Issue #621.
+
+$counter = 0
+def step
+  $counter += 1
+  $counter
+end
+
+# `3.times.map { step }` -> [1, 2, 3] (counter should advance by 3,
+# not by 6 from a duplicate emission).
+result = 3.times.map { step }.each_cons(2).with_index(1).map { |(x, y), i| [x - y, i] }
+result.each do |pair|
+  puts pair.inspect
+end
+puts $counter

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

@@ -0,0 +1,3 @@
+[-1, 1]
+[-1, 2]
+3

data/vendor/spinel/test/each_entry_reverse_each.rb

@@ -0,0 +1,8 @@
+# Enumerable#each_entry alias of each; Enumerable#reverse_each
+# walks the receiver in reverse.
+
+[1, 2, 3].each_entry { |x| puts x }
+puts "---"
+[1, 2, 3].reverse_each { |x| puts x }
+puts "---"
+["a", "b", "c"].reverse_each { |s| puts s }

data/vendor/spinel/test/each_slice_map.rb

@@ -0,0 +1,7 @@
+# Issue #829: array.each_slice(n).map { |x, y| ... } chains.
+a = [1, 3, 6, 10]
+p a.each_slice(2).map { |x, y| y - x }
+
+# A second chain to verify reuse.
+b = [2, 4, 8, 16]
+p b.each_slice(2).map { |x, y| y * x }

data/vendor/spinel/test/empty_array_local_arg_widen.rb

@@ -0,0 +1,57 @@
+# An empty-array local (`x = []`) that is then filled with objects via
+# `<<` and passed as a call argument must widen the callee's parameter
+# (and any ivar it is stored in) to the real element type. Previously
+# the class-body call-type pass typed such a local from its `[]` seed
+# alone (int_array) and ignored the pushes, so the parameter and ivar
+# became int_array. A real object array was then stored and later read
+# back as an IntArray, making `.size` / `.length` return garbage.
+#
+# Mirrors the roundhouse "preload" pattern: a controller groups child
+# records into a fresh array (built inside nested `each` blocks, off
+# another empty-array local) and hands it to a model's `_preload`,
+# which stashes it in an ivar that an accessor reads back.
+class Comment
+  def initialize(id, aid); @id = id; @aid = aid; end
+  def id; @id; end
+  def article_id; @aid; end
+  def touch(x); @id = x; end          # self-mutating -> heap class
+end
+
+class Article
+  def initialize(id)
+    @id = id
+    @cache = []
+    @loaded = false
+  end
+  def id; @id; end
+  def _preload(list)
+    @cache = list
+    @loaded = true
+  end
+  def comments
+    return @cache if @loaded
+    fresh = []
+    fresh << Comment.new(0, @id)
+    fresh
+  end
+end
+
+class Controller
+  def index(articles)
+    loaded = []                       # empty-array local #1
+    loaded << Comment.new(10, 1)
+    loaded << Comment.new(20, 1)
+    loaded << Comment.new(30, 2)
+    articles.each { |a|
+      group = []                      # empty-array local #2 (transitive)
+      loaded.each { |r| group << r if r.article_id == a.id }
+      a._preload(group) }
+  end
+end
+
+articles = []
+articles << Article.new(1)
+articles << Article.new(2)
+Controller.new.index(articles)
+
+articles.each { |a| puts a.id.to_s + ": " + a.comments.length.to_s }

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

@@ -0,0 +1,2 @@
+1: 2
+2: 1

data/vendor/spinel/test/empty_array_loop_intermediate_push.rb

@@ -0,0 +1,103 @@
+# Issue #412. An empty array literal followed by a `<<` push
+# inside a loop, where the pushed value rides through an
+# intermediate variable, emitted as `sp_IntArray *` even though
+# the pushed values were class pointers:
+#
+#   def make
+#     results = []
+#     i = 0
+#     while i < 3
+#       instance = Foo.new
+#       results << instance        # ← intermediate var
+#       i += 1
+#     end
+#     results
+#   end
+#
+#   error: passing argument 2 of 'sp_IntArray_push' makes integer
+#          from pointer without a cast
+#     sp_IntArray_push(lv_results, lv_instance);
+#                                  ^~~~~~~~~~~
+#
+# Three combinations distinguished:
+#
+#   - direct push (`results << Foo.new`)            -- worked
+#   - intermediate var, no loop                     -- worked
+#   - intermediate var INSIDE loop                  -- failed
+#
+# Root cause: `scan_locals`'s `<<` push observation upgrades
+# `int_array → <typed>_array` only when `infer_type(arg)` resolves
+# to a typed value. In pass 1, the intermediate local
+# (`instance`) hadn't been declared in the scope yet, so
+# `infer_type(LocalVariableReadNode "instance")` fell back to
+# "int" via `find_var_type` returning "" — push didn't upgrade.
+# Pass 2 (with locals declared) DID resolve and DID upgrade
+# `ltypes2[results]` to `obj_Foo_ptr_array`, but
+# `refine_method_body_locals`'s pass-1↔pass-2 merge only handled
+# `int → concrete` and `nil → nullable_pointer`, not
+# `int_array → typed_array`. The pass-2 result was dropped.
+#
+# Compounding the local-decl miss: `infer_all_returns`'s
+# top-level-method branch ran a single-pass `scan_locals` before
+# calling `infer_body_return`, so the function's return type was
+# also pinned at `int_array` independently of what
+# precompute_all_scope_decls eventually computed for the local.
+# Both branches now route through `refine_method_body_locals`.
+#
+# Coverage:
+#   - the canonical Rails-style `_adapter_all` shape from the
+#     issue's repro,
+#   - a typed-array (str) variant to prove the pass-2 merge
+#     covers `int_array → str_array` too,
+#   - a baseline direct-push variant as a regression check that
+#     the previously-working path still works.
+
+class Foo
+  attr_accessor :v
+  def initialize
+    @v = 0
+  end
+end
+
+def make_with_intermediate
+  results = []
+  i = 0
+  while i < 3
+    instance = Foo.new
+    results << instance
+    i += 1
+  end
+  results
+end
+
+a = make_with_intermediate
+puts a.length                   # 3
+
+def make_strs_with_intermediate
+  buf = []
+  i = 0
+  while i < 4
+    s = "row" + i.to_s
+    buf << s
+    i += 1
+  end
+  buf
+end
+
+s = make_strs_with_intermediate
+puts s.length                   # 4
+puts s[0]                       # row0
+puts s[3]                       # row3
+
+# Baseline direct-push (was already working).
+def make_direct
+  results = []
+  i = 0
+  while i < 3
+    results << Foo.new
+    i += 1
+  end
+  results
+end
+
+puts make_direct.length         # 3

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

@@ -0,0 +1,5 @@
+3
+4
+row0
+row3
+3

data/vendor/spinel/test/empty_array_push_container_elem.rb

@@ -0,0 +1,35 @@
+# `rows = []` followed by `rows << <container>` (where the pushed
+# value is a Hash or another Array, not a primitive) used to leave
+# `rows` typed as int_array — sp_IntArray_push then errored with
+# "incompatible pointer to integer conversion".
+#
+# #412 added the int_array → typed-array upgrade in scan_locals's
+# push observation for primitive element types (str_array,
+# float_array, sym_array, obj_X_ptr_array, poly_array). Container
+# element types (Hash, nested Array) fell through to the bottom
+# default and stayed at int_array.
+#
+# Fix: extend the push observation to recognise hash-type and
+# array-type arg types and promote to poly_array (spinel has no
+# <hash>_ptr_array or <array>_ptr_array_ptr_array slot — boxed
+# poly_array is the canonical container-of-containers shape, same
+# as the literal `[{...}, {...}]` inference at
+# infer_array_elem_type_from_ids).
+
+def build_hash_rows
+  rows = []
+  rows << { "k" => "v" }
+  rows << { "k" => "v2" }
+  rows.length
+end
+
+def build_nested_arrays
+  outer = []
+  inner = [1, 2]
+  outer << inner
+  outer << [3, 4]
+  outer.length
+end
+
+puts build_hash_rows         # 2
+puts build_nested_arrays     # 2

data/vendor/spinel/test/empty_array_push_ptr.rb

@@ -0,0 +1,26 @@
+# #688: empty `[]` followed by `.push(:ptr)` must promote to
+# ptr_ptr_array, not silently retain the IntArray default (which
+# would round-trip the pointer through mrb_int).
+
+module LibC
+  ffi_func :malloc, [:size_t], :ptr
+  ffi_func :free,   [:ptr],    :void
+end
+
+p1 = LibC.malloc(64)
+p2 = LibC.malloc(64)
+
+arr = []
+arr.push(p1)
+arr.push(p2)
+
+puts arr.length
+
+# Read back the pointers and confirm they're identical to what we pushed.
+got1 = arr[0]
+got2 = arr[1]
+puts (got1 == p1) ? "p1=match" : "p1=MISMATCH"
+puts (got2 == p2) ? "p2=match" : "p2=MISMATCH"
+
+LibC.free(p1)
+LibC.free(p2)

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

@@ -0,0 +1,3 @@
+2
+p1=match
+p2=match

data/vendor/spinel/test/empty_hash_arg_param_widen.rb

@@ -0,0 +1,44 @@
+# Issue #397. `def store(receiver); receiver["k"] = "v"; end; store({})`
+# previously emitted `sp_StrIntHash_set(receiver, "k", "v")` -- a const
+# char* into the int-valued slot of `sp_StrIntHash`, fails C-compile.
+# `{}` literal defaulted to str_int_hash, the param widened to that
+# from the caller, and the body's String store didn't fit.
+#
+# Fix: narrow_param_hash_types_from_body_writes scans the body for
+# `lv_<param>[k] = v` writes and widens the param's hash variant from
+# the observed value type. Then compile_call_args_with_defaults's new
+# empty_hash_coerce arm rewrites the caller's empty `{}` to emit the
+# matching `sp_<HashType>_new()`. detect_poly_params also gets an
+# empty-hash carve-out so it doesn't fold the body-widened concrete
+# type back to poly.
+
+def store_str(receiver)
+  receiver["k"] = "v"
+  receiver["k2"] = "v2"
+  receiver
+end
+
+h = store_str({})
+puts h["k"]                # v
+puts h["k2"]               # v2
+
+def store_sym_int(h)
+  h[:a] = 1
+  h[:b] = 2
+  h
+end
+
+s = store_sym_int({})
+puts s[:a].to_s            # 1
+puts s[:b].to_s            # 2
+
+# Mixed values widens to str_poly_hash.
+def store_mixed(r)
+  r["i"] = 7
+  r["s"] = "x"
+  r
+end
+
+m = store_mixed({})
+puts m["i"].to_s           # 7
+puts m["s"]                # x

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

@@ -0,0 +1,6 @@
+v
+v2
+1
+2
+7
+x

data/vendor/spinel/test/empty_hash_int_int_no_widen.rb

@@ -0,0 +1,46 @@
+# `h = {}; h[parts[0]] = v` where `parts` comes from a `split` result
+# (or any expression that returns str_array). Two pre-fix shapes
+# combined:
+#
+# 1. kt="int" + vt="int" — pass-0 promote_empty_hash_for widened to
+#    poly_poly_hash via the catch-all. Now defers (returns "") so the
+#    second pass with the key resolved as string produces
+#    str_int_hash.
+# 2. kt="int" + vt="string" — pass-0 promoted to int_str_hash, and
+#    the refine_locals merge had no rule to upgrade int_str_hash to
+#    str_str_hash when pass 1 resolved the key as string. Added
+#    int_str_hash → str_str_hash / sym_str_hash widening rules.
+#
+# Sibling check: a literal-keyed `h = {}; h[200] = "OK"` (legitimate
+# int-keyed-string-valued) keeps int_str_hash.
+
+def build_str_keyed_int_val(s)
+  parts = s.split("/")
+  h = {}
+  h[parts[0]] = 1
+  h
+end
+
+def build_str_keyed_str_val(s)
+  parts = s.split("/")
+  h = {}
+  h[parts[0]] = "v"
+  h
+end
+
+def build_int_keyed
+  h = {}
+  h[200] = "OK"
+  h[404] = "NotFound"
+  h
+end
+
+h1 = build_str_keyed_int_val("a/b")
+puts h1["a"]            # 1
+
+h1b = build_str_keyed_str_val("a/b")
+puts h1b["a"]           # v
+
+h2 = build_int_keyed
+puts h2[200]            # OK
+puts h2[404]            # NotFound

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

@@ -0,0 +1,4 @@
+1
+v
+OK
+NotFound

data/vendor/spinel/test/empty_hash_int_int_promote.rb

@@ -0,0 +1,32 @@
+# An empty `{}` hash that then receives an integer-literal key must
+# promote from the str_int_hash empty-default to int_int_hash.
+# Otherwise the integer key is passed to sp_StrIntHash_set/_get as a
+# `const char *` and dereferenced, segfaulting. Gated on Integer
+# *literal* keys (an unresolved/variable key whose type is the "int"
+# first-pass fallback must NOT promote, or a later-resolved String key
+# would be stored into an int_int_hash).
+
+h = {}
+h[1] = 10
+h[2] = 20
+puts h[1].to_s
+puts h[2].to_s
+puts h.size.to_s
+
+# present-key arithmetic and has_key? guard
+puts (h[1] + h[2]).to_s
+puts h.has_key?(5).to_s
+puts h.has_key?(1).to_s
+
+# overwrite an existing key
+h[1] = 11
+puts h[1].to_s
+
+# method scope
+def build_counts
+  m = {}
+  m[100] = 1
+  m[200] = 2
+  m[100] + m[200]
+end
+puts build_counts.to_s

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

@@ -0,0 +1,8 @@
+10
+20
+2
+30
+false
+true
+11
+3

data/vendor/spinel/test/empty_int_array_min_max.rb

@@ -0,0 +1,15 @@
+# Issue #745. `[].min` / `[].max` used to read uninitialized memory
+# in `sp_IntArray_min` / `_max` (no empty-array guard before reading
+# `a->data[a->start]`). After #832 both return nil (int? sentinel
+# SP_INT_NIL); inspect renders as "nil" per MRI.
+
+# `[1].first(0)` produces an empty int-typed array, preserving the
+# element type. Both min/max should return safely now.
+a = [1].first(0)
+puts a.min.inspect
+puts a.max.inspect
+
+# Non-empty: unchanged.
+b = [3, 1, 4, 1, 5, 9, 2, 6]
+puts b.min
+puts b.max

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

@@ -0,0 +1,4 @@
+nil
+nil
+1
+9

data/vendor/spinel/test/empty_method_returns_nil.rb

@@ -0,0 +1,8 @@
+# An empty method body implicitly returns nil.
+def f; end
+puts f.nil?
+def g
+end
+x = g
+puts x.nil?
+puts f.inspect

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

@@ -0,0 +1,3 @@
+true
+true
+nil

data/vendor/spinel/test/empty_symbol_literal.rb

@@ -0,0 +1,23 @@
+# The empty symbol literal `:""` is a real SymbolNode whose content is
+# "". collect_sym_names skipped "" (its shared helper guards param-name
+# callers against a blank), so the symbol got no table entry and
+# compile_symbol_literal fell back to sp_sym_intern -- a function that is
+# only emitted when the intern path is otherwise needed, leaving an
+# `undefined reference to sp_sym_intern` link failure for a bare `:""`.
+
+s = :""
+puts s.to_s.length          #=> 0
+puts(s == :"")              #=> true
+puts(:"" == :"")           #=> true
+puts(:"" == :a)            #=> false
+
+# In a symbol array and as a value.
+arr = [:"", :a, :""]
+puts arr.length             #=> 3
+puts arr[0].to_s.length     #=> 0
+puts arr[1].to_s            #=> a
+
+# Round-trips through to_s/to_sym.
+t = "".to_sym
+puts(t == :"")             #=> true
+puts "done"

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

@@ -0,0 +1,9 @@
+0
+true
+true
+false
+3
+0
+a
+true
+done

data/vendor/spinel/test/eq_string_vs_int.rb

@@ -0,0 +1,20 @@
+# A String and an Integer are never == in Ruby (no implicit coercion).
+# Spinel used to lock the == operand types and emit sp_str_eq(str, int)
+# (or int == char*), failing to compile.
+p("3" == 3)
+p(3 == "3")
+p("3" != 3)
+p(3 != "3")
+# Same-type comparisons still behave normally.
+p("3" == "3")
+p(3 == 3)
+p("3" == "4")
+
+# Both operands are still evaluated (side effects preserved).
+$c = 0
+def bump
+  $c = $c + 1
+  "x"
+end
+p(bump == 5)
+p $c

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

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

data/vendor/spinel/test/exception_backtrace_empty.rb

@@ -0,0 +1,12 @@
+# Issue #895: Exception#backtrace returns an empty str_array
+# (spinel doesn't track per-exception frames -- same rationale
+# as the deferred Kernel#caller in #878). Returning [] keeps
+# `.first` / `.length` from segfaulting on a nil receiver.
+begin
+  raise ArgumentError, "bad arg"
+rescue => e
+  puts e.class
+  puts e.message
+  puts e.backtrace.inspect
+  puts e.backtrace.empty?
+end

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

@@ -0,0 +1,4 @@
+ArgumentError
+bad arg
+[]
+true

data/vendor/spinel/test/exception_class_new.rb

@@ -0,0 +1,46 @@
+# Phase 1C: built-in exception class `.new("msg")`.
+# `RuntimeError.new(...)`, `ArgumentError.new(...)` etc. previously
+# emitted an undefined `sp_RuntimeError` type (the analyze inferred
+# obj_RuntimeError but no struct backed it). Spinel now models
+# built-in exception objects as their message string plus a
+# side-channel cls name -- the same convention `rescue => e` uses.
+#
+# Covers (Phase 1C):
+#   - CLS.new("msg") with various exception classes
+#   - .class returns the class name (string in spinel)
+#   - .message returns the msg
+#   - .is_a? walks the hierarchy
+#
+# Covers (Phase 1D):
+#   - raise <exception_object> -- raise a pre-built exc
+#   - raise CLS.new("msg") -- raise an inline-constructed exc
+
+err = RuntimeError.new("created")
+puts err.class                     # RuntimeError
+puts err.message                   # created
+puts err.is_a?(RuntimeError)       # true
+puts err.is_a?(StandardError)      # true
+puts err.is_a?(Exception)          # true
+
+# raise the saved object
+begin
+  raise err
+rescue => e
+  puts "caught: #{e.class}: #{e.message}"
+end
+
+# raise an inline-constructed exception (1D)
+begin
+  raise ArgumentError.new("inline ae")
+rescue => e
+  puts "inline: #{e.class}: #{e.message}"
+end
+
+# StandardError subclass with .new
+e2 = TypeError.new("bad type")
+puts e2.class                      # TypeError
+puts e2.message                    # bad type
+
+# Various built-in exception classes
+e3 = NoMethodError.new("missing")
+puts e3.class                      # NoMethodError

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

@@ -0,0 +1,10 @@
+RuntimeError
+created
+true
+true
+true
+caught: RuntimeError: created
+inline: ArgumentError: inline ae
+TypeError
+bad type
+NoMethodError

data/vendor/spinel/test/exception_namespaced_default_message.rb

@@ -0,0 +1,28 @@
+# #692: namespaced exception class default message must use Ruby's
+# `::` module separator, not the C-mangled `_` form spinel uses
+# internally.
+
+module ActiveRecord
+  class RecordNotFound < StandardError
+  end
+
+  class RecordInvalid < StandardError
+  end
+end
+
+module Outer
+  module Inner
+    class DeepError < StandardError
+    end
+  end
+end
+
+# Non-namespaced subclass with underscore in its name should NOT
+# get the underscore replaced (My_Class is one identifier).
+class My_Class < StandardError
+end
+
+puts ActiveRecord::RecordNotFound.new.message
+puts ActiveRecord::RecordInvalid.new.message
+puts Outer::Inner::DeepError.new.message
+puts My_Class.new.message

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

@@ -0,0 +1,4 @@
+ActiveRecord::RecordNotFound
+ActiveRecord::RecordInvalid
+Outer::Inner::DeepError
+My_Class