rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/hash_param_each_kv_weak_default.rb

@@ -0,0 +1,75 @@
+# Issue #408. Two coordinated changes here:
+#
+# 1. Port the per-block-body str-concat collector from codegen.rb
+#    to spinel_analyze.rb. The original #408 fix (commit 9ca01d77)
+#    added it to spinel_codegen.rb's narrow_param_hash_types_from_body_writes,
+#    but the analyze/codegen split (PR #416) moved the
+#    inference passes to spinel_analyze.rb; the codegen-side copy
+#    no longer runs. The analyze-side copy now harvests the
+#    same str-concat hints from `pname.each do |k, v|` block
+#    bodies that the codegen copy used to.
+#
+# 2. Option B "weak default" from Ori's issue body: when no
+#    concrete signals at all (no `[]=` writes, no str-concat
+#    hints from the each-block) and the current param type is
+#    `poly_poly_hash` / `sym_poly_hash` / `str_poly_hash`, AND
+#    the body has at least one `pname.each do |k, v|` shape on
+#    the param, default to `str_str_hash`. Unsound in general
+#    but covers the dominant string-keyed-Hash shape in
+#    Rails/Tep-like code where the body just iterates without
+#    inserting back.
+#
+# Out of scope for this fix (still #424): when the each-body
+# calls a sibling cmeth with k or v as an arg, propagating that
+# k/v narrowing into the cmeth's param widening needs a
+# different scope-handling shape than the inference pipeline
+# currently uses (the targeted block-scope push tried for #424
+# breaks issue207's static-fold convergence). #424 stays open
+# with a comment explaining the residual.
+
+# Shape 1: str-concat hint -- the existing path. The body
+# concatenates `+ k + "=" + v` into `out`; both k and v
+# contribute "string" to the hash variant inference.
+module Joiner
+  def self.encode(h)
+    out = ""
+    first = true
+    h.each do |k, v|
+      if !first
+        out = out + ","
+      end
+      first = false
+      out = out + k + "=" + v
+    end
+    out
+  end
+end
+
+puts Joiner.encode({"a" => "1", "b" => "2"})    # a=1,b=2
+
+# Shape 2: weak default -- no str-concat, just each|k,v|. The
+# body delegates to sibling cmeths whose param types haven't
+# been widened yet; option B sees the each|k,v| presence and
+# defaults the param to str_str_hash so the body compiles
+# under that assumption.
+class HashDumper
+  def initialize
+    @pairs = []
+  end
+  attr_reader :pairs
+
+  def collect(h)
+    h.each do |k, v|
+      @pairs << k
+      @pairs << v
+    end
+  end
+end
+
+d = HashDumper.new
+d.collect({"name" => "ada", "role" => "engineer"})
+puts d.pairs.length.to_s   # 4
+puts d.pairs[0]            # name
+puts d.pairs[1]            # ada
+puts d.pairs[2]            # role
+puts d.pairs[3]            # engineer

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

@@ -0,0 +1,6 @@
+a=1,b=2
+4
+name
+ada
+role
+engineer

data/vendor/spinel/test/hash_param_widen_from_callee_slot.rb

@@ -0,0 +1,43 @@
+# Hash-typed parameter back-propagation from callee slot:
+# `def outer(into); inner(into); end` where `inner` already
+# widened its `into` slot to a poly variant (via body
+# heterogeneous writes) should widen `outer`'s `into` slot to
+# the same poly variant. Symmetric extension of #453's ptr-back-
+# prop applied to hash types.
+#
+# Surfaces in real-blog's
+# `CgiIo.parse_form_into(into) -> CgiIo.assign_form_pair(into, ...)`
+# chain where assign_form_pair widens to str_poly_hash via its
+# body's mixed `into[k] = val` (string) + `into[k] = {}` (hash)
+# writes; pre-fix the outer parse_form_into kept `into` typed
+# str_int_hash and the C call passed it into a str_poly_hash *
+# slot.
+
+module Form
+  # Heterogeneous body — into[k] = string AND into[k] = {} —
+  # widens `into` to str_poly_hash via narrow_param_hash.
+  def self.assign(into, k, v)
+    if k.include?("[")
+      into[k] = {}
+    else
+      into[k] = v
+    end
+  end
+
+  # Bare-call forward of `into` — outer's `into` should widen
+  # to the same str_poly_hash via callee-slot back-prop.
+  def self.parse(input, into)
+    input.split("&").each { |pair| assign(into, pair, "v") }
+  end
+
+  # Driver that creates a properly-typed sym_poly_hash and
+  # widens through the chain. Using a heterogeneous initial
+  # literal pins the LV at str_poly_hash from the start.
+  def self.run
+    h = { "x" => "v", "nested" => {} }
+    parse("a=1&b=2", h)
+    h.length
+  end
+end
+
+puts Form.run

