rubyduino 0.1.1

data/vendor/spinel/test/class_var_read.rb

@@ -0,0 +1,113 @@
+# ClassVariableReadNode -- `@@var`, plus expression-form
+# ClassVariableWriteNode (the `@@x = ...` last-expression-as-return
+# path) and several real-world class-var idioms.
+#
+# Spinel's class vars are independent per declaring class -- the
+# ClassVariableWriteNode commit covers the storage-shape
+# limitation in detail. This test exercises only patterns that
+# stay inside one class's slot (no cross-hierarchy reads).
+
+# 1. Singleton-counter idiom: class-method bumps a shared counter,
+#    instance-method reads it. Both routes touch @@count via the
+#    same @current_class_idx, so they share the cvar_Counter_count
+#    slot.
+class Counter
+  @@count = 0
+
+  def self.tick
+    @@count = @@count + 1   # expression-form ClassVariableWriteNode
+  end
+
+  def self.value
+    @@count                  # plain ClassVariableReadNode
+  end
+
+  def instance_value
+    @@count                  # readable from instance methods too
+  end
+end
+
+puts Counter.value           # 0
+Counter.tick
+Counter.tick
+Counter.tick
+puts Counter.value           # 3
+puts Counter.new.instance_value   # 3 -- instance reads same slot
+
+
+# 2. Per-class isolation: two unrelated classes with the same cvar
+#    name get independent slots. Without the per-class qualification
+#    in cvar_qname, Counter.tick would have changed Other's count
+#    too.
+class Other
+  @@count = 100
+
+  def self.value
+    @@count
+  end
+end
+
+puts Other.value             # 100, unaffected by Counter.tick calls
+
+
+# 3. Cvar with explicit non-zero initial value at class body. Spinel
+#    folds the literal into the static C decl (compile-time), so the
+#    cvar enters the program with the source's value rather than the
+#    type default. Conditional rewrites at class body level (e.g.
+#    `if X; @@y = ...; end`) are NOT supported -- Spinel doesn't run
+#    class-body statements at startup, only constant assignments and
+#    method definitions get hoisted.
+class Config
+  @@debug = true
+  @@max_retries = 5
+
+  def self.debug?; @@debug; end
+  def self.max_retries; @@max_retries; end
+end
+
+puts Config.debug?           # true (folded into static decl)
+puts Config.max_retries      # 5
+
+
+# 4. Cvar updated across many class-method calls -- the cumulative
+#    state lives in the cvar slot, not in any temporary. Chained
+#    `.add(n).add(m)` returning self isn't supported in Spinel
+#    (class methods are static C functions with no self), so we
+#    call separately.
+class Tally
+  @@total = 0
+
+  def self.add(n)
+    @@total = @@total + n
+  end
+
+  def self.total
+    @@total
+  end
+end
+
+Tally.add(10)
+Tally.add(20)
+Tally.add(12)
+puts Tally.total             # 42
+
+
+# 5. Cvar mutation across instance and class methods of the same
+#    class. Real Ruby code mixes these freely (e.g. ActiveRecord
+#    counter caches).
+class Registry
+  @@items = 0
+
+  def self.count
+    @@items
+  end
+
+  def register
+    @@items = @@items + 1
+  end
+end
+
+r = Registry.new
+r.register
+r.register
+puts Registry.count          # 2

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

@@ -0,0 +1,8 @@
+0
+3
+3
+100
+true
+5
+42
+2

data/vendor/spinel/test/class_var_write.rb

@@ -0,0 +1,19 @@
+# ClassVariableWriteNode -- `@@var = value`.
+#
+# Spinel stores cvars as per-(class, name) C globals named
+# `cvar_<ClassName>_<var>`. The static declaration is emitted at
+# file scope alongside constants; ClassVariableReadNode (next
+# commit) consumes the same storage.
+#
+# This commit's test only exercises the write side -- a follow-up
+# Read commit prints @@count to verify round-trip.
+
+class Counter
+  @@count = 0
+end
+
+class Other
+  @@count = 99    # independent slot from Counter's @@count
+end
+
+puts "ok"

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

