rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/obj_class_dispatch.rb

@@ -0,0 +1,69 @@
+# Issue #419. `obj.class` was unresolved on an instance -- emitted
+# `cannot resolve call to 'class' on obj_<C> (emitting 0)` and
+# downstream methods cascaded through int -> 0. Sibling to #404
+# Phase 1 (which closed the literal-reference direction `c = Foo`):
+# this is the reflection direction, fetching the class FROM an
+# instance.
+#
+# Fix:
+#   - Codegen (compile_object_method_expr's is_obj_type arm): when
+#     mname is "class", emit `((sp_Class){<cls_idx>LL})`.
+#   - Codegen (compile_object_method_expr's recv_type=="class"
+#     arm): detect chained `<obj>.class.<cmeth>` via AST shape
+#     (recv is a `class` CallNode whose own recv has a known
+#     obj_<C> type) and dispatch directly to `sp_<C>_cls_<m>`,
+#     bypassing the runtime sp_Class value.
+#   - Inference: infer_method_name_type returns "class" for `obj.class`
+#     and the cmeth's return type for `<obj>.class.<cmeth>`.
+#   - DCE (collect_cls_calls): when the recv is a `class` CallNode,
+#     mark cmeth live on every class that defines one. Over-
+#     approximates because LocalVariableReadNode types aren't
+#     resolvable at DCE time (they're intentionally not cached
+#     by walk_and_cache), but DCE prefers a kept-but-unused
+#     method over a stripped live one.
+#   - String interpolation (`"#{self.class}"`): treat sp_Class
+#     value via sp_class_to_s, not (long long)-cast which is
+#     wrong for a struct.
+#
+# Coverage: chained .class.<cmeth>, plain `obj.class.to_s`
+# (uses the recv_type=="class" -> to_s arm from #404), and the
+# string-interpolation form `"#{self.class}"` that optcarrot's
+# default inspect uses.
+
+class Foo
+  def self.greet
+    "hello-from-foo"
+  end
+end
+
+f = Foo.new
+puts f.class.greet              # hello-from-foo
+puts f.class.to_s               # Foo
+
+class Bar
+  attr_accessor :v
+  def initialize
+    @v = 0
+  end
+  def describe
+    "#<#{ self.class }>"
+  end
+end
+
+b = Bar.new
+puts b.describe                 # #<Bar>
+
+# Subclass: dispatch should pick up the cmeth defined on the
+# inherited class. Spinel's cmeth lookup walks parents via
+# cls_cmethod_owner, mirroring CRuby's dispatch.
+class Base
+  def self.kind
+    "base-kind"
+  end
+end
+
+class Child < Base
+end
+
+c = Child.new
+puts c.class.kind               # base-kind

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

@@ -0,0 +1,4 @@
+hello-from-foo
+Foo
+#<Bar>
+base-kind

data/vendor/spinel/test/object_id_basic.rb

@@ -0,0 +1,19 @@
+# Object#object_id — unique stable id per object value.
+# Int uses the MRI tagged formula (2*n+1), string uses the pointer
+# bit pattern, symbol uses its interned id scaled to avoid collision.
+# The exact numbers aren't part of the contract; spinel just needs
+# values that are stable and unique-ish.
+
+puts 42.object_id == 42.object_id   # true (same value, same id)
+puts 1.object_id != 2.object_id     # true (different value)
+
+s = "hello"
+puts s.object_id == s.object_id     # true (same object)
+
+puts :foo.object_id == :foo.object_id  # true (interned)
+puts :foo.object_id != :bar.object_id  # true (different sym)
+
+# Returns Integer
+puts 42.object_id.class
+puts "x".object_id.class
+puts :s.object_id.class

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

@@ -0,0 +1,8 @@
+true
+true
+true
+true
+true
+Integer
+Integer
+Integer

data/vendor/spinel/test/object_method_gaps_callee_clone_itself.rb

@@ -0,0 +1,23 @@
+# Small built-in method gaps (#1222): __callee__ (resolves like
+# __method__ to the current method name), String#clone (like dup), and
+# NilClass#itself (returns nil).
+
+def who
+  __callee__
+end
+puts who                  # who
+
+def same?
+  __method__ == __callee__
+end
+puts same?                # true
+
+s = "abc".clone
+puts s                    # abc
+puts s.length             # 3
+
+m = String.new("mut").clone
+puts m                    # mut
+
+p nil.itself              # nil
+p nil.itself.nil?         # true

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

