rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/bundle_class_10.rb

@@ -0,0 +1,189 @@
+# Bundled tests:
+#   - forward_call_class_method_inherited_init_obj
+#   - forward_call_class_method_int_array
+#   - forward_call_class_method_nested
+#   - forward_call_class_method_obj
+#   - forward_call_param_type_int_array
+
+# === forward_call_class_method_inherited_init_obj ===
+# Inherited-init forward-ref where the param type is itself an
+# obj_X user class. Verifies the type flows through both the
+# `Class.new(@h)` constructor branch and the bare `super` of the
+# child's initialize.
+
+class T_forward_call_class_method_inherited_init_obj_Holder
+  def initialize(name)
+    @name = name
+  end
+  def label
+    "h:#{@name}"
+  end
+end
+
+class T_forward_call_class_method_inherited_init_obj_Outer
+  def initialize
+    @h = T_forward_call_class_method_inherited_init_obj_Holder.new("alpha")
+    @child = T_forward_call_class_method_inherited_init_obj_Sub.new(@h)
+  end
+  def report
+    @child.held_label
+  end
+end
+
+class T_forward_call_class_method_inherited_init_obj_Base
+  def initialize(holder)
+    @holder = holder
+  end
+  def held_label
+    @holder.label
+  end
+end
+
+class T_forward_call_class_method_inherited_init_obj_Sub < T_forward_call_class_method_inherited_init_obj_Base
+  def initialize(_holder)
+    super
+  end
+end
+
+o = T_forward_call_class_method_inherited_init_obj_Outer.new
+puts o.report
+
+# === forward_call_class_method_int_array ===
+# `Class.new(int_array_arg)` where the callee class is defined later
+# than the call site. Pre-fix codegen left T_forward_call_class_method_int_array_Target's `arr` param at
+# the default `mrb_int`; the int→class fallback then emitted the
+# call with a Wint-conversion error. Source order kept caller-first.
+
+class T_forward_call_class_method_int_array_Caller
+  def make_target
+    @t = T_forward_call_class_method_int_array_Target.new([10, 20, 30])
+  end
+  def length
+    @t.show
+  end
+end
+
+class T_forward_call_class_method_int_array_Target
+  def initialize(arr)
+    @arr = arr
+  end
+  def show
+    @arr.length
+  end
+end
+
+c = T_forward_call_class_method_int_array_Caller.new
+c.make_target
+puts c.length
+
+# === forward_call_class_method_nested ===
+# Nested forward-ref: `T_forward_call_class_method_nested_Outer.new(T_forward_call_class_method_nested_Inner.new)` where both T_forward_call_class_method_nested_Outer and
+# T_forward_call_class_method_nested_Inner are defined later than the construction site. The T_forward_call_class_method_nested_Inner.new
+# nested arg type must propagate to T_forward_call_class_method_nested_Outer.initialize's param so the
+# outer Class.new ptype widens correctly.
+
+class T_forward_call_class_method_nested_Driver
+  def boot
+    @outer = T_forward_call_class_method_nested_Outer.new(T_forward_call_class_method_nested_Inner.new(42))
+  end
+  def reach
+    @outer.payload.value
+  end
+end
+
+class T_forward_call_class_method_nested_Inner
+  def initialize(v)
+    @v = v
+  end
+  def value
+    @v
+  end
+end
+
+class T_forward_call_class_method_nested_Outer
+  def initialize(inner)
+    @inner = inner
+  end
+  def payload
+    @inner
+  end
+end
+
+d = T_forward_call_class_method_nested_Driver.new
+d.boot
+puts d.reach
+
+# === forward_call_class_method_obj ===
+# `Class.new(obj_X)` shape: caller passes a user-class instance to a
+# forward-defined Class.new. Mirrors the optcarrot
+# `PPU.new(@conf, @cpu, @video.palette)` site where the callee's
+# obj-typed param flowed in from a yet-to-be-defined sibling class.
+
+class T_forward_call_class_method_obj_Holder
+  def initialize(name)
+    @name = name
+  end
+  def label
+    "h:#{@name}"
+  end
+end
+
+class T_forward_call_class_method_obj_Caller
+  def make
+    @h = T_forward_call_class_method_obj_Holder.new("alpha")
+    @t = T_forward_call_class_method_obj_Target.new(@h)
+  end
+  def show
+    @t.held_label
+  end
+end
+
+class T_forward_call_class_method_obj_Target
+  def initialize(h)
+    @holder = h
+  end
+  def held_label
+    @holder.label
+  end
+end
+
+c = T_forward_call_class_method_obj_Caller.new
+c.make
+puts c.show
+
+# === forward_call_param_type_int_array ===
+# File-order caller-first / callee-second: a T_forward_call_param_type_int_array_Caller class invokes a
+# method on a yet-untyped ivar (because the callee class is defined
+# later in the source). Pre-fix codegen left the callee's params at
+# the default `mrb_int` so the IntArray + bool args produced
+# "incompatible-pointer" / "Wint-conversion" errors when the
+# int→class fallback emitted the call. With the forward-ref widening
+# in place the callee picks up `sp_IntArray *` + `mrb_bool` from
+# this single call site.
+
+class T_forward_call_param_type_int_array_Caller
+  def initialize(target)
+    @target = target
+    @arr = [1, 2, 3]
+    @flag = false
+  end
+  def go
+    @target.set_payload(@arr, @flag)
+  end
+end
+
+class T_forward_call_param_type_int_array_Target
+  def set_payload(arr, flag)
+    @arr = arr
+    @flag = flag
+  end
+  def info
+    "len=#{@arr.length} flag=#{@flag}"
+  end
+end
+
+t = T_forward_call_param_type_int_array_Target.new
+c = T_forward_call_param_type_int_array_Caller.new(t)
+c.go
+puts t.info
+

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

