rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/bundle_class_21.rb

@@ -0,0 +1,208 @@
+# Bundled tests:
+#   - issue219_aref_chain
+#   - issue235_chain_tail_widening
+#   - ivar_and_write_basic
+#   - ivar_c_keyword
+#   - ivar_float_array
+
+# === issue219_aref_chain ===
+# Issue #219: chained calls on a user-defined `[]` operator's
+# result silently lost their coercion (`.to_i` / `.length`) because
+# infer_type's `mname == "[]"` branch handled built-in collection
+# receivers but fell through to "int" for obj receivers.
+# `bag[:id].to_i` then routed through compile_int_method_expr's
+# `to_i` (which is identity) and the underlying `const char *`
+# leaked through.
+
+class T_issue219_aref_chain_Bag
+  def initialize(h); @h = h; end
+  def [](k); @h[k.to_sym]; end
+end
+
+bag = T_issue219_aref_chain_Bag.new({id: "42"})
+
+# .to_i: infers as int via String#to_i
+puts bag[:id].to_i              # 42
+puts bag[:id].to_i + 1          # 43
+
+# .length: routes through String#length
+puts bag[:id].length            # 2
+
+# Chained into a method expecting mrb_int
+class T_issue219_aref_chain_M
+  def self.find(id); id + 1; end
+end
+puts T_issue219_aref_chain_M.find(bag[:id].to_i)      # 43
+
+# Integer-valued bag — .to_s works the other direction (already
+# worked before the fix; pinning regression).
+class T_issue219_aref_chain_IntBag
+  def initialize(h); @h = h; end
+  def [](k); @h[k]; end
+end
+ib = T_issue219_aref_chain_IntBag.new({n: 42})
+puts ib[:n].to_s                # "42"
+
+# === issue235_chain_tail_widening ===
+# Issue #235 follow-up to #234: chained `@a = @b = expr` only widened
+# the chain *head*. The tail (and intermediate participants in
+# longer chains) relied on scan_ivars's dual-definite-literal gate,
+# which fires for literal RHS but not for CallNode/expression RHS.
+# A `@a = @b = make_int` with `@a`/`@b` previously string-typed left
+# `@b`'s slot at `const char *` while compile_chained_ivar_writes
+# emitted `iv_b = _t1;` with `_t1 : mrb_int`. Same T_issue235_chain_tail_widening_C error shape
+# #234 was fixing for the head, just on the tail.
+
+class T_issue235_chain_tail_widening_C
+  def initialize
+    @a = "hello"
+    @b = "world"
+  end
+
+  def make_int
+    42
+  end
+
+  # CallNode RHS — bypasses scan_ivars's literal-gate widening so
+  # the chain-drill path is the only thing that can widen `@b`.
+  def reset_call
+    @a = @b = make_int
+  end
+
+  # 3-chain with CallNode RHS — every intermediate must widen.
+  def reset_three(c)
+    @a = @b = @c = c.length
+  end
+
+  def show
+    puts @a
+    puts @b
+  end
+end
+
+c = T_issue235_chain_tail_widening_C.new
+c.reset_call
+c.show                  # 42 / 42
+
+c2 = T_issue235_chain_tail_widening_C.new
+c2.reset_three("ab")
+c2.show                 # 2 / 2
+
+# 3-chain that adds an `@c` slot to the picture too. After
+# reset_three sets @c, calling show wouldn't read it (no accessor),
+# but the struct emit needs to type-check.
+puts "ok"
+
+# === ivar_and_write_basic ===
+class T_ivar_and_write_basic_T
+  def initialize
+    @ready = false
+    @count = 0
+  end
+
+  def maybe_inc
+    @ready &&= step
+  end
+
+  def arm
+    @ready = true
+  end
+
+  def step
+    @count += 1
+    true
+  end
+
+  def state
+    "ready=#{@ready} count=#{@count}"
+  end
+end
+
+t = T_ivar_and_write_basic_T.new
+puts t.state
+t.maybe_inc
+puts t.state
+t.arm
+puts t.state
+t.maybe_inc
+puts t.state
+t.maybe_inc
+puts t.state
+
+# === ivar_c_keyword ===
+# Test: ivar naming remains safe for C keywords and iv_ prefix collisions.
+
+class T_ivar_c_keyword_KeywordIvar
+  def initialize
+    @if = 40
+    @iv_if = 1
+  end
+
+  def value
+    @if + @iv_if + 1
+  end
+end
+
+puts T_ivar_c_keyword_KeywordIvar.new.value
+
+# === ivar_float_array ===
+# Regression: instance variables initialized via Array.new(n, FILL) must be
+# typed by inspecting the fill argument, not always returned as "int_array".
+#
+# infer_ivar_init_type's CallNode/"new" branch used to unconditionally return
+# "int_array" for Array.new(...). That mistyped class fields as the
+# containing class's pointer; pointer-type fills additionally lost their GC
+# scan function, which would let live elements be swept.
+#
+# We now check the fill type and use the appropriate typed array container
+# (FloatArray for float fills, StrArray for string, sym_array (IntArray
+# internally) for symbol, PtrArray for object/pointer fills).
+#
+# Use float values whose fractional part is non-zero so Spinel's float-puts
+# matches CRuby's.
+
+class T_ivar_float_array_Box
+  attr_accessor :nums
+  def initialize
+    @nums = Array.new(3, 0.5)
+  end
+end
+
+class T_ivar_float_array_SymHolder
+  attr_accessor :tags
+  def initialize
+    @tags = Array.new(2, :alpha)
+  end
+end
+
+class T_ivar_float_array_Marker
+  attr_accessor :id
+  def initialize(id)
+    @id = id
+  end
+end
+
+class T_ivar_float_array_ObjHolder
+  attr_accessor :marks
+  def initialize
+    @marks = Array.new(3, T_ivar_float_array_Marker.new(42))
+  end
+end
+
+b = T_ivar_float_array_Box.new
+puts b.nums[0]      # 0.5
+puts b.nums[1]      # 0.5
+puts b.nums[2]      # 0.5
+puts b.nums.length  # 3
+
+s = T_ivar_float_array_SymHolder.new
+puts s.tags[0]      # alpha
+puts s.tags[1]      # alpha
+puts s.tags.length  # 2
+
+m = T_ivar_float_array_ObjHolder.new
+puts m.marks[0].id  # 42
+puts m.marks[1].id  # 42  (Array.new(n, obj) shares the same obj)
+puts m.marks[2].id  # 42
+puts m.marks.length # 3
+

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

