rubyduino 0.1.3 → 0.2.1

data/vendor/spinel/test/module_function_dead_method_dce.rb

@@ -0,0 +1,29 @@
+# A named-module_function method that no in-unit call site reaches
+# (even via a chain of other uncalled module functions) is dead-code-
+# eliminated, so its body — which may use unimplemented dynamic
+# patterns — doesn't break compilation. A *called* module function
+# still works. Regression for #1062.
+module M
+  # uncalled; body builds from a variable-held class (dynamic .new)
+  def fail_with(*args)
+    klass = args.shift
+    e = klass.new(*args)
+    e.set_backtrace([])
+    e
+  end
+  module_function :fail_with
+
+  # uncalled, but calls the above (chain) — both must be dead
+  def boom(*args)
+    fail_with(*args)
+  end
+  module_function :boom
+
+  # CALLED — must stay live and work
+  def greet(name)
+    "hi " + name
+  end
+  module_function :greet
+end
+puts M.greet("world")
+puts(2 + 3)

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

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

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

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

data/vendor/spinel/test/module_function_str_method_param.rb

@@ -0,0 +1,14 @@
+# A module_function-promoted method whose body calls a string method
+# on its param, invoked with a string-literal arg, must route the
+# param to the string path (not the int "0" NoMethodError fallback).
+# Mirrors strings-ansi's Strings::ANSI.sanitize gsub-with-regex-const.
+module Strings
+  module ANSI
+    ANSI_MATCHER = /\e\[[0-9;]*m/
+    def sanitize(string)
+      string.gsub(ANSI_MATCHER, "")
+    end
+    module_function :sanitize
+  end
+end
+puts Strings::ANSI.sanitize("\e[31mRED\e[0m and \e[1mbold\e[0m text")

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

@@ -0,0 +1 @@
+RED and bold text

data/vendor/spinel/test/module_ivar_empty_hash_reset.rb

@@ -0,0 +1,64 @@
+# A module class method that resets a module-level hash ivar back to
+# `{}` used to emit the default `sp_StrIntHash_new()` regardless of
+# the slot's actual variant. When the slot was promoted to e.g.
+# sym_poly_hash by other writes, the reset path mismatched the
+# const's declared type at C compile.
+#
+# Two failures in one shape:
+#   1. Wrong constructor — empty_hash_coerce' s container-typed `_new()`
+#      logic wasn't consulted for module class methods because
+#      @current_class_idx was -1 (modules don't enter the class scope).
+#   2. Wrong LHS — `self->iv_X` for a module class method is dangling
+#      (no self). ivar_lhs already routes `@X` inside `Mod_cls_*` to
+#      `cst_<Mod>_<X>`; the codegen path was hardcoded to
+#      `self->` and bypassed it.
+
+module Counters
+  @counts = {}
+
+  def self.add(name, n)
+    @counts[name] = (@counts[name] || 0) + n
+  end
+
+  def self.fetch(name)
+    @counts[name] || 0
+  end
+
+  def self.reset!
+    @counts = {}
+  end
+end
+
+Counters.add(:apples, 3)
+Counters.add(:oranges, 5)
+puts Counters.fetch(:apples)
+puts Counters.fetch(:oranges)
+Counters.reset!
+puts Counters.fetch(:apples)
+Counters.add(:apples, 7)
+puts Counters.fetch(:apples)
+
+# Array variant — same shape: module-level @list = [] in reset.
+module Events
+  @list = []
+
+  def self.record(s)
+    @list << s
+  end
+
+  def self.first
+    @list[0] || ""
+  end
+
+  def self.reset!
+    @list = []
+  end
+end
+
+Events.record("one")
+Events.record("two")
+puts Events.first
+Events.reset!
+puts Events.first
+Events.record("after_reset")
+puts Events.first

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

@@ -0,0 +1,7 @@
+3
+5
+0
+7
+one
+
+after_reset

data/vendor/spinel/test/module_ivar_nil_poly.rb

@@ -0,0 +1,17 @@
+# A module-level instance variable initialized to nil and later widened
+# to a polymorphic value (it holds nil, an empty [], and a String push)
+# must box the nil initializer as sp_box_nil(), not a bare 0, or the
+# assignment to the sp_RbVal const slot fails to compile.
+module Store
+  @log = nil
+
+  def self.capture
+    prev = @log
+    @log = []
+    @log.push("select 1")
+    @log = prev
+  end
+end
+
+Store.capture
+puts "ok"

data/vendor/spinel/test/module_ivar_op_write.rb

@@ -0,0 +1,53 @@
+# Module-level @ivar referenced inside `def self.X` (the canonical
+# Ruby singleton-state pattern) used to emit as `self->iv_X` in C.
+# The class method has no self parameter -- module class methods
+# dispatch through the module's static table rather than an
+# instance pointer -- so the use site failed to compile.
+#
+# Fix: `ivar_lhs` now detects the "current emit scope is a module
+# class method" case and routes the lhs / rhs to the module's
+# `cst_<Mod>_<name>` static slot. The InstanceVariableReadNode
+# arm already had this dispatch inline; the operator-write / or-
+# write / and-write arms reached `ivar_lhs` and got the wrong
+# `self->iv_X` expansion.
+#
+# Coverage:
+#   - Plain `@count += 1` (InstanceVariableOperatorWriteNode).
+#   - `@count = N` (InstanceVariableWriteNode).
+#   - `@flag ||= true` (InstanceVariableOrWriteNode).
+#   - Read access via `@count` (InstanceVariableReadNode) --
+#     unchanged but exercised by the puts below.
+
+module Counter
+  @count = 0
+  @flag = false
+
+  def self.increment
+    @count += 1
+  end
+
+  def self.reset
+    @count = 0
+  end
+
+  def self.set_flag
+    @flag ||= true
+  end
+
+  def self.value
+    @count
+  end
+
+  def self.flag?
+    @flag
+  end
+end
+
+Counter.increment
+Counter.increment
+Counter.increment
+puts Counter.value
+Counter.set_flag
+puts Counter.flag?
+Counter.reset
+puts Counter.value

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

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

data/vendor/spinel/test/module_reopen_after_include_ivar.rb

@@ -0,0 +1,33 @@
+# #572 follow-up to #573 (Sam Ruby). After 8ca93b4 wired late-
+# reopened module methods into namespaced including classes, the
+# struct-layout side missed: an ivar written by a late-reopened
+# method (`@session ||= ...` in `Dispatch#post`, then included by
+# `NS::IntegrationTest`) wasn't added to the host class's
+# @cls_ivar_names. The C emit referenced `self->iv_session` against
+# a struct that didn't declare the field; C compile failed.
+#
+# Fix: reconcile_class_includes re-runs collect_ivars on any class
+# whose method count grew, so the now-attached method bodies get
+# scanned for InstanceVariable*Write nodes.
+
+module Dispatch
+end
+
+class Base
+end
+
+module NS
+  class IntegrationTest < Base
+    include Dispatch
+  end
+end
+
+module Dispatch
+  def post(path)
+    @session ||= "session-obj"
+    puts @session
+    puts path
+  end
+end
+
+NS::IntegrationTest.new.post("/foo")

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

@@ -0,0 +1,2 @@
+session-obj
+/foo

data/vendor/spinel/test/module_reopen_after_include_namespaced.rb

@@ -0,0 +1,33 @@
+# #573 (Sam Ruby). When a module is forward-declared empty,
+# included by a class nested inside another module, and then
+# reopened with method definitions, the included class's
+# dispatch needs to see the late-defined methods. The bug
+# required the namespaced-class shape: top-level classes
+# resolved the late additions because they're collected in
+# Pass 1 (after Pass 0 has already processed every top-level
+# `module M; ... end` reopen), but nested-in-module classes
+# get collected inside Pass 0's recursion and resolve their
+# `include` against whatever module entries exist at that
+# moment -- which excluded any reopen later in source order.
+#
+# Fix: reconcile_class_includes runs once after Pass 1.6,
+# re-iterating every (class, included-module) pair so reopens
+# registered after the include site finally show up.
+
+class TestBase
+end
+
+module RequestDispatch
+end
+
+module ActionDispatch
+  class IntegrationTest < TestBase
+    include RequestDispatch
+  end
+end
+
+module RequestDispatch
+  def post(path); "post:" + path; end
+end
+
+puts ActionDispatch::IntegrationTest.new.post("/x")

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

@@ -0,0 +1 @@
+post:/x

data/vendor/spinel/test/module_reopen_cmeth_redefine.rb

@@ -0,0 +1,26 @@
+# #517. `module M; def self.X; ...; end; end` re-opened with a
+# second `def self.X` previously emitted two C functions with the
+# same name but possibly-conflicting return types. CRuby's
+# semantics: last definition wins; spinel now replaces the
+# @meth_* row in place when the same `<Mod>_cls_<X>` is seen
+# again (sibling to the class-reopen fix #489).
+
+module M
+  def self.greet
+    "first"
+  end
+end
+
+module M
+  def self.greet
+    "second"
+  end
+  def self.only_in_reopen
+    "extra"
+  end
+end
+
+# Last definition wins.
+puts M.greet
+# Method unique to the reopen is also available.
+puts M.only_in_reopen

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

@@ -0,0 +1,2 @@
+second
+extra

data/vendor/spinel/test/module_singleton_attr_accessor.rb

@@ -0,0 +1,41 @@
+# #511. `module M; class << self; attr_accessor :x; end; end` on a
+# module previously didn't recognize either the reader or writer
+# for non-constant-RHS assignments — the existing constant-fold
+# path (rewrite_module_singleton_accessors) only resolved when
+# every observed write was a ConstantReadNode RHS. Roundhouse hit
+# this with `ActiveRecord.adapter = SqliteAdapter.new` (the RHS
+# is a method call, not a constant).
+#
+# Fix: when the SingletonClassNode + attr_accessor shape is seen,
+# also synthesize a poly-typed file-scope const `<Mod>_<accessor>`.
+# Reads of `Mod.accessor` and writes of `Mod.accessor = v` then
+# fall through to the const slot when the constant-fold path is
+# empty or poisoned. The const initializes to `{SP_TAG_NIL,...}`
+# so an un-assigned read returns nil.
+
+module Cfg
+  class << self
+    attr_accessor :adapter, :timeout
+  end
+end
+
+# String RHS (non-constant): codegen falls through to the poly
+# slot. Reader returns sp_RbVal -> sp_poly_puts.
+Cfg.adapter = "sqlite"
+puts Cfg.adapter
+
+# Int RHS.
+Cfg.timeout = 30
+puts Cfg.timeout
+
+# Re-assign.
+Cfg.adapter = "postgres"
+puts Cfg.adapter
+
+# Pre-assignment read is nil.
+module Empty
+  class << self
+    attr_accessor :slot
+  end
+end
+puts Empty.slot.nil?

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

@@ -0,0 +1,4 @@
+sqlite
+30
+postgres
+true

data/vendor/spinel/test/module_singleton_new_user_method.rb

@@ -0,0 +1,23 @@
+# `module M; def self.new(x); ...; end; end` defines a user-level
+# class method, NOT a constructor (modules can't be instantiated).
+# Pre-fix the call `M.new(args)` hit compile_constructor_expr's
+# user-class arm and emitted `sp_box_obj(<result>, <mod_cls_id>)`,
+# mis-boxing the return as an instance of the module regardless of
+# the user method's declared return type. Sibling methods on the
+# same module (`def self.edit`) emitted correctly via the regular
+# class-method dispatch. Issue #625.
+
+module Views
+  module Articles
+    def self.new(x)
+      "rendered_#{x}"
+    end
+
+    def self.edit(x)
+      "edited_#{x}"
+    end
+  end
+end
+
+puts Views::Articles.new("a")
+puts Views::Articles.edit("b")

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

@@ -0,0 +1,2 @@
+rendered_a
+edited_b

data/vendor/spinel/test/module_singleton_self_accessor.rb

@@ -0,0 +1,31 @@
+# `self.<acc>` / `self.<acc> = v` for a module-level singleton accessor
+# (`class << self; attr_accessor`) must resolve to the same storage that
+# `Mod.<acc>` uses. Before, only an explicit module-name receiver worked;
+# a `self` receiver typed as int and the call fell through to the
+# NoMethodError gate, so the write in a module body was lost (read nil).
+
+# self.x = ... in the module body, runs at definition time
+module M
+  class << self; attr_accessor :x; end
+  self.x = [2, 3]
+end
+p M.x
+
+# self.x= and self.x inside a module class method
+module N
+  class << self; attr_accessor :val; end
+  def self.setup; self.val = 41; end
+  def self.bump; self.val = self.val + 1; end
+end
+N.setup
+N.bump
+p N.val
+
+# Regression: explicit Mod.acc = still works alongside the self form
+module P
+  class << self; attr_accessor :data; end
+  self.data = "in-body"
+end
+p P.data
+P.data = "after"
+p P.data

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

@@ -0,0 +1,4 @@
+[2, 3]
+42
+"in-body"
+"after"

data/vendor/spinel/test/more_truthies_nil_compare.rb

@@ -0,0 +1,31 @@
+# #562 (gurgeous / Adam Doppelt). A corpus of `<container_op>
+# == nil` predicates that CRuby answers as true but spinel
+# previously emitted as false. Root cause: typed-array /
+# typed-hash returns can't represent nil at the value level
+# (sp_IntArray_get returns 0 on out-of-range, sp_StrIntHash_get
+# returns 0 on missing key, etc.), so the existing
+# `int == nil` short-circuit in compile_eq folded the
+# predicate to FALSE.
+#
+# compile_container_op_nil_check recognizes specific call
+# shapes on the lhs of `== nil` and emits a CRuby-equivalent
+# runtime predicate:
+#   arr[i] / arr.delete_at(i) -> (i < 0 || i >= len)
+#   arr.first / arr.last / arr.pop -> (len == 0)
+#   arr.find_index(x) -> !arr.include?(x)
+#   hash[k] -> !hash.has_key?(k)
+#   regex.match(s) -> !regex.match?(s)
+#
+# Plus `Array.new.instance_of?(Array)` folds to TRUE: every
+# Array variant (int_array / str_array / etc.) is
+# conceptually `Array`; same for Hash variants.
+
+p ([1, 2, 3][99] == nil)          # 01
+p Array.new.instance_of?(Array)   # 02
+p ([1, 2].delete_at(3) == nil)    # 03
+p ([].first == nil)               # 04
+p ([].last == nil)                # 05
+p ([].pop == nil)                 # 06
+p ([1, 2].find_index(3) == nil)   # 07
+p ({0 => 0}[5] == nil)            # 08
+p (/xyz/.match("abxyc") == nil)   # 09

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

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

data/vendor/spinel/test/multi_arg_lambda.rb

@@ -0,0 +1,31 @@
+# Issue #400. `->(a, b) { a + b }` and longer-arity lambdas
+# previously emitted broken code: scan_lambda_free_vars saw only
+# reqs[0] as a formal param, so the 2nd+ params were treated as
+# free variables to capture from the surrounding scope. The
+# call site dropped extra args, too.
+#
+# Fix: scan_lambda_free_vars + compile_lambda_expr collect every
+# required param, the lambda fn signature gets one sp_Val* slot
+# per param, and compile_lambda_call_expr dispatches to
+# sp_lam_call2 / _3 / _4 (new runtime helpers that re-cast the
+# stored 1-arg fn ptr to the matching arity at the call site).
+# compile_lambda_body_expr learns `*` / `-` / `/` / `%` / `<>=`
+# arms so multi-arg arithmetic bodies lower correctly.
+
+add = ->(a, b) { a + b }
+puts add.call(3, 4).to_s        # 7
+
+mul3 = ->(a, b, c) { a * b * c }
+puts mul3.call(2, 3, 5).to_s    # 30
+
+quad = ->(a, b, c, d) { a + b + c + d }
+puts quad.call(1, 2, 3, 4).to_s # 10
+
+# 1-arg still works through the unchanged sp_lam_call path.
+double = ->(x) { x * 2 }
+puts double.call(21).to_s       # 42
+
+# Comparison
+gt = ->(a, b) { a > b }
+puts gt.call(5, 3).to_s         # true
+puts gt.call(2, 9).to_s         # false

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

@@ -0,0 +1,6 @@
+7
+30
+10
+42
+true
+false

data/vendor/spinel/test/multi_assign_ivar_type.rb

@@ -0,0 +1,21 @@
+# `@a, @b = x, y` must propagate the param types into the ivars just
+# like separate `@a = x; @b = y` assignments do. Previously the
+# destructuring target wasn't recognized as an assignment, so an
+# attr_reader ivar got widened to poly and a chained <=> mis-dispatched.
+class V
+  include Comparable
+  attr_reader :maj, :min
+  def initialize(maj, min); @maj, @min = maj, min; end
+  def <=>(other)
+    cmp = @maj <=> other.maj
+    if cmp == 0
+      cmp = @min <=> other.min
+    end
+    cmp
+  end
+end
+a = V.new(1, 2)
+b = V.new(1, 10)
+puts "a<b=#{a < b}"
+puts "b<a=#{b < a}"
+puts "eq=#{V.new(3, 4) == V.new(3, 4)}"

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

@@ -0,0 +1,3 @@
+a<b=true
+b<a=false
+eq=true

data/vendor/spinel/test/multi_write_call_rhs_as_expr.rb

@@ -0,0 +1,31 @@
+# #584 (cielavenir). Multi-assignment used as an expression value
+# whose RHS is a call returning a typed array (here `gets.split.
+# map(&:to_i)` → int_array), followed by an outer subscript /
+# comparison. Previously `compile_expr`'s MultiWriteNode arm only
+# handled the ArrayNode-RHS shape (#554) and fell through to
+# `return "0"` for the call-returning-array shape -- the outer
+# `[0]` then lowered to `sp_IntArray_get(0, 0LL)` (NULL recv)
+# and segv'd on the next iteration of any consumer loop.
+
+def two_ints; [10, 20]; end
+def three; [7, 8, 9]; end
+
+# T1: call-returning-array RHS, value-of-expression form
+result = (x, y = two_ints)
+p x
+p y
+p result
+
+# T2: subscript chain on the value
+first = (p1, p2, p3 = three)[0]
+p p1
+p p2
+p p3
+p first
+
+# T3: subscript chain on the value with comparison
+def pair; [3, 4]; end
+flag = (a, b = pair)[0] == 3
+p a
+p b
+p flag

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

@@ -0,0 +1,10 @@
+10
+20
+[10, 20]
+7
+8
+9
+7
+3
+4
+true

data/vendor/spinel/test/multi_write_scalar_rhs.rb

@@ -0,0 +1,12 @@
+# Scalar int RHS to multi-assign: `a, b = 1` previously emitted
+# `sp_IntArray *_t = 1LL;` which failed to compile. CRuby treats
+# the scalar as `[scalar]` so the first slot gets it; the rest are
+# nil in CRuby but land as the typed slot's default (0) here.
+a, b = 1
+puts a
+puts b
+
+e, f, g = 42
+puts e
+puts f
+puts g

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

@@ -0,0 +1,5 @@
+1
+0
+42
+0
+0

data/vendor/spinel/test/mutable_str_alias_uaf.rb

@@ -0,0 +1,62 @@
+# A mutable String (String.new + <<) owns its internal buffer, freed by
+# the object's finalizer. Boxing/coercing/returning that buffer as an
+# immutable string must copy it, not alias it: otherwise a GC that
+# collects the unreferenced builder frees the buffer out from under the
+# still-referenced string (a use-after-free). Each path below captures
+# the converted value, then churns the heap and forces a GC so a freed
+# buffer would be reused before it is read back.
+
+def build_io(n)
+  io = String.new
+  i = 0
+  while i < n
+    io << i.to_s
+    io << ","
+    i += 1
+  end
+  io
+end
+
+def hold(x)                 # poly param: arg is boxed via sp_box_str(->data)
+  GC.start
+  i = 0
+  t = ""
+  while i < 4000
+    t = t + i.to_s
+    i += 1
+  end
+  x
+end
+
+def via_to_s(n)             # mutable.to_s returned across a fn boundary
+  build_io(n).to_s
+end
+
+def via_gsub(n)             # gsub with no match returns the receiver
+  build_io(n).gsub("ZZZ", "x")
+end
+
+hold(42)                    # int call site forces hold's param to poly
+
+a = hold(build_io(6))       # poly-box conversion
+b = via_to_s(6)             # to_s conversion
+c = String(build_io(6))     # Kernel#String conversion
+d = via_gsub(6)             # no-op gsub returning the receiver
+
+i = 0
+t = ""
+while i < 8000
+  t = t + i.to_s
+  i += 1
+end
+GC.start
+i = 0
+while i < 8000
+  t = t + i.to_s
+  i += 1
+end
+
+puts a
+puts b
+puts c
+puts d

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

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