rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/exception_object_methods.rb

@@ -70,11 +70,12 @@ rescue ArgumentError => e
   puts "msg: #{e.message}"
 end
 
-# .backtrace returns nil (spinel does not track per-exception backtraces).
+# .backtrace returns an empty str_array (#895; spinel does not
+# track per-exception backtraces).
 begin
   raise "trace"
 rescue => e
-  puts "backtrace is nil: #{e.backtrace == nil}"
+  puts "backtrace is empty: #{e.backtrace.empty?}"
 end
 
 # .full_message returns "ClassName: message".

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

@@ -9,7 +9,7 @@ re-raised msg: inner
 compat-msg
 caught propagated: ArgumentError
 msg: propagate
-backtrace is nil: true
+backtrace is empty: true
 full: ArgumentError: fm
 second clause: TypeError multi
 done

data/vendor/spinel/test/exception_super_interpolated_message.rb

@@ -0,0 +1,41 @@
+# A user exception subclass whose #initialize forwards an interpolated
+# string to super must report that interpolated message, with the
+# construction args bound to the initialize params -- not just the
+# first construction arg. Covers both raise E.new(...) and an assigned
+# E.new(...). Regression for #1048.
+class NotFoundError < StandardError
+  def initialize(kind, id)
+    super("not found - kind `#{kind}`, id `#{id}`")
+  end
+end
+
+begin
+  raise NotFoundError.new("company", "123")
+rescue => e
+  puts e.message
+end
+
+err = NotFoundError.new("user", "42")
+puts err.message
+
+# Plain `super(msg)` (no interpolation) must still report the message.
+class Plain < StandardError
+  def initialize(msg)
+    super(msg)
+  end
+end
+begin
+  raise Plain.new("plain message")
+rescue => e
+  puts e.message
+end
+
+# A default-valued param used in the super message resolves to its
+# default when no construction arg is given.
+class Defaulted < StandardError
+  def initialize(detail = "fallback")
+    super("oops: #{detail}")
+  end
+end
+puts Defaulted.new.message
+puts Defaulted.new("custom").message

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

@@ -0,0 +1,5 @@
+not found - kind `company`, id `123`
+not found - kind `user`, id `42`
+plain message
+oops: fallback
+oops: custom

data/vendor/spinel/test/exception_user_subclass.rb

@@ -0,0 +1,35 @@
+# User subclasses of built-in exception classes should also lower
+# to first-class sp_Exception * with cls_name = subclass name.
+class MyError < StandardError
+  def initialize(msg = "default msg")
+    super(msg)
+  end
+end
+
+e = MyError.new("hello")
+puts e.message
+puts e.class
+
+e2 = MyError.new
+puts e2.message
+puts e2.class
+
+# is_a? walks the parent chain.
+puts e.is_a?(MyError)
+puts e.is_a?(StandardError)
+puts e.is_a?(RuntimeError)
+
+# raise + rescue with user subclass
+begin
+  raise MyError, "raised"
+rescue MyError => caught
+  puts "caught: #{caught.message}"
+end
+
+# rescue by parent matches subclass
+begin
+  raise MyError, "via parent"
+rescue StandardError => parent_caught
+  puts "parent caught: #{parent_caught.message}"
+  puts "parent caught cls: #{parent_caught.class}"
+end

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

@@ -0,0 +1,10 @@
+hello
+MyError
+default msg
+MyError
+true
+true
+false
+caught: raised
+parent caught: via parent
+parent caught cls: MyError

data/vendor/spinel/test/extend_module.rb

@@ -0,0 +1,30 @@
+# Issue #721. `class C; extend M; end` should expose M's instance
+# methods as class methods on C. spinel used to silently ignore the
+# extend call; `C.<m>` would fall through to the unresolved-call
+# warning + emit 0.
+
+module M
+  def ext_method; "extended"; end
+  def hello(name); "hi " + name; end
+end
+
+class C
+  extend M
+end
+
+puts C.ext_method
+puts C.hello("world")
+
+# `def self.X` on M stays on M and is NOT pulled into the extending
+# class (CRuby semantics).
+module N
+  def self.solo; "solo-on-N"; end
+  def shared; "shared"; end
+end
+
+class D
+  extend N
+end
+
+puts D.shared
+puts N.solo

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

@@ -0,0 +1,4 @@
+extended
+hi world
+shared
+solo-on-N