@@ -0,0 +1,5 @@
+h:alpha
+3
+42
+h:alpha
+len=3 flag=false

data/vendor/spinel/test/bundle_class_11.rb

@@ -0,0 +1,191 @@
+# Bundled tests:
+#   - forward_call_param_type_obj
+#   - gc_save_double_in_new
+#   - gc_scan_skip_inherited_ivar
+#   - hash_each_param_narrow
+#   - hash_fetch_hash_default
+
+# === forward_call_param_type_obj ===
+# Forward-call with a user-class-typed arg flowing through the
+# caller's ivar to the callee's parameter slot. Mirrors optcarrot's
+# `@ppu.nametables = @mirroring` shape — the callee accepts an
+# `obj_<UserClass>` and the int→class fallback dispatches via the
+# yet-untyped `@ppu` ivar.
+
+class T_forward_call_param_type_obj_Holder
+  def initialize(name)
+    @name = name
+  end
+  def label
+    "h:#{@name}"
+  end
+end
+
+class T_forward_call_param_type_obj_Caller
+  def initialize(target)
+    @target = target
+    @holder = T_forward_call_param_type_obj_Holder.new("alpha")
+  end
+  def go
+    @target.attach(@holder)
+  end
+end
+
+class T_forward_call_param_type_obj_Target
+  def attach(h)
+    @holder = h
+  end
+  def held_label
+    @holder.label
+  end
+end
+
+t = T_forward_call_param_type_obj_Target.new
+c = T_forward_call_param_type_obj_Caller.new(t)
+c.go
+puts t.held_label
+
+# === gc_save_double_in_new ===
+class T_gc_save_double_in_new_GcSaveDoubleInNew
+  def initialize(path)
+    data = [1, 2, 3]
+    @x = data
+  end
+
+  def step
+    @x.length
+  end
+end
+
+o = T_gc_save_double_in_new_GcSaveDoubleInNew.new("a")
+puts o.step
+
+# === gc_scan_skip_inherited_ivar ===
+# When parent and child both record the same ivar name, the struct
+# field is contributed once by `emit_parent_fields`. `emit_class_struct`
+# already skips child-side redeclaration, so child's own gc_scan walk
+# must also skip the inherited slot — otherwise it emits a second
+# (often miscast) mark on top of the parent walk's correct mark.
+#
+# Here parent's `@data` is widened to poly (heterogeneous writes), and
+# child also writes `@data` from a method-returned poly value, exercising
+# the inherited-slot path under GC pressure.
+
+class T_gc_scan_skip_inherited_ivar_Base
+  def initialize(kind)
+    if kind == 0
+      @data = [1, 2, 3]
+    else
+      @data = "hello"
+    end
+  end
+end
+
+class T_gc_scan_skip_inherited_ivar_Holder
+  def initialize(v)
+    @v = v
+  end
+  attr_reader :v
+end
+
+class T_gc_scan_skip_inherited_ivar_Child < T_gc_scan_skip_inherited_ivar_Base
+  def initialize(h)
+    super(0)
+    @data = h.v
+  end
+end
+
+class T_gc_scan_skip_inherited_ivar_Trash
+  def initialize(n)
+    @n = n
+    @s = "padding payload " * 64
+  end
+end
+
+h_str = T_gc_scan_skip_inherited_ivar_Holder.new("from-holder")
+T_gc_scan_skip_inherited_ivar_Holder.new(123)
+c = T_gc_scan_skip_inherited_ivar_Child.new(h_str)
+
+junk = []
+i = 0
+while i < 5000
+  junk << T_gc_scan_skip_inherited_ivar_Trash.new(i)
+  i = i + 1
+end
+
+puts junk.length
+puts "ok"
+
+# === hash_each_param_narrow ===
+# Issue #408. Regression guard for the hash-each body-walker
+# narrow path (9ca01d7 + analyze-side port in 02003ad).
+#
+# Pre-fix shape: a class method whose only signal on its hash
+# param is `h.each |k, v|` inside the body left `h` typed as
+# poly_poly_hash, made `k` / `v` poly, and the str-concat
+# `\"\\\"\" + k + \"\\\":\"` cascaded into compile errors at the C
+# layer ("passing sp_RbVal to parameter of incompatible type
+# 'const char *'").
+#
+# Post-fix: the body-walker harvests usage signals -- here, k/v
+# both flowing into str-concat -- and narrows the param to
+# str_str_hash (or str_int_hash when v is int-shaped). Both
+# compile clean and produce the expected output.
+#
+# This test re-runs the exact confirmation snippet Ori posted on
+# #408; closing the issue without a regression guard would leave
+# the narrow path exposed to silent regressions on future
+# refactors to the each-body walker.
+
+class T_hash_each_param_narrow_Encoder
+  def self.from_str_hash(h)
+    out = "{"
+    first = true
+    h.each do |k, v|
+      out += "," unless first
+      first = false
+      out += "\"" + k + "\":\"" + v + "\""
+    end
+    out + "}"
+  end
+
+  def self.from_int_hash(h)
+    out = "{"
+    first = true
+    h.each do |k, v|
+      out += "," unless first
+      first = false
+      out += "\"" + k + "\":" + v.to_s
+    end
+    out + "}"
+  end
+end
+
+puts T_hash_each_param_narrow_Encoder.from_str_hash({"name" => "alice", "city" => "NYC"})
+puts T_hash_each_param_narrow_Encoder.from_int_hash({"a" => 1, "b" => 2, "c" => 3})
+
+# === hash_fetch_hash_default ===
+# `Hash#fetch(key, {})` on an int-leaf hash. Sequel to #454 which
+# closed the string-default case via sp_int_to_s conversion. The
+# hash-default case can't unify the two ternary arms to a single
+# primitive: get returns int, default is a hash pointer. Box both
+# arms to sp_RbVal and surface the return type as poly.
+
+class T_hash_fetch_hash_default_P
+  def self.lookup_present(params)
+    params.fetch "x", {}
+  end
+
+  def self.lookup_missing(params)
+    params.fetch "missing", {}
+  end
+end
+
+box = { "x" => 7 }
+v1 = T_hash_fetch_hash_default_P.lookup_present(box)
+v2 = T_hash_fetch_hash_default_P.lookup_missing(box)
+# Hit path returns the int value (boxed)
+puts v1.is_a?(Integer) ? v1 : "non-int"
+# Miss path returns the empty hash (boxed)
+puts v2.is_a?(Hash) ? "hash" : "non-hash"
+

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