data/vendor/spinel/test/hash_replace_variants.rb

@@ -0,0 +1,17 @@
+# Hash#replace on the 4 common typed-hash variants — empty
+# receiver and copy entries from `other` in original-key order.
+# Returns the receiver.
+
+h1 = {a: 1, b: 2}; h2 = {c: 3, d: 4}; h1.replace(h2)
+puts h1.inspect
+puts h1[:c]
+puts h1[:a]
+
+h3 = {a: "x"}; h4 = {b: "y"}; h3.replace(h4)
+puts h3.inspect
+
+h5 = {"a" => 1}; h6 = {"b" => 2}; h5.replace(h6)
+puts h5.inspect
+
+h7 = {"a" => "x"}; h8 = {"b" => "y"}; h7.replace(h8)
+puts h7.inspect

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

@@ -0,0 +1,6 @@
+{c: 3, d: 4}
+3
+
+{b: "y"}
+{"b"=>2}
+{"b"=>"y"}

data/vendor/spinel/test/hash_temp_gc_root.rb

@@ -0,0 +1,26 @@
+# #689: Hash temporaries created from `{}` literals must be GC-rooted
+# before subsequent allocations, otherwise GC may reclaim them mid-
+# expression and the consuming call reads NULL+offset.
+#
+# Simulates the failing pattern: two hash literals constructed in
+# sequence, the first consumed by a helper that allocates more.
+
+def two_hashes(a, b)
+  a.length + b.length
+end
+
+# Drive GC by allocating between binding and consumption.
+i = 0
+while i < 5000
+  h1 = {"x" => 1, "y" => 2}
+  h2 = {"a" => 3, "b" => 4}
+  # Allocate strings to force GC pressure between the two hash
+  # literals (the same pattern that #689 hits with stylesheet_link_tag).
+  filler = "filler-" + i.to_s + "-" + i.to_s
+  if two_hashes(h1, h2) != 4
+    puts "broken at #{i}"
+    exit 1
+  end
+  i += 1
+end
+puts "ok"

data/vendor/spinel/test/hash_transform_keys_cross.rb

@@ -0,0 +1,12 @@
+# Hash#transform_keys with a sym → string block: result is a
+# str_*_hash (key-type swap). Same-type blocks preserve the variant.
+h = {a: 1, b: 2}
+r1 = h.transform_keys { |k| k.to_s }
+puts r1.inspect
+puts r1["a"]
+puts r1["b"]
+
+# Same-type block: sym → sym keeps sym_int_hash
+r2 = {a: 1, b: 2}.transform_keys { |k| k }
+puts r2.inspect
+puts r2[:a]

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

@@ -0,0 +1,5 @@
+{"a"=>1, "b"=>2}
+1
+2
+{a: 1, b: 2}
+1

data/vendor/spinel/test/hash_value_p.rb

@@ -0,0 +1,19 @@
+# Issue #738 (partial -- value? / has_value?). Hash#value?(v) returns
+# true if any value in the hash equals v, else false. spinel used to
+# fall through to the unresolved-call warning.
+
+# sym_int_hash
+h = { a: 1, b: 2 }
+puts h.value?(2)
+puts h.value?(99)
+puts h.has_value?(1)
+
+# str_str_hash
+h2 = { "x" => "alpha", "y" => "beta" }
+puts h2.value?("alpha")
+puts h2.value?("zzz")
+
+# str_int_hash
+h3 = { "one" => 1, "two" => 2 }
+puts h3.value?(1)
+puts h3.value?(3)

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

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

data/vendor/spinel/test/hash_value_split_widen.rb