data/vendor/spinel/test/ffi_array_specs_decl.rb

@@ -0,0 +1,25 @@
+# #474. New FFI type specs `:float_array` / `:int_array` for
+# zero-copy bulk transfer of Spinel's contiguous Array storage to
+# C functions. Spinel emits `((const double *)(<arg>)->data)` at
+# the call site (`const int64_t *` for :int_array), giving the C
+# side a pointer to the underlying `FloatArray` / `IntArray`
+# `.data`. Lifetime is call-duration only — same contract as
+# `:str`.
+#
+# This test exercises only the analyze + codegen path (the FFI
+# functions are declared but not called); a real-world callable
+# test needs a C-side function with `const double *` /
+# `const int64_t *` signature, which no portable libm/libc symbol
+# matches. The toy_ruby_neural_network project (the issue's
+# motivating use case) drives the runtime side via the new
+# tnn_upload_from_float_array shim.
+
+module BulkF
+  ffi_func :phantom_sum_f64, [:float_array, :size_t], :double
+end
+
+module BulkI
+  ffi_func :phantom_sum_i64, [:int_array, :size_t], :int
+end
+
+puts "ok"

data/vendor/spinel/test/ffi_int_arg_poly_value.rb

@@ -0,0 +1,27 @@
+# Issue #626 sub-issue 1. FFI numeric arg (`:int`, `:uint32`,
+# `:float`, ...) call site receiving an sp_RbVal value previously
+# emitted `(int)(<struct>)` — gcc rejected it with "aggregate
+# value used where an integer was expected". Fix: at the catch-
+# all numeric coercion in compile_ffi_func_call, extract `.v.i`
+# (or `.v.f` for `:float` / `:double`) when the arg's static
+# type is poly. Mirrors the existing :str / :ptr poly handling.
+#
+# The original report involved a cross-class attr_writer widening
+# (`Mat#@nrows` widened to sp_RbVal when a sibling class's
+# poly-recv `obj.nrows = val` site fired); this regression test
+# exercises the same symptom shape through a within-class poly
+# slot created by a mixed-type initializer.
+
+class Sink
+  attr_accessor :n
+  def initialize(flag)
+    @n = flag ? 42 : "fallback"
+  end
+end
+
+module Lib
+  ffi_func :abs, [:int], :int
+end
+
+s = Sink.new(true)
+puts Lib.abs(s.n)

data/vendor/spinel/test/ffi_ptr_array.rb

@@ -0,0 +1,35 @@
+# #492. An array literal whose elements are FFI `:ptr` returns
+# (e.g. `[LibC.malloc(...)]`) used to infer as `int_array`, since
+# `infer_array_elem_type_from_ids` had no `et == "ptr"` arm and
+# fell through to the int_array default. Codegen then emitted
+# `sp_IntArray *` storage and `sp_IntArray_push(arr, void *)`,
+# which fails -Wint-conversion on every push site — the user hit
+# this in a transformer-LM workload with per-head FFI ptr slots.
+#
+# Fix: analyze + codegen recognise `[ptr, ptr, ...]` and lower it
+# to `ptr_ptr_array` (sp_PtrArray with the noscan constructor —
+# external pointers don't carry sp_gc_hdr, so the default
+# sp_gc_mark element scan would crash at collection time).
+#
+# Test asserts the program runs to completion + prints the length.
+# The crucial regression is at codegen — that the generated C now
+# compiles under -Werror=int-conversion. The harness drops cc
+# stderr, so failure surfaces as a missing binary / wrong output
+# rather than a noisy warning.
+
+module LibC
+  ffi_func :malloc, [:size_t], :ptr
+  ffi_func :free,   [:ptr],    :void
+end
+
+class Bag
+  attr_accessor :slots
+  def initialize
+    @slots = [LibC.malloc(8)]
+  end
+end
+
+b = Bag.new
+b.slots.push(LibC.malloc(8))
+puts b.slots.length
+b.slots.each { |p| LibC.free(p) }

data/vendor/spinel/test/ffi_ptr_int_literal.rb