@@ -0,0 +1,7 @@
+who
+true
+abc
+3
+mut
+nil
+true

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

@@ -0,0 +1,2 @@
+15
+17

data/vendor/spinel/test/op_method_bitwise.rb

@@ -0,0 +1,30 @@
+# User-defined | & ^ % dispatch to the class method (mangled C name),
+# not a raw C bitwise/modulo op on the struct pointer.
+class Flags
+  def initialize(v)
+    @v = v
+  end
+  def |(o)
+    @v + 100
+  end
+  def &(o)
+    @v + 200
+  end
+  def ^(o)
+    @v + 300
+  end
+  def %(o)
+    @v + 400
+  end
+end
+f = Flags.new(1)
+g = Flags.new(2)
+puts(f | g)
+puts(f & g)
+puts(f ^ g)
+puts(f % g)
+# Builtin int operators still work (regression guard).
+puts(6 | 1)
+puts(6 & 4)
+puts(6 ^ 2)
+puts(7 % 3)

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

@@ -0,0 +1,8 @@
+101
+201
+301
+401
+7
+4
+4
+1

data/vendor/spinel/test/op_method_shift.rb

@@ -0,0 +1,30 @@
+# User-defined << / >> dispatch to the class method, not a raw C shift.
+class Buf
+  def initialize
+    @s = ""
+  end
+  def <<(x)
+    @s = @s + x
+    self
+  end
+  def >>(x)
+    @s = x + @s
+    self
+  end
+  def to_s
+    @s
+  end
+end
+b = Buf.new
+b << "hi"
+b << "!"
+b >> "[" 
+puts b.to_s
+# Builtin << still works (regression guard).
+a = []
+a << 1
+a << 2
+puts a.length
+s = "x"
+s << "y"
+puts s

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