@@ -0,0 +1,22 @@
+# Sibling to #437. `h = {}; h[pa[i]] = pb[i]` where both `pa` and
+# `pb` come from `split` results inside a method body. #437 added
+# str_int_hash → str_str_hash widening in refine_locals_multi_pass_full
+# but the analogous merge rule in refine_method_body_locals was
+# missing, so `def f; ... end` shapes stayed at str_int_hash even
+# after pass 2 resolved both key and value as string.
+
+def build_str_str(a, b)
+  pa = a.split("/")
+  pb = b.split("/")
+  h = {}
+  i = 0
+  while i < pa.length
+    h[pa[i]] = pb[i]
+    i += 1
+  end
+  h
+end
+
+r = build_str_str("a/b", "x/y")
+puts r["a"]
+puts r["b"]

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

@@ -0,0 +1,2 @@
+x
+y

data/vendor/spinel/test/hash_values_at_fetch_values.rb

@@ -0,0 +1,23 @@
+# Hash#values_at / #fetch_values on typed hashes. Each key is looked up
+# and the values collected into an array; values_at yields nil for a
+# missing key, fetch_values raises KeyError. Results box into a
+# poly_array so mixed value types and nil coexist.
+h = {a: 1, b: 2, c: 3}
+p h.values_at(:a, :c)
+p h.values_at(:a, :c, :d)
+p h.fetch_values(:a, :b, :c)
+
+s = {"x" => 10, "y" => 20}
+p s.values_at("x", "z")
+
+ss = {a: "one", b: "two"}
+p ss.values_at(:a, :b, :c)
+
+pp = {a: 1, b: "two", c: nil}
+p pp.values_at(:a, :b, :c, :d)
+
+begin
+  h.fetch_values(:a, :z)
+rescue KeyError
+  puts "KeyError raised"
+end

data/vendor/spinel/test/hash_variant_call_boundary_sym.rb

@@ -0,0 +1,27 @@
+# #690: Symbol-keyed hash literal passed to a sym_poly_hash-typed
+# callee param must convert at the call boundary; the post-#676
+# kwargs-bind path no longer covered this shape.
+#
+# Mirrors the failing roundhouse pattern: render_attrs takes
+# Hash[Symbol, untyped] (sym_poly_hash), callers pass a literal
+# {key: val} (sym_str_hash). The value types diverge, so the call
+# needs sp_SymStrHash_to_sym_poly to bridge.
+
+def render_attrs(attrs)
+  pairs = []
+  attrs.each do |k, v|
+    pairs << k.to_s + "=" + v.to_s
+  end
+  pairs.join(" ")
+end
+
+# Calling with a Symbol-keyed string-valued literal.
+puts render_attrs({ class: "primary", id: "go" })
+
+# Calling with the merged form: literal SymStr + LV SymStr.
+def build_attrs
+  inner = { id: "foo" }
+  render_attrs({ class: "btn" }.merge(inner))
+end
+
+puts build_attrs

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

@@ -0,0 +1,2 @@
+class=primary id=go
+class=btn id=foo

data/vendor/spinel/test/heterogeneous_tuple_return.rb

@@ -0,0 +1,32 @@
+def kv(s)
+  return nil, nil if s.empty?
+  return s, s
+end
+
+a, b = kv("x")
+p [a, b]
+c, d = kv("")
+p [c, d]
+
+def mixed(s)
+  return 1, 1, 1 if s == "i"
+  return "a", "b", "c" if s == "s"
+  return nil, nil, nil
+end
+
+e, f, g = mixed("i")
+p [e, f, g]
+h, i, j = mixed("s")
+p [h, i, j]
+k, l, m = mixed("x")
+p [k, l, m]
+
+def partial(s)
+  return s, 1 if s.empty?
+  return s, "x"
+end
+
+n, o = partial("")
+p [n, o]
+q, r = partial("y")
+p [q, r]

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

@@ -0,0 +1,7 @@
+["x", "x"]
+[nil, nil]
+[1, 1, 1]
+["a", "b", "c"]
+[nil, nil, nil]
+["", 1]
+["y", "x"]

data/vendor/spinel/test/i1006.rb