@@ -0,0 +1,8 @@
+h:alpha
+3
+5000
+ok
+{"name":"alice","city":"NYC"}
+{"a":1,"b":2,"c":3}
+7
+hash

data/vendor/spinel/test/bundle_class_12.rb

@@ -0,0 +1,234 @@
+# Bundled tests:
+#   - hash_fetch_hash_default_narrowing
+#   - hash_fetch_string_default_on_int_leaf
+#   - heterogeneous_dispatch_int_return_narrow
+#   - if_static_false_skips_dead_branch_compile
+#   - imeth_name_collision_recv_aware
+
+# === hash_fetch_hash_default_narrowing ===
+# Sequel to hash_fetch_hash_default: when `params.fetch "k", {}`
+# is followed by `is_a?(Hash)` narrowing into an if-expression
+# whose else arm returns an empty hash, the receiving local was
+# typed as the concrete hash variant (str_int_hash) by the
+# pass-1 scan_locals (the if-expr's then-arm reads raw_sub but
+# raw_sub is still in the deferred-declaration window), then
+# stuck there because the pass-2 merge had no "concrete → poly"
+# rule. The codegen-emitted assignment then puts an sp_RbVal
+# poly into the typed slot, failing C compile with
+# `incompatible types when assigning to type 'sp_StrIntHash *'
+#  from type 'sp_RbVal'`.
+
+class T_hash_fetch_hash_default_narrowing_ArticleParams
+  def self.from_raw(params)
+    raw_sub = params.fetch "article", {}
+    sub = if raw_sub.is_a?(Hash)
+      raw_sub
+    else
+      {}
+    end
+    sub.is_a?(Hash) ? "got-hash" : "no-hash"
+  end
+end
+
+puts T_hash_fetch_hash_default_narrowing_ArticleParams.from_raw({ "x" => 1 })
+puts T_hash_fetch_hash_default_narrowing_ArticleParams.from_raw({ "y" => 2 })
+
+# === hash_fetch_string_default_on_int_leaf ===
+# #454: `params.fetch "k", ""` on a Hash[String, Int] (or
+# Hash[Symbol, Int]) emitted a type-mismatched ternary
+# (`has_key ? get_int : char_star_default`) and failed C compile
+# under -Werror=int-conversion.
+#
+# Narrow fix: when the default is a string literal and the hash
+# leaf is int, widen the call's static return type to "string"
+# and route the get arm through sp_int_to_s so both arms agree
+# on `const char *`. Limited to (int leaf + string default);
+# broader (poly leaf, hash default, etc.) cascades through the
+# `is_a?(Hash)` narrowing in real-blog params and is left for
+# a follow-up.
+
+class T_hash_fetch_string_default_on_int_leaf_P
+  def self.lookup_str(params)
+    params.fetch "title", ""
+  end
+
+  def self.lookup_sym(params)
+    params.fetch :title, ""
+  end
+end
+
+# Hit path: the integer at the key gets stringified.
+puts T_hash_fetch_string_default_on_int_leaf_P.lookup_str({ "x" => 1, "title" => 42 })
+# Miss path: the empty-string default.
+puts T_hash_fetch_string_default_on_int_leaf_P.lookup_str({ "x" => 1 })
+
+# Sym-keyed counterpart.
+puts T_hash_fetch_string_default_on_int_leaf_P.lookup_sym({ x: 1, title: 99 })
+puts T_hash_fetch_string_default_on_int_leaf_P.lookup_sym({ x: 1 })
+
+# Matched-default control (no fix needed; existing behavior).
+class T_hash_fetch_string_default_on_int_leaf_Q
+  def self.lookup(params)
+    params.fetch "x", 0
+  end
+end
+puts T_hash_fetch_string_default_on_int_leaf_Q.lookup({ "x" => 7 })
+puts T_hash_fetch_string_default_on_int_leaf_Q.lookup({ "other" => 1 })
+
+# === heterogeneous_dispatch_int_return_narrow ===
+# Approach-2 narrowing: when `<poly>[k]` chases an `arr[i]` whose
+# `arr` is a poly_array with observed elements that all return int
+# from `[]` (IntArray + Method-objects), narrow the outer dispatch
+# return type from poly to int. Without narrowing, the outer call
+# returns sp_RbVal and downstream sites — `total + 1`, `~bits`,
+# `iv += 1`, etc. — fail the C compile or cascade widen ivars to
+# poly.
+
+class T_heterogeneous_dispatch_int_return_narrow_Box
+  def initialize
+    @slots = [nil] * 4         # int_array initially
+    @int_arr = [10, 20, 30, 40]
+    @slots[0] = method(:double_at)   # widens via obj_Method_ptr_array
+    @slots[1] = @int_arr             # then widens to poly_array
+    @total = 0
+  end
+
+  def double_at(i)
+    i * 2
+  end
+
+  # Direct ivar access: narrowing fires via `InstanceVariableReadNode`.
+  def via_ivar(i)
+    @slots[i][i]
+  end
+
+  # Local-variable alias: narrowing fires via `LocalVariableReadNode`
+  # with the AST-walking fallback in `find_lv_ivar_alias_in_ast`.
+  def via_local(i)
+    cache = @slots
+    cache[i][i]
+  end
+
+  def run
+    # IntArray arm of @slots[1]: returns @int_arr[1] = 20.
+    @total = via_ivar(1)
+    @total += 1
+    puts @total                # 21
+    # Method arm of @slots[0]: returns double_at(0) = 0.
+    @total = via_local(0)
+    @total += 1
+    puts @total                # 1
+  end
+end
+
+T_heterogeneous_dispatch_int_return_narrow_Box.new.run
+
+# === if_static_false_skips_dead_branch_compile ===
+# `compile_cond_expr` already returns the literal "FALSE" for a
+# predicate whose static type is `nil` (e.g. an attr-style read
+# of an ivar only ever assigned `nil`). The if/unless emit then
+# wraps the dead body in `if (FALSE) { … }`, but the body's C
+# statements still pass through gcc — and they often type-error
+# against ivars/methods whose shapes only make sense when the
+# predicate is true. Skipping body emission lets the rest of
+# the program compile.
+
+class T_if_static_false_skips_dead_branch_compile_Profiler
+  def initialize
+    # `@mode` is statically nil — only ever assigned this literal.
+    # The read in the predicate below folds to `if (FALSE)`.
+    @mode = nil
+  end
+
+  def run
+    # Dead branch when @mode is nil. Pre-fix, spinel emits the
+    # body anyway: `sp_str_sub("...", "MODE", iv_mode)` with
+    # iv_mode typed as `mrb_int` (its only init being `= nil`)
+    # — the 3rd arg fails -Wint-conversion.
+    if @mode
+      out = "label_MODE".sub("MODE", @mode)
+      puts out
+    end
+    puts "ran"
+  end
+end
+
+# `if @nil_ivar; ... else; ... end` with a trailing stmt forces
+# the if into statement position (compile_if_stmt). The else arm
+# is the live one when the predicate is statically nil.
+class T_if_static_false_skips_dead_branch_compile_Either
+  def initialize
+    @verbose = nil
+  end
+
+  def run
+    if @verbose
+      out = "label_MODE".sub("MODE", @verbose)
+      puts out
+    else
+      puts "quiet"
+    end
+    puts "done"
+  end
+end
+
+T_if_static_false_skips_dead_branch_compile_Profiler.new.run
+T_if_static_false_skips_dead_branch_compile_Either.new.run
+
+# === imeth_name_collision_recv_aware ===
+# Issue #429. Two unrelated classes each defining `def get(k)`
+# with different return types caused the analyzer's int-recv
+# cross-class widening to pick the first match -- so a local
+# `r = c.get("/foo")` where c is statically obj_IntClient ended
+# up declared `const char *` (from T_imeth_name_collision_recv_aware_StrBag#get's String return),
+# crashing the C compile when sp_IntClient_get returned an
+# sp_IntBag *.
+#
+# Fix: scan_locals' first pass calls infer_type before the
+# scope decls land, so `c`'s var-type is "" / "int" at that
+# point. infer_recv_method_type's int-recv arm enumerates
+# every user class with `mname` and picks the first non-int
+# return. The fix bails out of that path when (a) the recv is
+# a LocalVariableReadNode whose var-type isn't pinned yet, and
+# (b) the candidate classes disagree on the return type --
+# leaving a later iteration of the iterative loop to pick the
+# right one via the is_obj_type arm once `c`'s declaration
+# has propagated.
+#
+# Coverage: the canonical "two classes, same imeth name,
+# different return types, statically-typed call sites for
+# each" shape from Ori's repro.
+
+class T_imeth_name_collision_recv_aware_StrBag
+  def initialize
+    @h = {"a" => "b"}
+    @h.delete("a")
+    @h["x"] = "got-x"
+  end
+  def get(k)
+    @h[k]
+  end
+end
+
+class T_imeth_name_collision_recv_aware_IntBag
+  attr_accessor :status
+  def initialize
+    @status = 42
+  end
+end
+
+class T_imeth_name_collision_recv_aware_IntClient
+  def get(path)
+    out = T_imeth_name_collision_recv_aware_IntBag.new
+    out.status = path.length
+    out
+  end
+end
+
+s = T_imeth_name_collision_recv_aware_StrBag.new
+puts s.get("x")
+
+c = T_imeth_name_collision_recv_aware_IntClient.new
+r = c.get("/foo")
+puts r.status
+

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