@@ -0,0 +1,31 @@
+# Pass an integer-typed value where a `:ptr` arg is declared. The
+# codegen arm for non-poly `:ptr` (compile_ffi_func_call in
+# spinel_codegen.rb) emits `((void *)<expr>)`, so the integer's bit
+# pattern flows through to C as a pointer value. Real-world use:
+# pass `-1` as the `sqlite3_bind_text` destructor argument to get
+# `SQLITE_TRANSIENT` (`((sqlite3_destructor_type)-1)`), the same
+# wire-shape ruby-ffi exposes via `FFI::Pointer.new(-1)`. The
+# round-trip was verified empirically during development against
+# `sqlite3_bind_text(stmt, 1, "hello", 5, -1)` (insert + select
+# returns "hello", with generated C `sqlite3_bind_text(..., ((void
+# *)-1LL))` matching the SQLITE_TRANSIENT byte pattern); this test
+# guards the codegen primitive that makes it possible.
+#
+# `free(NULL)` is a well-defined POSIX no-op, so we use it as a safe
+# observation point. The interesting bit isn't the runtime behavior
+# (free returns void) but that the call compiles: the analyzer must
+# accept int→:ptr coercion at the call site, and codegen must emit
+# `((void *)0)` — both prerequisites for sentinel-value patterns.
+
+module LibC
+  ffi_func :free, [:ptr], :void
+end
+
+# Integer literal directly as :ptr arg.
+LibC.free(0)
+
+# Int-typed local as :ptr arg.
+n = 0
+LibC.free(n)
+
+puts "ok"

data/vendor/spinel/test/ffi_str_arg_poly_value.rb

@@ -0,0 +1,26 @@
+# #502. FFI `:str` arg call site receiving an sp_RbVal value
+# (e.g. an ivar widened to poly by a ternary) used to emit the
+# raw struct as the call arg and failed C compile with
+# "passing 'sp_RbVal' to parameter of incompatible type
+# 'const char *'". Fix: at the :str / :ptr coercion in
+# compile_ffi_func_call, extract `.v.s` (or `.v.p`) when the
+# arg's static type is poly.
+#
+# Test uses libc's `atoi(const char *)` to exercise the :str
+# coercion through a real, always-available external function;
+# the value (5) doesn't matter — what matters is that the C
+# call site emits cleanly under -Werror.
+
+class Sink
+  attr_accessor :body
+  def initialize(flag)
+    @body = flag ? "42" : 7
+  end
+end
+
+module Lib
+  ffi_func :atoi, [:str], :int
+end
+
+s = Sink.new(true)
+puts Lib.atoi(s.body)

data/vendor/spinel/test/fiber_capture_no_leak_to_sibling.rb

@@ -0,0 +1,27 @@
+# #564 (Ori Pekelman). Fiber.new block bodies that capture a
+# local push a `_hcell_<name>_<n>` entry onto
+# @heap_promoted_names so the capturing function's emit sees
+# `(*_hcell_<name>_<n>)` instead of `lv_<name>`. The list was
+# never reset at method boundaries, so a sibling method
+# defined later in the same compilation unit (e.g. a top-level
+# `def do_work(client)` called from inside the fiber body)
+# also saw `(*_hcell_<name>_<n>)` in its own body emit and
+# the link failed with `'_hcell_<name>_0' undeclared`.
+#
+# Fix: save / restore @heap_promoted_names length around each
+# top-level method body emit so the cells only live in the
+# C scope that actually allocates them.
+
+def spawn_for(client)
+  f = Fiber.new do
+    do_work(client)
+  end
+  f
+end
+
+def do_work(client)
+  puts "client=" + client.to_s
+end
+
+f = spawn_for(42)
+f.resume

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

@@ -0,0 +1 @@
+client=42

data/vendor/spinel/test/fiber_gc_root_isolation.rb

@@ -0,0 +1,76 @@
+# Cooperative fibers each hold their own GC roots. Pre-fix the
+# single shared sp_gc_roots[] / sp_gc_nroots pair meant that a
+# fiber switch via non-LIFO yields / Fiber.transfer let one
+# fiber's pushes clobber another fiber's slots in the global
+# array, so a GC pass triggered from the second fiber could
+# collect the first fiber's live locals.
+#
+# Each fiber's saved root region is now memcpy'd in/out of the
+# global view on every switch, isolating the per-fiber stacks
+# from each other. Issue #636.
+
+class Holder
+  attr_reader :data
+  def initialize(label)
+    @data = "holder_" + label
+  end
+end
+
+# Build a small amount of garbage on every iteration to coax the
+# allocator into running a GC pass while fibers are suspended.
+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
+  # If h1 got collected during f2's churn, this read would
+  # segfault or return garbage.
+  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
+
+# Resume each fiber once — they push their roots and yield.
+f1.resume
+f2.resume
+f3.resume
+
+# Now hammer the allocator. Any of the three fibers' h1/h2/h3
+# locals that were clobbered will surface as stale memory.
+n = 0
+while n < 50
+  churn(20)
+  n += 1
+end
+
+# Resume each fiber — they read their saved local.
+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/file_dir_methods.rb