@@ -0,0 +1 @@
+ok

data/vendor/spinel/test/cls_ivar_type_parent_defer.rb

@@ -0,0 +1,32 @@
+# When the same ivar is registered on both a child class and a
+# parent, the C struct embeds the parent's field at the parent's
+# recorded type (`emit_class_fields` skips own copies that are also
+# in the parent chain). `cls_ivar_type` used to return the child's
+# own-table entry — letting downstream emit sites disagree with
+# the actual struct field type.
+
+class Parent
+  def initialize
+    @x = 0
+    @x = "s"      # heterogeneous int+string → @x widens to poly
+  end
+end
+
+class Child < Parent
+  def initialize
+    super
+    @x = 7        # write through the inherited (poly) slot
+  end
+  def read_x
+    @x
+  end
+end
+
+c = Child.new
+# Reading back via a Child-defined method that emits `self->iv_x`.
+# Without the fix, cls_ivar_type(Child, "@x") returned the int from
+# Child's own table; the struct field is sp_RbVal (Parent's poly);
+# the read miscompiled / yielded a garbage int. With the fix the
+# emit goes through the poly read path and unboxes correctly.
+v = c.read_x
+puts v        # 7

data/vendor/spinel/test/cls_method_object.rb

@@ -0,0 +1,31 @@
+# `Klass.method(:cls_meth)` returns a Method object that wraps a
+# class method (`def self.foo`).  Spinel previously only handled
+# instance-receiver `obj.method(:bar)`, so the class-receiver form
+# fell through to the unresolved-call fallback (emitting `0`) and
+# the captured "Method" was actually an int.  Subsequent
+# `.call(args)` then warned `cannot resolve call to 'call' on int`
+# and returned 0.
+#
+# Repro: capture two class methods on the same class, then call
+# both via `.call`.  The wrapping must:
+#   - infer the result as `obj_Method` (not int),
+#   - mark the underlying cls method as live (so the adapter
+#     trampoline's `sp_<Klass>_cls_<m>` reference resolves at
+#     link time — without the live-mark the body is DCE'd and the
+#     C link fails),
+#   - bind through an adapter that absorbs the dispatch ABI's
+#     `void *self` slot (class methods have no `self *` param).
+
+class CPU
+  def self.poke_nop(addr, data)
+    addr + data
+  end
+  def self.poke_log(addr, data)
+    addr * 2 + data
+  end
+end
+
+m1 = CPU.method(:poke_nop)
+m2 = CPU.method(:poke_log)
+puts m1.call(10, 5)
+puts m2.call(10, 5)

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

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

data/vendor/spinel/test/codegen_class_in_module_with_explicit_parent.rb

@@ -0,0 +1,15 @@
+# Regression for the `String#rindex` nil-guard in
+# `collect_class_with_prefix`. A `class Sub < Parent` written
+# inside a single-level `module M` triggers the parent-resolution
+# walk that strips trailing `_<segment>` from the module prefix.
+# `mp = "M"` has no underscore, so `mp.rindex("_")` returns nil
+# under CRuby (and -1 under spinel). The pre-fix `if idx < 0`
+# crashed on the CRuby path with `NoMethodError: undefined
+# method '<' for nil`.
+
+module M
+  class Sub < Object
+    def hello; puts "hi"; end
+  end
+end
+M::Sub.new.hello

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

@@ -0,0 +1 @@
+hi

data/vendor/spinel/test/codegen_const_lookup_in_toplevel_method.rb

@@ -0,0 +1,13 @@
+# Regression for the `String#index` nil-guard in
+# `current_lexical_scope_name`. A toplevel `def show` body that
+# reads a CONSTANT routes through `resolve_const_read_name`, which
+# calls `current_lexical_scope_name`. Inside that helper,
+# `@current_method_name.index("_cls_")` looks for the class-method
+# name marker — for a toplevel def the marker isn't present, so
+# CRuby's `String#index` returns nil while spinel's runtime
+# returns -1. The pre-fix `if cls_idx >= 0` crashed on the CRuby
+# path with `NoMethodError: undefined method '>=' for nil`.
+
+FOO = 42
+def show; puts FOO; end
+show

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

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

