rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/bigint_volatile_combo.rb

@@ -0,0 +1,69 @@
+# Regression test: bigint operations inside begin/rescue must compile
+# clean under -Werror. Locals in setjmp-bearing functions are emitted
+# `volatile sp_Bigint *`, but the bigint runtime takes plain
+# `sp_Bigint *`. Without (sp_Bigint *) casts at every emit site, gcc
+# / clang warn about discarded qualifiers, and the test runner's
+# -Werror promotes that to a hard fail.
+#
+# Exercises every bigint operator dispatch path that previously
+# emitted a cast-free local read. Output values are not the focus —
+# the test runner gates on the C code compiling clean with -Werror.
+
+a = 1
+i = 0
+while i < 50
+  a = a * 2
+  i = i + 1
+end
+
+# Inside begin/rescue: every binary operator + comparison + to_s/to_i
+begin
+  b = a + a
+  puts b.to_s.length > 0
+  c = a - a
+  puts c.to_s.length > 0
+  d = a * a
+  puts d.to_s.length > 0
+  e = a / 2
+  puts e.to_s.length > 0
+  f = a % 7
+  puts f.to_s.length > 0
+  puts a > 0
+  puts a < 0
+  puts a >= 0
+  puts a <= 0
+  puts a == a
+  puts a != 0
+  puts a.to_s.length > 0
+  puts a.to_i > 0
+rescue
+  puts "caught"
+end
+
+# Compound assignment inside begin/rescue. `x = x + 1` desugars to
+# LocalVariableWriteNode + CallNode; the `+=` family lowers through
+# LocalVariableOperatorWriteNode, a distinct code path that has its
+# own bigint cast in compile_LocalVariableAndWriteNode.
+begin
+  x = a
+  x += 1
+  x *= 2
+  x -= 1
+  x /= 2
+  x %= 7
+  puts x.to_s.length > 0
+rescue
+  puts "caught"
+end
+
+# puts/p of bigint inside begin/rescue. Single-arg dispatches through
+# compile_puts_single; multi-arg through compile_puts. Both arms have
+# their own bigint cast and need exercising. `print` lands in the
+# multi-arg path too.
+begin
+  puts a
+  puts a, a
+  print a, "\n"
+rescue
+  puts "caught"
+end

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

@@ -0,0 +1,18 @@
+true
+true
+true
+true
+true
+true
+false
+true
+false
+true
+true
+true
+true
+true
+1125899906842624
+1125899906842624
+1125899906842624
+1125899906842624

data/vendor/spinel/test/block_given_block_param.rb

@@ -14,9 +14,8 @@
 # existing `@in_yield_method` branch.
 #
 # This test exercises the no-block-passed observable through the
-# receiverless default-padding path. (Receivered + literal-block
-# paths route through the yield-inliner's own `block_given?`
-# shortcut, which doesn't transit the new lowering at all.)
+# receiverless default-padding path and the explicit `self.block_given?`
+# spelling.
 
 # 1. Top-level `&block` method, called without a block — block_given?
 #    must return false. Pre-fix this constant-returned 0 with no
@@ -43,4 +42,23 @@ end
 
 top2("2")                 #=> 2-no
 
+def top3(&block)
+  if self.block_given?
+    puts "3-yes"
+  else
+    puts "3-no"
+  end
+end
+
+def top4(&block)
+  if self.block_given?
+    puts "4-yes"
+  else
+    puts "4-no"
+  end
+end
+
+top3                      #=> 3-no
+top4 {}                   #=> 4-yes
+
 puts "done"

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

@@ -1,3 +1,5 @@
 1-no
 2-no
+3-no
+4-yes
 done

data/vendor/spinel/test/block_given_inline_call_site.expected

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

data/vendor/spinel/test/block_given_inline_call_site.rb

@@ -0,0 +1,9 @@
+# Issue #706: block_given? in a yield-using method, called from
+# a site that either omits the block (zero-arg case emits
+# `sp_f(NULL, NULL)`) or supplies a literal block (inline path
+# correctly answers true).
+def f
+  puts block_given?
+end
+f
+f { }