@@ -0,0 +1,3 @@
+[hi!
+2
+xy

data/vendor/spinel/test/open_class_array_builtin.rb

@@ -0,0 +1,11 @@
+# Built-in class reopens should not be collected as user classes.
+# Array uses the boxed open-class receiver path rather than emitting
+# a fake sp_Array struct.
+
+class Array
+  def marker
+    self.class.name
+  end
+end
+
+puts [1, 2].marker

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

@@ -0,0 +1 @@
+Array

data/vendor/spinel/test/open_class_bool_builtin.rb

@@ -0,0 +1,28 @@
+class TrueClass
+  def flag_name
+    "true:" + self.class.name
+  end
+end
+
+class FalseClass
+  def flag_name
+    "false:" + self.class.name
+  end
+end
+
+class Object
+  def object_flag
+    "object:" + self.class.name
+  end
+end
+
+puts true.flag_name
+puts false.flag_name
+
+t = 1 == 1
+f = 1 == 2
+puts t.flag_name
+puts f.flag_name
+
+puts true.object_flag
+puts false.object_flag

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

@@ -0,0 +1,6 @@
+true:TrueClass
+false:FalseClass
+true:TrueClass
+false:FalseClass
+object:TrueClass
+object:FalseClass

data/vendor/spinel/test/open_class_default_arg.rb

@@ -0,0 +1,47 @@
+class String
+  def pad(n = 3)
+    self + ("x" * n)
+  end
+
+  def bang
+    self + "!"
+  end
+end
+
+class Integer
+  def bump(by = 10)
+    self + by
+  end
+end
+
+class TrueClass
+  def truthy(x = 7)
+    x
+  end
+end
+
+module Padder
+  def wrap(s = "*")
+    s + self + s
+  end
+end
+
+class String
+  include Padder
+end
+
+# Optional arg omitted -> default filled in.
+puts "a".pad
+# Optional arg supplied explicitly -> default ignored.
+puts "a".pad(1)
+# Zero-explicit-param reopen still works (no spurious extra arg).
+puts "hi".bang
+# Integer reopen, default omitted and supplied.
+puts 5.bump
+puts 5.bump(2)
+# Bool reopen, default omitted and supplied.
+puts true.truthy
+puts true.truthy(9)
+# Module included into a builtin, default omitted and supplied.
+puts "in".wrap
+puts "in".wrap("-")

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

@@ -0,0 +1,9 @@
+axxx
+ax
+hi!
+15
+7
+7
+9
+*in*
+-in-

data/vendor/spinel/test/open_class_object.rb

@@ -0,0 +1,26 @@
+# Issue #1306: reopening Object must not emit a second Object
+# struct/constructor, and Object methods must dispatch for built-in
+# receivers with the real receiver as `self`.
+
+module ObjectGreeting
+  def hi
+    "hi from " + self.class.name
+  end
+end
+
+class Object
+  include ObjectGreeting
+
+  def global_hi
+    "global " + self.class.name
+  end
+end
+
+class LocalThing
+end
+
+puts "x".hi
+puts "x".global_hi
+puts 1.global_hi
+puts [1, 2].global_hi
+puts LocalThing.new.global_hi

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

@@ -0,0 +1,5 @@
+hi from String
+global String
+global Integer
+global Array
+global LocalThing

data/vendor/spinel/test/pack_utf8.rb

@@ -0,0 +1,12 @@
+# Array#pack("U*") encodes integer codepoints as UTF-8. The runtime
+# `U` directive was missing, so pack returned an empty string.
+p [0x1E0A].pack("U*").bytes       # E1 B8 8A
+p [0x3042].pack("U*").bytes       # E3 81 82  (HIRAGANA A)
+p [104, 105].pack("U*")           # "hi" (ASCII, 1 byte each)
+p [0x1F600].pack("U*").bytes      # F0 9F 98 80 (4-byte emoji)
+p [65, 0x3042, 66].pack("U*").bytes
+p [0x7F].pack("U*").bytes         # boundary: last 1-byte
+p [0x80].pack("U*").bytes         # boundary: first 2-byte
+p [0x800].pack("U*").bytes        # boundary: first 3-byte
+p [].pack("U*")                   # empty array -> ""
+p [97].pack("U")                  # single, no count

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

@@ -0,0 +1,10 @@
+[225, 184, 138]
+[227, 129, 130]
+"hi"
+[240, 159, 152, 128]
+[65, 227, 129, 130, 66]
+[127]
+[194, 128]
+[224, 160, 128]
+""
+"a"

data/vendor/spinel/test/param_body_array_hash_inference.rb

@@ -0,0 +1,58 @@
+# #544 / #545 follow-up to #542. Body-usage param inference
+# extended to two new shapes:
+#
+# A. Array body inference (#545 conservative path):
+#    `param.push(x)` / `.pop` / `.shift` / `.unshift` / `.concat`
+#    / `.compact` / `.flatten` / `.transpose` widens an
+#    int/nil-defaulted param to poly_array. Critically does NOT
+#    fire on `<<`, `&`, `|`, `*`, `+`, `-` (overlap with
+#    Integer bitwise/arithmetic -- optcarrot's poke(data) shape).
+#    Runs ONCE post-fixpoint so call-site inference can pin
+#    narrower variants (int_array / float_array / etc.) first.
+#
+# B. Hash iteration inference (#545 iteration arm, lifted to
+#    #542's pass):
+#    `param.keys` / `.values` / `.each_pair` / `.merge` /
+#    `.has_key?` / `.fetch` / `.store` / `.delete` /
+#    `.transform_values` / `.transform_keys` / `.to_h` widens
+#    to str_poly_hash when no literal-key signal has already
+#    pinned the more-specific variant. These methods don't exist
+#    on Array / String / Integer, so the classifier is
+#    unambiguous.
+#
+# Updated to MRI-compat after #634 shape B landed. The prior
+# fixture seeded the body widening via `b.contents` on an
+# uninitialized `attr_accessor :contents` whose read returned
+# the int placeholder (cast to NULL at the call site, with
+# runtime NULL-guards no-op'ing the body). That setup contradicts
+# MRI -- `nil.push` raises NoMethodError. The body-widening
+# passes themselves still need test coverage; we keep that by
+# seeding from concrete literal arguments instead.
+
+# Array body inference - typed caller via an array literal.
+def consume_arr(arr)
+  arr.push(42)
+  puts "arr.length=" + arr.length.to_s
+end
+
+consume_arr([])
+
+# Hash iteration inference -- .each + .merge / .keys + [k].
+def merge_into_seed(other)
+  result = {a: 1}
+  other.each { |k, v| result[k] = v }
+  result.keys.length
+end
+
+puts merge_into_seed({b: 2, c: 3})
+
+# Hash widening via .keys (no .each, no [k] literal access) --
+# Sam's SqliteAdapter#insert/update shape (`cols = attrs.keys;
+# cols.map { |k| attrs[k] }` -- the [k] uses a computed key,
+# not a literal, so #542's literal-key arm misses but .keys
+# catches the param's Hash shape).
+def hash_keys_count(h)
+  h.keys.length
+end
+
+puts hash_keys_count({a: 1, b: 2})

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

@@ -0,0 +1,3 @@
+arr.length=1
+3
+2

data/vendor/spinel/test/param_body_hash_inference.rb

@@ -0,0 +1,72 @@
+# #542. Method param defaulted to int when no caller passed a
+# concretely-typed argument. The body's `row["id"]` then emitted
+# the literal 0 with a "cannot resolve" warning and the method
+# silently produced wrong output -- `id=0` for the repro,
+# all-default-value Article rows in the roundhouse real-blog.
+# Sam Ruby ran 30 lines of type_seeds.rb to work around this.
+#
+# Fix (Option 2 + cast + NULL-guard, per the issue's design
+# discussion):
+#
+# 1. analyze: new `infer_hash_param_from_body` pass scans each
+#    method body for `param[StringNode/SymbolNode]` access. When
+#    found and the param's slot is still at the int/nil default,
+#    widen to `str_poly_hash` (string keys) or `sym_poly_hash`
+#    (symbol keys). Runs in the inference fixpoint alongside
+#    `infer_string_param_from_body`.
+#
+# 2. codegen: `compile_call_args_with_defaults` adds a hash-typed
+#    param cast arm. When the param's static type is a hash and
+#    the arg's inferred type is int/nil/poly, cast at the call
+#    site so the C signature accepts the call without an
+#    "incompatible integer to pointer conversion" error.
+#
+# 3. runtime: NULL-guards in the hash getters
+#    (`sp_StrPolyHash_get`, `sp_SymPolyHash_get`,
+#    `sp_StrIntHash_get`, `sp_StrStrHash_get`,
+#    `sp_IntStrHash_get`, `sp_SymIntHash_get`,
+#    `sp_SymStrHash_get`, `sp_PolyPolyHash_get`) return the
+#    slot's default sentinel (`sp_box_nil`, `0`, `sp_str_empty`)
+#    instead of dereferencing a NULL hash header.
+#
+# The combination addresses Sam's composition concern: typed
+# callers continue to build the right hash variant; untyped
+# callers cast their nil/int values to NULL of the param's
+# pointer type, the body's `row["k"]` safely returns nil, and
+# the consumer gets `nil.to_s -> ""` (CRuby raises NoMethodError
+# on nil[:k] -- we don't match the raise, but the silent
+# emit-0 is gone).
+
+# Single untyped caller: param widens from body usage alone, no
+# type_seeds.rb seeding required.
+def consume(row)
+  puts "id=" + row["id"].to_s
+end
+
+class Box
+  attr_accessor :contents
+end
+
+b = Box.new
+consume(b.contents)  # untyped (uninit ivar = nil); body inference widens param
+
+# Mixed callers: typed hash literal + untyped value -- previously
+# the typed caller's widening would lock the param at sp_StrPolyHash*
+# and the untyped caller would fail C compile. Now the call-site
+# cast lets the untyped caller through.
+def fetch(row)
+  puts "title=" + row["title"].to_s
+end
+
+fetch({"title" => "Real Hash"})
+fetch(b.contents)
+fetch({"title" => "Another Real"})
+
+# Symbol-keyed lookup widens to sym_poly_hash via the same
+# inference path.
+def grab(opts)
+  puts "name=" + opts[:name].to_s
+end
+
+grab({name: "Sym Hash"})
+grab(b.contents)

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

@@ -0,0 +1,6 @@
+id=
+title=Real Hash
+title=
+title=Another Real
+name=Sym Hash
+name=

data/vendor/spinel/test/param_include_body_widen.rb

@@ -0,0 +1,32 @@
+# #558 (rubys / Sam Ruby). Sibling of #552 for `.include?`,
+# the other "ambiguous receiver" method that exists on
+# String / Array / Hash / Range but NOT on Integer.
+# Pre-fix: `cols.include?(:updated_at)` on an
+# int/nil-defaulted param surfaced as "cannot resolve call to
+# 'include?' on int" and silently returned 0.
+#
+# Post-fix: is_collection_query_method also matches `include?`,
+# so the param widens to flat `poly`. emit_poly_builtin_dispatch
+# emits include? arms across the relevant Array / Hash variants
+# keyed by the arg type (Hash#include? aliases has_key?).
+# SP_TAG_STR include? fires when the arg is a string (substring
+# search per CRuby's String#include? semantics).
+
+def consume(coll)
+  coll.include?(:x)
+end
+
+class Box
+  attr_accessor :v
+end
+
+b = Box.new
+puts consume(b.v)
+b.v = [:y, :x, :z]
+puts consume(b.v)
+b.v = [:a, :b]
+puts consume(b.v)
+b.v = {x: 1, y: 2}
+puts consume(b.v)
+b.v = "abc"
+puts consume(b.v)

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

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

data/vendor/spinel/test/param_lengthlike_body_widen.rb

@@ -0,0 +1,53 @@
+# #552. Body-usage param inference widens int/nil-defaulted
+# params to flat `poly` when the body calls a length-like
+# method (length / size / empty?) on the param. These methods
+# exist on String / Array / Hash but NOT on Integer, so a
+# body proving it calls them on a param establishes the param
+# is one of those container types. Codegen's poly-recv
+# dispatch routes through tag/cls_id arms covering String +
+# every Array variant + every Hash variant.
+#
+# Discriminator: the Hash case (last line, prints 2) failed
+# pre-fix; the warning was silenced for some cases by earlier
+# Option C work but the Hash-variant length dispatch wasn't
+# wired in emit_poly_builtin_dispatch. String and Array
+# variants happen to have worked already; this test still
+# pins them so a future regression in the broader poly-recv
+# length pathway is caught.
+#
+# nil semantics: spinel returns 0 for nil.length (the result
+# temp's default) while CRuby raises NoMethodError. The
+# silent emit-0 isn't fixed here; the test pins the
+# spinel-specific behavior, not CRuby reference output.
+#
+# Conservative classifier: only length / size / empty? widen.
+# These don't exist on Integer so widening to poly is sound.
+# Methods that DO exist on Integer (<<, &, |, +, -, *, [])
+# are deliberately excluded -- a body like
+# `def poke(data); data << 8; end` (optcarrot's PPU) is
+# legitimately Integer arithmetic and would break under a
+# broader widening.
+
+def consume_length(x)
+  x.length
+end
+
+def consume_empty(x)
+  x.empty?
+end
+
+class Box
+  attr_accessor :contents
+end
+
+b = Box.new
+puts consume_length(b.contents)
+b.contents = "hello"
+puts consume_length(b.contents)
+b.contents = [1, 2, 3, 4]
+puts consume_length(b.contents)
+b.contents = { "a" => 1, "b" => 2 }
+puts consume_length(b.contents)
+puts consume_empty(b.contents)
+b.contents = {}
+puts consume_empty(b.contents)

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

@@ -0,0 +1,6 @@
+0
+5
+4
+2
+false
+true

data/vendor/spinel/test/param_ptr_from_callee_slot.rb

@@ -0,0 +1,42 @@
+# A method param passed unmodified to a callee whose corresponding
+# slot is `ptr` / a specific class pointer used to leave the caller's
+# param typed `mrb_int`. The C compile then failed at the call site
+# when the caller passed its mrb_int param into a `void *`-expecting
+# slot.
+#
+# Mirrors the Db.column_bool shape in real-blog: a thin wrapper
+# around a typed primitive (FFI sqlite handle) that didn't have its
+# `stmt` param widened from the body's call to column_int.
+
+module Box
+  def self.read_int(p)
+    p.length
+  end
+
+  def self.read_bool(p)
+    read_int(p) != 0
+  end
+end
+
+puts Box.read_int("abc")
+puts Box.read_bool("abc")
+puts Box.read_bool("")
+
+# Same pattern across two layers — three-deep chain.
+module Chain
+  def self.head(s)
+    middle(s)
+  end
+
+  def self.middle(s)
+    tail(s)
+  end
+
+  def self.tail(s)
+    s.length
+  end
+end
+
+puts Chain.head("abc")
+puts Chain.middle("xyz")
+puts Chain.tail("hi")