data/vendor/spinel/test/comparable.rb

@@ -0,0 +1,21 @@
+class Temperature
+  attr_reader :degrees
+  def initialize(d)
+    @degrees = d
+  end
+  def <=>(other)
+    @degrees - other.degrees
+  end
+  def <(other); (self <=> other) < 0; end
+  def >(other); (self <=> other) > 0; end
+  def ==(other); (self <=> other) == 0; end
+end
+
+t1 = Temperature.new(100)
+t2 = Temperature.new(200)
+t3 = Temperature.new(100)
+puts t1 < t2    # true
+puts t2 > t1    # true
+puts t1 == t3   # true
+puts t1 > t2    # false
+puts "done"

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

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

data/vendor/spinel/test/const_init_block_param_scan.rb

@@ -0,0 +1,13 @@
+# A constant initializer's RHS can introduce block params (here
+# `n`) whose declarations need to land at main()'s frame. The
+# top-level-stmt scan in `emit_main` previously skipped const-init
+# expressions, so iterations whose body assigns `lv_n` without a
+# preceding `mrb_int lv_n;` (e.g. the `Array#sum { |n| ... }`
+# emit path uses `emit_iter_open`, which does plain `elem_var =
+# idx_var;`) failed C compilation with "undeclared identifier".
+
+TOTAL = [1, 2, 3].sum { |n| n * 2 }
+puts TOTAL                         # 12
+
+DOUBLED = [4, 5, 6].sum { |m| m * 3 }
+puts DOUBLED                       # 45

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

@@ -0,0 +1,2 @@
+12
+45

data/vendor/spinel/test/constant_path.rb

@@ -0,0 +1,102 @@
+# ConstantPath access — covers ARGV (top-level builtin), built-in
+# constructors (::Array.new etc.), nested const reads (A::B::C),
+# class-method dispatch (A::B.create), and the relative-vs-root
+# scope distinction (RootNS::Mid::LEAF vs ::RootNS::Mid::LEAF).
+# Merged from constant_path_{argv,builtin_new,class_method,
+# nested_read,new}.rb. The class-method section's `A::B` (a class)
+# would collide with the nested-read section's `A::B::C` (where
+# A::B is a module), so the class-method section is namespaced as
+# CmA::CmB to keep both shapes co-resident.
+
+# ---- ARGV access via ConstantPath ----
+# Runs at top-level scope so sp_argv is in scope (sp_argv is only
+# declared in main()).
+puts ARGV.length
+puts ::ARGV.length
+puts(ARGV[0] == nil)
+puts(::ARGV[0] == nil)
+
+# ---- Built-in constructors via absolute ConstantPath ----
+require "stringio"
+
+bia = ::Array.new(3, 2)
+puts bia[0] + bia[2]
+
+bih = ::Hash.new
+bih["k"] = bia[1]
+puts bih["k"]
+
+bip = ::Proc.new { |x| x + 1 }
+puts bip.call(5)
+
+bis = ::StringIO.new("ab")
+puts bis.getc
+
+bif = ::Fiber.new { |x|
+  ::Fiber.yield(x + 1)
+  x + 2
+}
+puts bif.resume(4)
+puts bif.resume(4)
+
+bicur = ::Fiber.current
+puts bicur.alive?
+
+# ---- ConstantPath class-method dispatch (A::B.create) ----
+module CmA
+  class CmB
+    def self.create(x)
+      x + 1
+    end
+  end
+end
+puts CmA::CmB.create(41)
+puts ::CmA::CmB.create(99)
+
+# ---- Nested ConstantPath reads (A::B::C, M::C::X) ----
+module A
+  module B
+    C = 7
+  end
+end
+module M
+  class C
+    X = 11
+  end
+end
+puts A::B::C
+puts ::A::B::C
+puts M::C::X
+puts ::M::C::X
+
+# Relative path prefers lexical scope; `::` forces root scope.
+module RootNS
+  module Mid
+    LEAF = 31
+  end
+end
+module Lex
+  module RootNS
+    module Mid
+      LEAF = 47
+    end
+  end
+  def self.pick_relative
+    RootNS::Mid::LEAF
+  end
+  def self.pick_root
+    ::RootNS::Mid::LEAF
+  end
+end
+puts Lex.pick_relative
+puts Lex.pick_root
+
+# ---- Top-level constructor via absolute ConstantPath (::TopC.new) ----
+# Renamed from `class C` to TopC to keep it distinct from M::C above.
+class TopC
+  def initialize
+    puts "init"
+  end
+end
+puts "start"
+::TopC.new

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