@@ -0,0 +1,21 @@
+path = "i1006_tmp.txt"
+File.delete(path) if File.exist?(path)
+
+f = File.open(path, "w")
+f.write("hello\n")
+f.write("world\n")
+f.close
+puts f.closed?
+
+g = File.open(path, "r")
+puts g.read
+puts g.eof?
+g.close
+
+h = File.open(path, "r")
+puts h.gets.chomp
+puts h.gets.chomp
+puts h.gets.nil?
+h.close
+
+File.delete(path)

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

@@ -0,0 +1,7 @@
+true
+hello
+world
+true
+hello
+world
+true

data/vendor/spinel/test/i1007.rb

@@ -0,0 +1,25 @@
+class Server
+  def self.run(sfd)
+    f = Fiber.new { sfd + 1 }
+    f.resume
+  end
+  def self.work(sfd)
+    sfd * 2
+  end
+end
+
+class Worker
+  def run(sfd)
+    f = Fiber.new { sfd + 1 }
+    f.resume
+  end
+  def work(sfd)
+    sfd * 2
+  end
+end
+
+puts Server.run(10)
+puts Server.work(5)
+w = Worker.new
+puts w.run(10)
+puts w.work(5)

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

@@ -0,0 +1,4 @@
+11
+10
+11
+10

data/vendor/spinel/test/i1009.rb