data/vendor/spinel/test/block_optional_unused.rb

@@ -0,0 +1,18 @@
+class Greeter
+  def greet(text = nil, &block)
+    puts text || "anonymous"
+    yield if block
+  end
+
+  def call_internal
+    greet("internal")
+  end
+end
+
+Greeter.new.greet("hi")
+Greeter.new.call_internal
+
+def forwarder(&block)
+  Greeter.new.greet("forwarded", &block)
+end
+forwarder { puts "  block received" }

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

@@ -0,0 +1,4 @@
+hi
+internal
+forwarded
+  block received

data/vendor/spinel/test/block_param_call_block_given.rb

@@ -0,0 +1,46 @@
+# A method that captures its block as `&blk` AND calls `block_given?`
+# must still invoke the block through the &blk slot. The block_given?
+# call makes the method look like a yield-method, which previously
+# routed the literal-block call site through the yield-inline path;
+# that path renamed the block local to `blk_y<N>` but left the body's
+# `blk.call` referencing the original `lv_blk` (undeclared C). The
+# fix skips inlining when the method has a trailing &block param and
+# forwards the literal block into that slot instead, padding the
+# trailing yield-ABI slots with NULL.
+
+# 1. Top-level &blk + block_given? + blk.call.
+def build(&blk)
+  blk.call(42) if block_given?
+end
+build { |x| puts x }              #=> 42
+
+# 2. Expression context: the call result is consumed.
+def build_v(&blk)
+  r = blk.call(21) if block_given?
+  r
+end
+puts build_v { |x| x * 2 }        #=> 42
+
+# 3. Instance method.
+class Foo
+  def run(&blk)
+    blk.call(7) if block_given?
+  end
+end
+Foo.new.run { |x| puts x }        #=> 7
+
+# 4. Singleton (class) method.
+class Bar
+  def self.make(&blk)
+    blk.call(9) if block_given?
+  end
+end
+Bar.make { |x| puts x }           #=> 9
+
+# 5. A method mixing &blk and an actual yield still works.
+def mix(&blk)
+  yield 5 if block_given?
+end
+mix { |x| puts x }                #=> 5
+
+puts "done"

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

@@ -0,0 +1,6 @@
+42
+42
+7
+9
+5
+done

data/vendor/spinel/test/block_param_call_value_return.rb

@@ -0,0 +1,32 @@
+# An &block-param method called with a literal block returns the
+# value of blk.call, typed by the block body's return type rather than
+# the int default. The block value is carried through sp_proc_call's
+# mrb_int slot (a uniform C signature) and cast back per call site, so
+# distinct literal blocks coexist without an ABI change.
+
+def applies(&blk)
+  blk.call("hi")
+end
+
+# string-returning block: the carried pointer prints as a string,
+# not a raw address.
+puts applies { |x| x.upcase }
+
+# int-returning block at the SAME method: per-call-site typing, no
+# signature change.
+puts applies { |x| x.length }
+
+# block body that does not depend on the param's type works for
+# instance methods too (value-return typing is receiver-agnostic).
+class Runner
+  def run(&blk)
+    blk.call("hi")
+  end
+end
+puts Runner.new.run { "fixed" }
+puts Runner.new.run { |x| "got" }
+
+# instance &block method whose block body depends on the yielded arg's
+# type: the block param is typed from blk.call's arg (string here), so
+# string methods resolve.
+puts Runner.new.run { |x| x.upcase }

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

@@ -0,0 +1,5 @@
+HI
+2
+fixed
+got
+HI

data/vendor/spinel/test/bm_instance_eval.rb

@@ -127,10 +127,9 @@ puts boot.routes.entries[1]      # POST /ivar
 
 # ---- 9. Ivar receiver in tail position of a class method ----
 # Same lift but the instance_eval call is the method body's last