@@ -0,0 +1,21 @@
+0
+0
+true
+true
+4
+2
+6
+a
+5
+6
+true
+42
+100
+7
+7
+11
+11
+47
+31
+start
+init

data/vendor/spinel/test/constants.rb

@@ -0,0 +1,44 @@
+# Test module constants and top-level constants
+
+MAX_SIZE = 100
+PI_APPROX = 3
+NAME = "spinel"
+
+module Config
+  VERSION = 42
+  GREETING = "hello"
+  ENABLED = true
+end
+
+puts MAX_SIZE         # 100
+puts PI_APPROX        # 3
+puts NAME             # spinel
+puts Config::VERSION  # 42
+puts Config::GREETING # hello
+puts Config::ENABLED  # true
+
+# Constants in expressions
+puts MAX_SIZE + 1     # 101
+puts NAME.length      # 6
+puts Config::GREETING.upcase  # HELLO
+
+# Lexical constant reads inside module/class initializers
+module LexicalConst
+  A = 10
+  B = A + 1
+
+  class C
+    X = 7
+    Y = X + 2
+  end
+
+  module N
+    P = A + 3
+  end
+end
+
+puts LexicalConst::B     # 11
+puts LexicalConst::C::Y  # 9
+puts LexicalConst::N::P  # 13
+
+puts "done"

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

@@ -0,0 +1,13 @@
+100
+3
+spinel
+42
+hello
+true
+101
+6
+HELLO
+11
+9
+13
+done

data/vendor/spinel/test/control.rb

@@ -0,0 +1,23 @@
+# Test control flow additions
+
+# __LINE__
+puts __LINE__  # 4
+
+# defined? on known variable
+x = 42
+puts defined?(x) ? "yes" : "no"  # yes
+
+# String freeze (no-op in AOT)
+s = "hello"
+puts s  # hello
+
+# Modifier if/unless
+y = 10
+puts "big" if y > 5     # big
+puts "small" unless y > 100  # small
+
+# Ternary chains
+a = 3
+puts(a == 1 ? "one" : a == 2 ? "two" : a == 3 ? "three" : "other")  # three
+
+puts "done"

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

@@ -0,0 +1,7 @@
+4
+yes
+hello
+big
+small
+three
+done

data/vendor/spinel/test/default_args.rb