@@ -0,0 +1,15 @@
+got-hash
+got-hash
+42
+
+99
+
+7
+0
+21
+1
+ran
+quiet
+done
+got-x
+4

data/vendor/spinel/test/bundle_class_13.rb

@@ -0,0 +1,61 @@
+# Bundled tests:
+#   - imeth_override_widen_to_poly
+#   - implicit_self_param_poly
+
+# === imeth_override_widen_to_poly ===
+# #567 (Sam Ruby). Sibling of #563. When an override widens a
+# value param to sp_RbVal (poly) because its call sites pass
+# mixed types, but the parent's same param stays scalar, the C
+# function signatures of base and override disagree. The
+# override-dispatch gate cls_imeth_override_ptypes_match
+# rejected the family, so a `self[k] = v` inside a parent body
+# fell through to the static call on the parent's raise stub
+# rather than dispatching to the override.
+#
+# Fix: post-fixpoint, unify the family's ptypes at any slot
+# where at least one member is "poly" so all member signatures
+# agree. The cls_id switch then fires and routes to the
+# concrete override.
+
+class T_imeth_override_widen_to_poly_Base
+  def []=(name, value); raise NotImplementedError; end
+  def fill; self[:title] = "Hello"; end
+end
+
+class T_imeth_override_widen_to_poly_Article < T_imeth_override_widen_to_poly_Base
+  attr_accessor :id, :title
+  def []=(name, value)
+    case name
+    when :id then @id = value
+    when :title then @title = value
+    end
+  end
+end
+
+a = T_imeth_override_widen_to_poly_Article.new
+a.id = 0
+a.title = ""
+a[:id] = 42
+a[:title] = "Other"
+a.fill
+puts a.title.inspect
+
+# === implicit_self_param_poly ===
+class T_implicit_self_param_poly_TokenSink
+  def initialize
+    @value = ""
+  end
+
+  def set_token(value)
+    @value = value.to_s
+  end
+
+  def run
+    set_token(1)
+    set_token("done")
+    puts @value
+  end
+end
+
+T_implicit_self_param_poly_TokenSink.new.run
+

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

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