@@ -0,0 +1,27 @@
+42
+43
+2
+43
+42
+42
+42
+2
+2
+ok
+ready=false count=0
+ready=false count=0
+ready=true count=0
+ready=true count=1
+ready=true count=2
+42
+0.5
+0.5
+0.5
+3
+alpha
+alpha
+2
+42
+42
+42
+3

data/vendor/spinel/test/bundle_class_22.rb

@@ -0,0 +1,218 @@
+# Bundled tests:
+#   - ivar_hash_aset_param_widen
+#   - ivar_lazy_init_push_via_getter
+#   - ivar_op_assign_bitwise_and_shift
+#   - ivar_or_write_basic
+#   - ivar_same_shape_string_new_no_widen
+
+# === ivar_hash_aset_param_widen ===
+# #488. A class method writing a param into a typed ivar hash —
+# `@data[key] = value` where @data is pinned to e.g. str_str_hash
+# by another method — left the writer's `key` and `value` params
+# at the `mrb_int` default. The C emit then passed mrb_int into
+# the const char * key / value slots and failed -Wint-conversion.
+# Sibling to #482's nil-default + Hash-receiver back-propagation
+# pass; this one covers the @hash-write side of the same
+# back-propagation gap.
+
+class T_ivar_hash_aset_param_widen_Bag
+  def initialize
+    @data = {}
+  end
+
+  # Pins @data to str_str_hash from a typed source.
+  def populate(source)
+    source.each do |k, v|
+      @data[k] = v
+    end
+  end
+
+  # No caller; without back-propagation `key` and `value` stayed
+  # at mrb_int and the body's sp_StrStrHash_set fired
+  # -Wint-conversion.
+  def []=(key, value)
+    @data[key] = value
+  end
+
+  def fetch(k)
+    @data[k]
+  end
+end
+
+b = T_ivar_hash_aset_param_widen_Bag.new
+b.populate({ "x" => "hello" })
+puts "ok"
+puts b.fetch("x")
+
+# === ivar_lazy_init_push_via_getter ===
+# Issue #430. `@ivar = [] if @ivar.nil?` plus push-through-getter:
+# the ivar stayed inferred as IntArray (from the empty `[]`
+# literal) even when pushes through a getter method handed in
+# string values. sp_IntArray_push then took the string as a
+# mrb_int -- C compile error.
+#
+# Fix: scan_writer_calls now also matches the bare-call shape
+# `<getter>(*args) << v` / `<getter>.push(v)` by resolving
+# through method_returns_ivar_in_class -- if the getter method's
+# body returns a bare `@<iname>` as its last expression, the
+# push observation lands on `@<iname>` directly. The empty-array
+# default promotes the same way it does for direct `@x.push`
+# / `@x << v` writes.
+#
+# Coverage:
+#   - The canonical Rails-style `ActiveRecord::Base#errors`
+#     shape: lazy-init via nil guard, push via a sibling
+#     `add_error` method that calls `errors << "..."`.
+#   - Same shape with `self.<getter>` (explicit self-recv) so
+#     both the bare and self-prefixed call forms route to the
+#     ivar.
+
+class T_ivar_lazy_init_push_via_getter_Errors
+  def list
+    @list = [] if @list.nil?
+    @list
+  end
+
+  def add(msg)
+    list << msg
+  end
+end
+
+class T_ivar_lazy_init_push_via_getter_ErrorsSelf
+  def list
+    @list = [] if @list.nil?
+    @list
+  end
+
+  def add(msg)
+    self.list << msg
+  end
+end
+
+e = T_ivar_lazy_init_push_via_getter_Errors.new
+e.add("a")
+e.add("b")
+puts e.list.length
+puts e.list[0]
+puts e.list[1]
+
+es = T_ivar_lazy_init_push_via_getter_ErrorsSelf.new
+es.add("x")
+puts es.list[0]
+
+# === ivar_op_assign_bitwise_and_shift ===
+# Statement-form `@x OP= v` for the bitwise / shift / multiplicative
+# operators. The pre-fix codegen only handled `+=` and `-=`; every
+# other op-assign was silently dropped, so `@a &= 0x80` left @a
+# untouched. Walks all the operators that map onto T_ivar_op_assign_bitwise_and_shift_C `OP=` directly.
+
+class T_ivar_op_assign_bitwise_and_shift_C
+  attr_reader :a
+  def initialize; @a = 0xff; end
+  def m_amp; @a &= 0x80; end
+  def m_or;  @a |= 0x01; end
+  def m_xor; @a ^= 0xff; end
+  def m_lsh; @a <<= 1; end
+  def m_rsh; @a >>= 1; end
+  def m_mul; @a *= 2; end
+end
+
+c = T_ivar_op_assign_bitwise_and_shift_C.new; c.m_amp; puts "amp: #{c.a}"
+c = T_ivar_op_assign_bitwise_and_shift_C.new; c.m_or;  puts "or: #{c.a}"
+c = T_ivar_op_assign_bitwise_and_shift_C.new; c.m_xor; puts "xor: #{c.a}"
+c = T_ivar_op_assign_bitwise_and_shift_C.new; c.m_lsh; puts "lsh: #{c.a}"
+c = T_ivar_op_assign_bitwise_and_shift_C.new; c.m_rsh; puts "rsh: #{c.a}"
+c = T_ivar_op_assign_bitwise_and_shift_C.new; c.m_mul; puts "mul: #{c.a}"
+
+# === ivar_or_write_basic ===
+class T_ivar_or_write_basic_T
+  def initialize
+    @str = nil
+    @hits = 0
+    @marker = "init"
+  end
+
+  def cache
+    @str ||= compute
+  end
+
+  def compute
+    @hits += 1
+    "hello"
+  end
+
+  def get
+    @str
+  end
+
+  def hits
+    @hits
+  end
+end
+
+t = T_ivar_or_write_basic_T.new
+puts t.get.nil? ? "nil-before" : "not-nil-before"
+puts t.cache
+puts t.get
+puts t.cache
+puts t.get
+puts "hits=#{t.hits}"
+
+class T_ivar_or_write_basic_U
+  def initialize
+    @v = nil
+    @hits = 0
+    @log = []
+  end
+
+  def value
+    @v ||= 42
+  end
+
+  def hits
+    @hits
+  end
+
+  def log_size
+    @log.size
+  end
+end
+
+u = T_ivar_or_write_basic_U.new
+puts u.value
+puts u.value
+puts u.value
+
+# === ivar_same_shape_string_new_no_widen ===
+# Two `String.new` writes to the same ivar should keep the slot at
+# `sp_String *`, not widen to `sp_RbVal`. Pre-fix scan_ivars used
+# `infer_ivar_init_type` which returned `obj_String` for the first
+# write; later writer-scan saw `mutable_str` via `infer_type` for the
+# second; update_ivar_type took the disagreement as a real conflict
+# and widened to poly. Issue #629.
+
+class T_ivar_same_shape_string_new_no_widen_T
+  def initialize
+    @body = String.new
+  end
+
+  def reset
+    @body = String.new
+  end
+
+  def append(s)
+    @body << s
+  end
+
+  def body
+    @body
+  end
+end
+
+t = T_ivar_same_shape_string_new_no_widen_T.new
+t.append("hello")
+puts t.body
+t.reset
+t.append("world")
+puts t.body
+

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