-# expression. The pre-existing v1 path always emitted the lift in
-# statement form; here it must round-trip through compile_ieval_call_expr
-# (the comma-expression form) so the enclosing method can still
-# return the receiver. Sister-class with a typed return signature.
+# expression. The block's last call (`get("/tail")`) returns the
+# entries array, so the lift's value would flow out; explicitly
+# return @routes to keep `setup` returning the receiver.
 class Configure
   attr_accessor :routes
 
@@ -140,6 +139,7 @@ class Configure
 
   def setup
     @routes.instance_eval { get("/tail") }
+    @routes
   end
 end
 
@@ -171,13 +171,14 @@ puts shared.entries.length  # 1
 puts shared.entries[0]      # GET /param
 
 # ---- 11. Param receiver in tail position ----
-# Same as §10 but the lift is the method body's last expression so
-# the wire_param signature has to match the comma-expression return
-# value. infer_call_type's synthetic-name early case (PR #15
-# follow-up landed in PR #158) handles this once the rewrite fires.
+# Same as §10 but the lift is the method body's last expression.
+# Block's last call (`get("/tail-param")`) returns the entries
+# array; explicitly return `r` to keep wire_param returning the
+# receiver.
 class WireTail
   def wire_param(r)
     r.instance_eval { get("/tail-param") }
+    r
   end
 end
 

data/vendor/spinel/test/bool_case_equality.rb

@@ -0,0 +1,10 @@
+# TrueClass#=== / FalseClass#=== is case equality: true only when the
+# argument is a boolean with the same value.
+p(true === true)
+p(true === false)
+p(true === 1)
+p(false === false)
+p(false === true)
+x = true
+p(x === true)
+p(x === false)

data/vendor/spinel/test/bool_logical_operators.rb

@@ -0,0 +1,9 @@
+# TrueClass / FalseClass #& #| #^ return a boolean, not an int.
+p (true & true)
+p (true | false)
+p (true ^ false)
+p (false & true)
+p (true & false)
+p (false | false)
+p (true ^ true)
+p (false ^ false)

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

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

data/vendor/spinel/test/builtin_array_method_capture.rb

@@ -0,0 +1,38 @@
+# `<int_array>.method(:op)` lowered through a per-(type, op)
+# trampoline matching the Method dispatch ABI. Surfaced via
+# optcarrot's CPU memory-mapping shape
+# `add_mappings(0x0000..0x07ff, @ram, @ram.method(:[]=))` —
+# the captured Method later sits in @store and is invoked via
+# `@store[addr][addr, val]`.
+#
+# Three operators supported in the first cut: `:[]`, `:[]=`,
+# `:push`. Other (recv_type, mname) pairs still fall through to
+# the unresolved-call warning until they're added to
+# emit_builtin_array_method_adapter.
+
+a = [10, 20, 30, 40, 50]
+
+mget = a.method(:[])
+mset = a.method(:[]=)
+mpush = a.method(:push)
+
+# Read via captured Method: bracket-call shape.
+puts mget[0]
+puts mget[2]
+puts mget[4]
+
+# Write via captured Method: mutates the receiver in place.
+mset[1, 200]
+mset[3, 400]
+puts a[0]
+puts a[1]
+puts a[2]
+puts a[3]
+puts a[4]
+
+# Push via captured Method: extends the receiver.
+mpush[60]
+mpush[70]
+puts a.length
+puts a[5]
+puts a[6]

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

@@ -0,0 +1,11 @@
+10
+30
+50
+10
+200
+30
+400
+50
+7
+60
+70

data/vendor/spinel/test/bundle_array_e.rb