@@ -0,0 +1,11 @@
+# Issue #892: File.extname / .basename / .dirname / Dir.pwd.
+puts File.extname("hello.rb")
+puts File.basename("/home/user/file.rb")
+puts File.dirname("/home/user/file.rb")
+# Edge cases.
+puts File.extname(".bashrc")       # "" — leading-dot only
+puts File.extname("foo.")          # ""
+puts File.dirname("foo")           # "."
+puts File.dirname("/usr/local")    # "/usr"
+# Dir.pwd returns a string.
+puts Dir.pwd.length > 0

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

@@ -0,0 +1,8 @@
+.rb
+file.rb
+/home/user
+
+.
+.
+/usr
+true

data/vendor/spinel/test/file_expand_path.rb

@@ -0,0 +1,10 @@
+# File.expand_path: pure-string absolute-path expansion. Only absolute
+# bases/paths are exercised so the result is independent of cwd/HOME.
+puts File.expand_path("test", "/tmp")
+puts File.expand_path("/a/b/c")
+puts File.expand_path("../x", "/a/b")
+puts File.expand_path("./y", "/a/b")
+puts File.expand_path("a/../b/./c", "/root")
+puts File.expand_path("", "/tmp")
+puts File.expand_path("/")
+puts File.expand_path("p/q/../../r", "/base")

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

@@ -0,0 +1,8 @@
+/tmp/test
+/a/b/c
+/a/x
+/a/b/y
+/root/b/c
+/tmp
+/
+/base/r

data/vendor/spinel/test/file_mtime.rb

@@ -0,0 +1,10 @@
+filename = "test_mtime_temp.txt"
+File.write(filename, "mtime test")
+begin
+  t = File.mtime(filename)
+  puts t.class
+  # Year should be an integer
+  puts t.year.class
+ensure
+  File.delete(filename)
+end

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

@@ -0,0 +1,2 @@
+Time
+Integer

data/vendor/spinel/test/file_read_count.rb

@@ -0,0 +1,19 @@
+# IO#read(n) reads up to n bytes from the current position, advancing it,
+# and returns nil at EOF. The no-arg form reads the rest of the file.
+path = "file_read_count_tmp.dat"
+File.delete(path) if File.exist?(path)
+
+File.open(path, "w") { |f| f.print "ABCDEFGHIJ" }
+
+f = File.open(path, "r")
+puts f.read(5).inspect
+puts f.read(5).inspect
+puts f.read(5).inspect
+f.close
+
+g = File.open(path, "r")
+puts g.read(3).inspect
+puts g.read.inspect
+g.close
+
+File.delete(path) if File.exist?(path)

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

@@ -0,0 +1,5 @@
+"ABCDE"
+"FGHIJ"
+nil
+"ABC"
+"DEFGHIJ"

data/vendor/spinel/test/file_readlines.rb

@@ -0,0 +1,15 @@
+# File.readlines: read a file back as an array of lines, keeping the
+# "\n" terminator (CRuby default). chomp: true strips it; an encoding:
+# keyword is accepted and ignored. Uses a cwd-relative path because
+# Windows MinGW builds can't fopen /tmp paths.
+path = "file_readlines_tmp.txt"
+File.write(path, "alpha\nbeta\ngamma\n")
+p File.readlines(path)
+p File.readlines(path, chomp: true)
+p File.readlines(path, encoding: 'utf-8')
+
+# A file whose last line has no trailing newline keeps that line bare.
+File.write(path, "x\ny")
+p File.readlines(path)
+
+File.delete(path)

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

@@ -0,0 +1,4 @@
+["alpha\n", "beta\n", "gamma\n"]
+["alpha", "beta", "gamma"]
+["alpha\n", "beta\n", "gamma\n"]
+["x\n", "y"]

data/vendor/spinel/test/file_write_at_tail_position.rb