@@ -0,0 +1,23 @@
+ok
+hello
+2
+a
+b
+x
+amp: 128
+or: 255
+xor: 0
+lsh: 510
+rsh: 127
+mul: 510
+nil-before
+hello
+hello
+hello
+hello
+hits=1
+42
+42
+42
+hello
+world

data/vendor/spinel/test/bundle_class_23.rb

@@ -0,0 +1,187 @@
+# Bundled tests:
+#   - ivar_writer_heterogeneity
+#   - kernel_module_function_call
+#   - known_constants
+#   - kwarg_default_empty_hash_kind
+#   - kwargs_into_default_hash_param
+
+# === ivar_writer_heterogeneity ===
+# Issue #247: when two writers in different methods of the same class
+# disagree on the value type, spinel used to narrow the slot to
+# whichever writer's update_ivar_type call ran last — and the loser's
+# emit site silently miscompiled. Here writer 1 in initialize assigns
+# an int (via SymIntHash#[]) and writer 2 in write_any assigns a
+# string param; the slot must widen to poly so both store cleanly.
+
+class T_ivar_writer_heterogeneity_C
+  def initialize(h)
+    @id = h[:id]
+  end
+
+  def id; @id; end
+
+  def write_any(value)
+    @id = value
+  end
+end
+
+c = T_ivar_writer_heterogeneity_C.new({id: 42})
+c.write_any("string")
+puts c.id
+
+# Ensure the int-writer side still works when we don't re-write to a
+# different type — the slot stays as observed.
+class T_ivar_writer_heterogeneity_D
+  def initialize(h)
+    @v = h[:v]
+  end
+  def v; @v; end
+end
+
+d = T_ivar_writer_heterogeneity_D.new({v: 7})
+puts d.v
+
+# === kernel_module_function_call ===
+# Issue #428. `Kernel.<m>` cmeth-style calls (the disambiguator
+# users reach for when a `def self.<m>` shadows a Kernel
+# module-function) emitted `0` instead of dispatching. Bare
+# `<m>(...)` worked but couldn't be used inside a method body
+# that shadowed the name -- which is exactly when callers
+# write `Kernel.<m>`.
+#
+# Fix: in compile_object_method_expr's recv_type == "class"
+# arm, when the recv AST is the ConstantReadNode "Kernel",
+# route through compile_no_recv_call_expr. The bare-dispatch
+# path already handles every Kernel module-function the
+# runtime ships (sleep / puts / print / rand / etc.), so the
+# Kernel-prefixed form gets the same shape uniformly.
+
+class T_kernel_module_function_call_Sched
+  def self.nap(seconds)
+    # Kernel-prefixed to disambiguate from a hypothetical
+    # def self.sleep on the same class.
+    Kernel.sleep(seconds)
+    0
+  end
+end
+
+T_kernel_module_function_call_Sched.nap(0)
+puts "ok"
+
+# === known_constants ===
+# Issue #75: the codegen now rejects an unknown constant reference
+# with a "uninitialized constant <Name>" error instead of either
+# leaking the bare identifier into the C output (`p Foo`) or
+# silently lowering to `0` (`p Foo.bar`). This regression test pins
+# the legitimate constant references that look superficially like
+# the failing cases but resolve to known names — the fix shouldn't
+# reject any of them.
+
+# User-defined class — `find_class_idx` resolves it.
+class T_known_constants_Box
+  def initialize(v); @v = v; end
+  attr_reader :v
+end
+
+puts T_known_constants_Box.new(7).v          # 7
+
+# User-defined constant.
+N = 42
+puts N                     # 42
+
+# Built-in module-like receiver (Math).
+puts Math.sqrt(16).to_i    # 4
+
+# ARGV / STDOUT pass through.
+puts ARGV.length           # 0
+
+# === kwarg_default_empty_hash_kind ===
+# #486. Class method with a kwarg `set_cookies: {}` whose
+# param is body-widened (via other call sites passing a
+# sym-keyed hash) to sp_SymStrHash *. A bare call site that
+# omits the kwarg synthesized the default at the call site as
+# the generic sp_StrIntHash_new(), tripping
+# -Wincompatible-pointer-types because the callee expects
+# sp_SymStrHash *. Fix: the kwarg-default emit at the class-
+# method dispatch site routes through empty_hash_coerce so an
+# empty `{}` literal default takes on the param's declared
+# hash variant.
+
+class T_kwarg_default_empty_hash_kind_W
+  def self.write(io, status, set_cookies: {})
+    n = 0
+    set_cookies.each do |name, val|
+      n = n + 1
+    end
+    n
+  end
+end
+
+class T_kwarg_default_empty_hash_kind_Use
+  def self.kick
+    cookies = { flash_notice: "Hi" }
+    T_kwarg_default_empty_hash_kind_W.write(1, 200, set_cookies: cookies)
+  end
+end
+
+puts T_kwarg_default_empty_hash_kind_W.write(1, 404).to_s
+
+# === kwargs_into_default_hash_param ===
+# When a method's only positional has a default hash literal
+# (`attrs = {}`), call sites that pass kwargs whose names DON'T
+# match the param name should bundle the kwargs into that hash
+# slot. CRuby auto-folds trailing unmatched kwargs into a hash
+# positional; spinel previously dropped them silently because:
+#  - The analyzer fixpoint left the param typed `str_int_hash`
+#    (from the literal `{}` default) and never widened despite
+#    the call site carrying mixed-type values.
+#  - The codegen `compile_typed_call_args` / class-method dispatch
+#    arm filled the unmatched slot with the literal default
+#    (`sp_StrIntHash_new()` / `sp_StrPolyHash_new()`), so the
+#    callee saw an empty hash and constructed all-default values.
+#
+# Surfaced by Sam Ruby's roundhouse `comment_test.rb`
+# `test_belongs_to_article_association` (issue #572 follow-up):
+# `Comment.create(article_id: article.id, ...)` against
+# `def self.create(attrs = {})` had the kwargs dropped, so the
+# created Comment's article_id stayed 0 and the assertion
+# `article.id != comment.article_id` raised.
+
+class T_kwargs_into_default_hash_param_Bag
+  def self.create(attrs = {})
+    new(attrs)
+  end
+  def initialize(attrs = {})
+    @id = attrs[:id] || 0
+    @name = attrs[:name] || "(none)"
+    @count = attrs.length
+  end
+  attr_reader :id, :name, :count
+end
+
+# Class method form: `.create(kw: val, ...)`.
+b1 = T_kwargs_into_default_hash_param_Bag.create(id: 7, name: "alpha")
+puts b1.id     # 7
+puts b1.name   # alpha
+puts b1.count  # 2
+
+# Instance constructor form: `.new(kw: val, ...)` with default
+# hash param. Without the analyzer widening, sp_Bag_new(0)
+# segfaulted on the NULL hash. Issue #530 sibling.
+b2 = T_kwargs_into_default_hash_param_Bag.new(id: 42, name: "beta")
+puts b2.id     # 42
+puts b2.name   # beta
+puts b2.count  # 2
+
+# Empty call: defaults still kick in.
+b3 = T_kwargs_into_default_hash_param_Bag.create
+puts b3.id     # 0
+puts b3.name   # (none)
+puts b3.count  # 0
+
+# Mixed kwarg types -- string + int -- exercise the str_poly_hash
+# poly value path.
+b4 = T_kwargs_into_default_hash_param_Bag.create(id: 99, name: "gamma")
+puts b4.id     # 99
+puts b4.name   # gamma
+

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

@@ -0,0 +1,19 @@
+string
+7
+ok
+7
+42
+4
+0
+0
+7
+alpha
+2
+42
+beta
+2
+0
+(none)
+0
+99
+gamma