@@ -0,0 +1,250 @@
+# Bundled tests:
+#   - array_at_append_string_chomp_bang
+#   - array_eq_int_vs_sym_literal
+#   - array_index_nil_for_not_found
+#   - array_keyed_hash_int_array_eql
+#   - array_literal_all_nil_first_is_nil
+#   - array_new_n_fills_nil
+#   - array_new_nil_fill
+#   - array_sum_init
+
+# === array_at_append_string_chomp_bang ===
+def t_array_at_append_string_chomp_bang
+  # Method aliases / shapes from #619 puzzles 8 / 9 / 10:
+  #   Array#at(n)      -> Array#[n]
+  #   Array#append(x)  -> Array#push(x), returning self (the array)
+  #   String#chomp!    -> mutates in place on mutable_str; raises
+  #                       FrozenError on a frozen string literal
+  #                       (#859 / #886). Test exercises the
+  #                       mutable_str path.
+
+  p([1, 2, 3].at(1) == 2)
+  p(%w[a].append("b") == %w[a b])
+  s = String.new("ab\n")
+  s.chomp!
+  p(s.to_s == "ab")
+end
+t_array_at_append_string_chomp_bang
+
+# === array_eq_int_vs_sym_literal ===
+def t_array_eq_int_vs_sym_literal
+  # `[0,0,0] == %i[a a a]` must answer FALSE -- CRuby compares element
+  # classes too, so int 0 != sym :a even when their encoded ids match.
+  # Spinel's sym_array storage shares the sp_IntArray layout with
+  # int_array (sym ids stored as raw mrb_int), and sp_IntArray_eq
+  # compares raw bytes. With SPS_a == 0, both arrays' bytes are
+  # [0,0,0] and the eq returned `true`, breaking `!=` to false.
+  #
+  # Fix: when the equality is between literal `[...]` and literal
+  # `%i[...]` and the static types differ (int_array vs sym_array),
+  # short-circuit to FALSE. The `<<`-widened "int_array carrying
+  # syms at runtime" shape from issue #555 keeps both sides typed
+  # `int_array` (the analyzer leaves the static type alone), so the
+  # guard's "different static types" condition doesn't fire and
+  # IntArray_eq continues to apply. Issue #600 puzzle 1.
+  
+  p [0, 0, 0] != %i[a a a]                 # true
+  p [0, 0, 0] == %i[a a a]                 # false
+  p %i[a a a] != [0, 0, 0]                 # true
+  
+  # Sibling shapes -- arrays of the same element-kind still compare
+  # correctly via IntArray_eq.
+  p [1, 2, 3] == [1, 2, 3]                 # true
+  p %i[a b c] == %i[a b c]                 # true
+  p %i[a b c] != %i[a b]                   # true (length differs)
+  
+  # Issue #555 test #6 shape: int_array with sym pushes at runtime.
+  # Both sides resolve to lt == at == "int_array" statically, so the
+  # new guard doesn't engage and IntArray_eq compares element ids
+  # (which match for the :foo pushed and the :foo literal in [:foo]).
+  a = [1]
+  a.shift
+  a << :foo
+  p a == [:foo]                            # true
+end
+t_array_eq_int_vs_sym_literal
+
+# === array_index_nil_for_not_found ===
+def t_array_index_nil_for_not_found
+  # `Array#index(x)` / `#find_index(x)` / `#rindex(x)` return
+  # Integer | nil in CRuby (nil when not found). spinel previously
+  # returned the raw -1 sentinel from `sp_*Array_index`, which
+  # diverged from CRuby's nil for the not-found case.
+  #
+  # spinel positions itself as a Ruby SUBSET, so documented Ruby
+  # APIs must match CRuby behavior. The fix: codegen now routes
+  # Array#index family through `sp_*Array_index_poly` wrappers
+  # that box nil for not-found / box int for found. The type
+  # inference returns "poly" for the call result so `.nil?` /
+  # `== nil` checks dispatch through the standard poly-tag path.
+  #
+  # The raw `_index` helpers (returning -1) stay for any internal
+  # caller that needs the sentinel.
+  
+  # Int arrays
+  ints = [10, 20, 30, 40]
+  puts ints.index(20).inspect       # 1
+  puts ints.index(999).inspect      # nil
+  puts ints.index(999).nil?         # true
+  puts ints.index(20).nil?          # false
+  puts ints.find_index(30).inspect  # 2
+  
+  # String arrays
+  strs = ["alpha", "beta", "gamma"]
+  puts strs.index("beta").inspect   # 1
+  puts strs.index("zeta").inspect   # nil
+  puts strs.rindex("alpha").inspect # 0
+  puts strs.rindex("zeta").inspect  # nil
+end
+t_array_index_nil_for_not_found
+
+# === array_keyed_hash_int_array_eql ===
+def t_array_keyed_hash_int_array_eql
+  # Array-keyed Hash. `entries[[a, b]] ||= ...` was broken because
+  # spinel's PolyPolyHash defaulted to pointer-identity comparison
+  # for SP_TAG_OBJ keys — every fresh `[a, b]` literal allocated a
+  # new IntArray, so identical-content keys never matched and the
+  # `||=` never deduped. The cache grew unboundedly and reads with
+  # a fresh `[a, b]` returned nil.
+  #
+  # Fix: extend the codegen-emitted sp_obj_hash_hook /
+  # sp_obj_eql_hook to handle SP_BUILTIN_INT_ARRAY with element-wise
+  # content hash + comparison. Two IntArray instances with the same
+  # elements now hash and eql? identically — array-keyed Hash
+  # behaves like CRuby's `Hash` with the [a,b]-style key idiom.
+  
+  entries = {}
+  entries[[1, 2]] = "a"
+  entries[[3, 4]] = "b"
+  entries[[1, 2]] ||= "z"   # already set, no overwrite
+  puts entries[[1, 2]]      # "a"
+  puts entries[[3, 4]]      # "b"
+  puts entries.length       # 2
+  
+  # Heterogeneous keys still work — int / IntArray / string mixed.
+  mixed = {}
+  mixed[42] = "int-key"
+  mixed[[5, 6, 7]] = "arr-key"
+  mixed[[5, 6, 7]] ||= "no-overwrite"
+  puts mixed[42]            # int-key
+  puts mixed[[5, 6, 7]]     # arr-key
+  puts mixed.length         # 2
+end
+t_array_keyed_hash_int_array_eql
+
+# === array_literal_all_nil_first_is_nil ===
+def t_array_literal_all_nil_first_is_nil
+  # `[nil, nil, ...].first` / `.last` returns nil. Pre-fix the
+  # array-literal lowering pushed each NilNode as `sp_IntArray_push(_t, 0)`
+  # (the int_array default) and `.first` returned int 0, so `.nil?`
+  # folded to false. The peephole keeps the int_array layout for the
+  # rest of the inference -- lifting all-nil literals to poly_array
+  # breaks optcarrot's `[nil] * N` initialization -- but recognises
+  # the `[nil, ...].first / .last` shape at the analyzer's CallNode
+  # return-type site. Issue #619 puzzle 5.
+  p [nil].first.nil?               # true
+  p [nil].last.nil?                # true
+  p [nil, nil, nil].first.nil?     # true
+  p [nil, nil, nil].last.nil?      # true
+end
+t_array_literal_all_nil_first_is_nil
+
+# === array_new_n_fills_nil ===
+def t_array_new_n_fills_nil
+  # `Array.new(n)` (single arg, no fill value, no block) is CRuby
+  # shorthand for `Array.new(n, nil)`: an array of n nils, NOT an
+  # empty array. Pre-fix the single-arg lowering returned
+  # `sp_IntArray_new()` (length 0) and downstream `.length` /
+  # `.inspect` / `[i].nil?` saw the wrong shape. Issue #619 puzzle 4.
+  puts Array.new(3).length         # 3
+  puts Array.new(3).inspect        # [nil, nil, nil]
+  puts Array.new(3)[0].nil?        # true
+  puts Array.new(0).length         # 0
+  puts Array.new(5).length         # 5
+end
+t_array_new_n_fills_nil
+
+# === array_new_nil_fill ===
+def t_array_new_nil_fill
+  # `Array.new(n, nil)` -- the fill value is the nil singleton, so
+  # MRI fills each slot with `nil` and `.inspect` prints
+  # "[nil, nil, ...]". Spinel previously lowered the call to an
+  # int_array filled with the C default (0), and inspect printed
+  # "[0, 0, 0]". Lowering must produce a sp_PolyArray so the slot
+  # can carry the nil tag and `.inspect` / `[i].nil?` / etc. see
+  # the actual nil.
+  
+  ary = Array.new(3, nil)
+  puts ary.inspect
+  puts ary[0].nil?
+  puts ary[1].nil?
+  puts ary[2].nil?
+  puts ary.length
+end
+t_array_new_nil_fill
+
+# === array_sum_init ===
+def t_array_sum_init
+  # Array#sum's init argument was silently dropped on the IntArray /
+  # FloatArray dispatch paths -- spinel emitted sp_IntArray_sum(rc)
+  # (no init parameter) and the block-form accumulator in
+  # compile_array_sum_block was hardcoded to `mrb_int t = 0;`.
+  # Pre-fix:
+  #   [1,2,3].sum(10)             # => 6   (CRuby: 16)
+  #   [].sum(7)                   # => 0   (CRuby: 7)
+  #   [1,2,3].sum(10) { |x| x*2 } # => 12  (CRuby: 22)
+  #
+  # Fix: sp_IntArray_sum / sp_FloatArray_sum take an init parameter
+  # and seed the accumulator with it; codegen forwards
+  # compile_arg0(nid) at every sum dispatch. compile_array_sum_block
+  # initialises tmp_sum from compile_arg0(nid).
+  
+  # IntArray, no block
+  puts [1, 2, 3].sum(10)            # 16
+  puts [1, 2, 3].sum                # 6   (no-init regression check)
+  puts [].sum(7)                    # 7   (empty + init survives)
+  puts [].sum                       # 0   (empty default still 0)
+  puts [1, 2].sum(-5)               # -2  (negative init)
+  
+  # IntArray, with block
+  puts [1, 2, 3].sum(10) { |x| x * 2 }   # 22
+  puts [1, 2, 3].sum { |x| x * 2 }       # 12  (block, no init)
+  puts [].sum(7) { |x| x * 2 }           # 7   (empty + init w/ block)
+  
+  # FloatArray, no block
+  puts [1.5, 2.5].sum(0.5)          # 4.5
+  puts [1.5, 2.5].sum               # 4.0 (no-init regression check)
+  puts [1.5, 2.5].sum(1)            # 5.0 (int init implicitly widens)
+  puts [1.5, 2.5].sum(-0.5)         # 3.5 (negative float init)
+  
+  # Poly init: a heterogeneous-array element resolves to a poly local.
+  # compile_arg0_as_int / compile_arg0_as_float unbox via `.v.i` / `.v.f`;
+  # without them gcc rejects passing sp_RbVal to mrb_int / mrb_float.
+  poly_arr = [10, "x"]
+  init_p = poly_arr[0]
+  puts [1, 2].sum(init_p)           # 13 (poly init unboxed as mrb_int)
+  
+  fpoly_arr = [1.5, "x"]
+  finit_p = fpoly_arr[0]
+  puts [1.0, 2.0].sum(finit_p)      # 4.5 (poly init unboxed as mrb_float)
+  
+  # Tag-mixed: poly is INT-tagged but the FloatArray expects mrb_float.
+  # sp_poly_to_f dispatches on the tag so the int value is coerced to
+  # float rather than reinterpreted bit-for-bit from `.v.f`.
+  ipoly_for_float = [1, "x"][0]
+  puts [1.0, 2.0].sum(ipoly_for_float)   # 4.0 (poly INT->float via sp_poly_to_f)
+  
+  # FloatArray + block + float init: compile_array_sum_block now picks
+  # an mrb_float accumulator and compile_arg0_as_float when recv_type is
+  # float_array, so the 0.5 seed and the float block result are no
+  # longer truncated. Use distinct block-param names (`fx` / `fy`) so
+  # they don't get widened by the earlier int blocks' `|x|` -- spinel
+  # hoists block params to a shared function-scope local, an orthogonal
+  # limitation outside this PR's scope.
+  puts [1.5, 2.5].sum(0.5) { |fx| fx }      # 4.5
+  puts [1.0, 2.0].sum { |fy| fy * 1.5 }     # 4.5
+  
+  puts "done"
+end
+t_array_sum_init
+