@@ -0,0 +1,16 @@
+# Followup to #549. File.write recognized at expression level
+# (alongside binwrite). Statement-context calls to File.write
+# were already routed through compile_control_call_stmt and
+# emitted sp_file_write directly. Tail-position calls in a
+# method body fall through to compile_expr, which only
+# recognized binwrite; without the alias here, File.write
+# warned "cannot resolve call to 'write' on int" and returned
+# the literal 0, silently dropping the side effect.
+
+def store(path, data)
+  File.write(path, data)
+end
+
+store("spinel_file_write_test.txt", "ok\n")
+puts File.read("spinel_file_write_test.txt")
+File.delete("spinel_file_write_test.txt")

data/vendor/spinel/test/float_array_first_last_nil.rb

@@ -0,0 +1,20 @@
+# FloatArray#first/#last on an empty array return nil (float? nullable),
+# not 0.0. A non-empty array yields the value as a plain float, and the
+# value flows transparently through arithmetic (the float? rides as a
+# double; base_type strips the `?`).
+a = [1.5, 2.5]
+p a.first
+p a.last
+p a.first.nil?
+
+b = [3.0, 4.0]
+b.pop
+b.pop
+p b.first
+p b.last
+p b.first.nil?
+
+c = [10.5, 4.5]
+p c.last - c.first        # float? - float? -> float
+x = c.last
+p x + 1.0                 # float? flowing into bare-float arithmetic

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

@@ -0,0 +1,8 @@
+1.5
+2.5
+false
+nil
+nil
+true
+-6.0
+5.5

data/vendor/spinel/test/float_divmod_zerodiv.rb

@@ -0,0 +1,57 @@
+# Float#divmod(0) / Float#divmod(0.0) raises ZeroDivisionError.
+#
+# Sibling of Integer#divmod(0) which was fixed in the parent
+# rescue/raise overhaul (test/integer_div_by_zero.rb). Without
+# this guard, `(mrb_int)floor(rc / 0.0)` would consume an
+# Infinity/NaN and produce undefined C behaviour at the cast.
+#
+# Test uses `puts e` directly (which prints the message string in
+# spinel) — exception object methods like .message live on a
+# separate exception-bindings PR.
+
+# Sanity: divmod with non-zero divisor still works.
+q, r = 5.0.divmod(2.0)
+puts q
+puts r
+
+# Float / int divisor
+begin
+  1.0.divmod(0)
+  puts "no raise"
+rescue ZeroDivisionError => e
+  puts "caught int divisor: #{e}"
+end
+
+# Float / float divisor
+begin
+  1.0.divmod(0.0)
+  puts "no raise"
+rescue ZeroDivisionError => e
+  puts "caught float divisor: #{e}"
+end
+
+# Bare rescue catches it.
+begin
+  3.5.divmod(0.0)
+rescue => e
+  puts "bare-rescue: #{e}"
+end
+
+# NaN divisor → FloatDomainError("NaN"). Without this guard the
+# `(mrb_int)floor(1.0 / NaN)` cast on the result would also be
+# C undefined behaviour.
+nan = 0.0 / 0.0
+begin
+  1.0.divmod(nan)
+  puts "no raise nan divisor"
+rescue FloatDomainError => e
+  puts "caught nan divisor: #{e}"
+end
+
+# NaN dividend → FloatDomainError("NaN"). Same UB risk on the cast.
+begin
+  nan.divmod(2.0)
+  puts "no raise nan dividend"
+rescue FloatDomainError => e
+  puts "caught nan dividend: #{e}"
+end

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

@@ -0,0 +1,7 @@
+2
+1.0
+caught int divisor: divided by 0
+caught float divisor: divided by 0
+bare-rescue: divided by 0
+caught nan divisor: NaN
+caught nan dividend: NaN

data/vendor/spinel/test/float_limit_constants.rb

@@ -0,0 +1,14 @@
+# Issue #1253: Float::MAX / MIN / EPSILON compiled to undeclared C
+# identifiers (Float_MAX) instead of the <float.h> DBL_* macros.
+# Issue #1252: Integer has no public constants in CRuby (it is
+# arbitrary precision), so Integer::MAX must raise NameError, not emit
+# a bare Integer_MAX identifier.
+puts Float::MAX
+puts Float::MIN
+puts Float::EPSILON
+puts(Float::MAX > Float::MIN)
+puts((1.0 + Float::EPSILON) > 1.0)
+imax = Integer::MAX rescue "NameError"
+puts imax
+imin = Integer::MIN rescue "NameError"
+puts imin