@@ -0,0 +1,108 @@
+# Issue #49 (default args at call sites) and the scope follow-ups.
+# Merged from default_arg_{ctor,method,inherited,partial,self_call,
+# callee_scope}.rb. Each section covers a distinct dispatch path;
+# the original split had only the dispatch path varying, so the
+# class shapes mostly didn't collide. Where they did (`Foo` was
+# reused in self_call and callee_scope for unrelated purposes) the
+# names are made path-specific (SelfDefault / CalleeFoo).
+
+# ---- Constructor default ----
+# `Counter.new` (no arg) and `Counter.new(7)` both need to compile.
+class Counter
+  def initialize(start = 0)
+    @n = start
+  end
+  attr_reader :n
+end
+puts Counter.new.n         # 0
+puts Counter.new(7).n      # 7
+
+# ---- Instance method default + inherited dispatch ----
+# Same Greeter covers both: direct call and a subclass inheriting
+# the defaulted method without redefining it.
+class Greeter
+  def hello(name = "world")
+    puts "Hello, #{name}"
+  end
+end
+class GreeterChild < Greeter
+end
+Greeter.new.hello                # Hello, world
+Greeter.new.hello("Ruby")        # Hello, Ruby
+GreeterChild.new.hello           # Hello, world
+GreeterChild.new.hello("Ruby")   # Hello, Ruby
+
+# ---- Partial defaulting ----
+# Caller supplies some leading positional args; trailing defaults
+# fill the rest.
+class M
+  def f(a, b = 1, c = 2)
+    puts a + b + c
+  end
+end
+m = M.new
+m.f(10)             # 13
+m.f(10, 20)         # 32
+m.f(10, 20, 30)     # 60
+
+# ---- Implicit-self call inside same class ----
+# Bare-method dispatch from within a class body must also fill in
+# the callee's defaults; previously this path called compile_call
+# _args without the defaults map.
+class SelfDefault
+  def initialize
+    bar
+    bar(99)
+  end
+  def bar(x = 42)
+    puts x
+  end
+end
+SelfDefault.new
+# 42
+# 99
+
+# ---- Default expression reads @ivar ----
+# The inlined default expansion at the caller's site must resolve
+# against the call's *receiver* (here Wrapper#grab's recv `@w`),
+# not the caller's `self`. WrapperCaller has no @base, so a naive
+# inlining would either fail to compile or read the wrong instance.
+class Wrapper
+  def initialize(seed)
+    @base = seed
+  end
+  def grab(target = @base * 10)
+    target
+  end
+end
+class WrapperCaller
+  def initialize
+    @w = Wrapper.new(3)
+  end
+  def go
+    @w.grab
+  end
+end
+puts WrapperCaller.new.go        # 30
+
+# ---- Default expression calls a same-class bare method ----
+# CallerBar defines its own `target` returning 2, but CalleeFoo's
+# default-arg `target` must still dispatch to CalleeFoo#target
+# (returning 1) rather than the caller's vtable.
+class CalleeFoo
+  def target
+    1
+  end
+  def foo(opt = target)
+    opt
+  end
+end
+class CallerBar
+  def target
+    2     # different value — must NOT be picked up by CalleeFoo#foo
+  end
+  def check
+    CalleeFoo.new.foo
+  end
+end
+puts CallerBar.new.check         # 1

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

@@ -0,0 +1,13 @@
+0
+7
+Hello, world
+Hello, Ruby
+Hello, world
+Hello, Ruby
+13
+32
+60
+42
+99
+30
+1

data/vendor/spinel/test/default_argv_narrows_from_string_call_site.rb

@@ -0,0 +1,32 @@
+# `def initialize(conf = ARGV)` typed `conf` as the specialised
+# `argv` scalar (because `infer_type(ARGV) == "argv"`). A caller
+# that passes a single string then unified the call-site `string`
+# against `argv` — the unifier had no argv-vs-string rule, so it
+# dropped to the catch-all poly tail. `conf` widened to poly and
+# `Wrapper.new(conf)` (which expects a String) received a poly arg,
+# miscompiling the inner `@s.length` read.
+#
+# Narrowing argv + string → string biases toward the call-site
+# shape: single-string entry points don't drag the whole signature
+# into poly, while genuinely-array-of-strings call sites still
+# unify on their own type via the existing array-array path.
+
+class Wrapper
+  def initialize(s)
+    @s = s
+  end
+  def show
+    puts @s.length
+  end
+end
+
+class Entry
+  def initialize(conf = ARGV)
+    @conf = Wrapper.new(conf)
+  end
+  def show
+    @conf.show
+  end
+end
+
+Entry.new("hello").show     # 5

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

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