@@ -0,0 +1,9 @@
+s = "a\e[31mred\e[0mb"
+puts s.gsub(/\033\[[0-9;]*[A-Za-z]/, "")
+
+t = "x\033y"
+puts (t =~ /\033/).inspect
+puts t.match?(/\033/)
+
+u = "p\x1bq"
+puts (u =~ /\x1b/).inspect

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

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

data/vendor/spinel/test/i1011.rb

@@ -0,0 +1,12 @@
+# ffi_cflags / ffi_func args fold compile-time string forms:
+# __dir__, File.expand_path(rel, base), and String#+. The folded
+# -I<dir> is a harmless include path; the test passes iff the fold
+# succeeds (a non-foldable arg would abort analyze with "string
+# literal" before this runs).
+module Pathy
+  ffi_cflags("-I" + File.expand_path(".", __dir__))
+  ffi_func :strlen, [:str], :size_t
+end
+
+puts Pathy.strlen("hello")
+puts Pathy.strlen("")

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

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

data/vendor/spinel/test/i1015.rb

@@ -0,0 +1,11 @@
+def check(selector, body)
+  tag = selector[/\A[a-z]+/]
+  raise "no #{selector}" unless tag && body.include?("<#{tag}")
+  yield
+end
+check("div", "<div>x</div>") { puts "found div" }
+begin
+  check("p", "<div>x</div>") { puts "unreachable" }
+rescue => e
+  puts "raised: #{e.message}"
+end

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

@@ -0,0 +1,2 @@
+found div
+raised: no p

data/vendor/spinel/test/i1017.rb

@@ -0,0 +1,37 @@
+# Issue #1017: a proc body whose tail expression is an FFI :ptr value
+# wasn't cast to (mrb_int)(uintptr_t) before being returned through the
+# proc-fn `mrb_int` ABI slot. The existing #709 cast bridge (in
+# compile_proc_literal) guarded on `type_is_pointer == 1`, but FFI :ptr
+# is intentionally non-GC and reports 0 there, so the cast was skipped
+# and cc failed with -Wint-conversion.
+#
+# Repro: a yielding constructor whose block tail is an `ffi_read_ptr`
+# call. Without the fix, cc rejects `return ((void *)(...))` from a
+# `mrb_int`-returning `_sp_proc_fn_N`. With the fix, the read yields
+# NULL (BSS-zero buffer) and the pool's free list ends up holding nil.
+
+module Buf
+  ffi_buffer :scratch, 16
+  ffi_read_ptr :first_ptr, 0
+end
+
+class Pool
+  def initialize(n)
+    @free = []
+    i = 0
+    while i < n
+      @free.push(yield)
+      i += 1
+    end
+  end
+  def first
+    @free[0]
+  end
+end
+
+p = Pool.new(1) { Buf.first_ptr(Buf.scratch) }
+if p.first == nil
+  puts "ok"
+else
+  puts "not_ok"
+end

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

@@ -0,0 +1 @@
+ok

data/vendor/spinel/test/i1020.rb

@@ -0,0 +1,31 @@
+class Item
+  def initialize(tag); @tag = tag; end
+  attr_reader :tag
+end
+module S
+  def self.root; Item.new("R"); end
+  def self.list
+    [Item.new("a"), Item.new("b"), Item.new("c"),
+     Item.new("d"), Item.new("e"), Item.new("f"),
+     Item.new("g"), Item.new("h"), Item.new("i")]
+  end
+end
+
+def f(table)
+  i = 0
+  while i < table.length
+    table[i]
+    i += 1
+  end
+end
+
+bad = 0
+i = 0
+while i < 50
+  combined = [S.root] + S.list
+  bad += 1 if combined.length != 10
+  f(combined)
+  i += 1
+end
+puts bad
+puts "done"

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

@@ -0,0 +1,2 @@
+0
+done

data/vendor/spinel/test/i1021.rb

@@ -0,0 +1,12 @@
+s = GC.stat
+puts s.key?("bytes")
+puts s.key?("old_bytes")
+puts s.key?("threshold")
+puts s.key?("cycle")
+puts s.key?("full_runs")
+puts s["bytes"] >= 0
+puts s["threshold"] > 0
+GC.start
+t = GC.stat
+puts t["cycle"] >= s["cycle"]
+puts "done"

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

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

data/vendor/spinel/test/i1027.rb

@@ -0,0 +1,28 @@
+# Issue #1027: string interpolation of a method that returns sp_String *
+# (the mutable-string type backing `String.new` + `<<`) emitted the
+# pointer cast to long long with `%lld` instead of reading the string
+# contents with `%s` + sp_String_cstr.
+#
+# The dispatch chain in compile_string_interp had arms for "int",
+# "bigint", "float", "string", "bool", "poly", "class", "encoding",
+# "symbol", "exception", "nil", and the array families — but no arm
+# for "mutable_str", so an interpolated sp_String * fell through to
+# the integer fallback and rendered as a pointer address.
+#
+# Direct `<<` on the same value already worked via sp_String_append
+# (the type info exists; only the interp format-spec dispatch missed
+# the arm). Surfaced in roundhouse view emit after a lowering coalesced
+# `io << x; io << y; io << z` runs into `io << "...#{y}..."`-style
+# string-interpolation. Other roundhouse targets (ts/crystal/rust/go/
+# ruby) interpolate cleanly because their string primitives accept
+# the mutable variant directly; only spinel needed the missing arm.
+
+module M
+  def self.make
+    s = String.new
+    s << "hello"
+    s
+  end
+end
+
+puts "[#{M.make}]"

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

@@ -0,0 +1 @@
+[hello]

data/vendor/spinel/test/i1031.rb

@@ -0,0 +1,64 @@
+# A fiber's captured locals must survive a GC that fires while the
+# fiber is parked. The capture struct holds the only reference to
+# these objects; without a scan hook on it the collector frees them
+# and a later resume reads freed memory (use-after-free). Forcing
+# several collections via GC.start while multiple fibers are parked
+# is what surfaces the corruption.
+class Holder
+  attr_reader :data
+  def initialize(label)
+    @data = "holder_payload_" + label
+  end
+end
+
+def churn(n)
+  i = 0
+  s = ""
+  while i < n
+    s = s + i.to_s + ","
+    i += 1
+  end
+  s.length
+end
+
+results = []
+
+f1 = Fiber.new do
+  h1 = Holder.new("one")
+  Fiber.yield
+  results.push(h1.data)
+end
+
+f2 = Fiber.new do
+  h2 = Holder.new("two")
+  Fiber.yield
+  results.push(h2.data)
+end
+
+f3 = Fiber.new do
+  h3 = Holder.new("three")
+  Fiber.yield
+  results.push(h3.data)
+end
+
+f1.resume
+f2.resume
+f3.resume
+
+n = 0
+while n < 20
+  churn(200)
+  GC.start
+  n += 1
+end
+
+f3.resume
+f1.resume
+f2.resume
+
+puts results.length
+i = 0
+while i < results.length
+  puts results[i]
+  i += 1
+end

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

@@ -0,0 +1,4 @@
+3
+holder_payload_three
+holder_payload_one
+holder_payload_two