rubyduino 0.1.1

data/vendor/spinel/test/hash_shorthand_str.rb

@@ -0,0 +1,48 @@
+# Hash shorthand with string-valued local variable.
+# Regression: scan_locals's first pass infers the hash literal value type
+# before the local's type lands in @scope_names, so `{first:}` mis-types
+# as int. Pre-fix: declared sp_SymIntHash / sp_SymPolyHash but built with
+# string values -> incompatible-pointer C error or unknown-type error.
+
+# Single string-valued shorthand
+name = "ada"
+who1 = {name:}
+puts who1[:name]
+puts who1.length
+
+# Mixed string-valued shorthand and explicit string pair
+first = "ada"
+who2 = {first:, last: "lovelace"}
+puts who2[:first]
+puts who2[:last]
+puts who2.length
+
+# Compare against the explicit equivalent (both should produce the same output)
+who3 = {first: first, last: "lovelace"}
+puts who3[:first]
+puts who3[:last]
+puts who3.length
+
+# Three string-valued shorthand keys
+a = "alpha"
+b = "beta"
+c = "gamma"
+who4 = {a:, b:, c:}
+puts who4[:a]
+puts who4[:b]
+puts who4[:c]
+puts who4.length
+
+# Mixed shorthand and explicit pairs round-tripping a single value type
+x = "one"
+y = "two"
+who5 = {x:, y:, z: "three"}
+puts who5[:x]
+puts who5[:y]
+puts who5[:z]
+puts who5.length
+
+# Has-key membership over the inferred hash type
+puts who1.has_key?(:name)
+puts who2.has_key?(:first)
+puts who2.has_key?(:missing)

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

@@ -0,0 +1,19 @@
+ada
+1
+ada
+lovelace
+2
+ada
+lovelace
+2
+alpha
+beta
+gamma
+3
+one
+two
+three
+3
+true
+true
+false

data/vendor/spinel/test/heterogeneous_dispatch_int_return_narrow.rb

@@ -0,0 +1,46 @@
+# Approach-2 narrowing: when `<poly>[k]` chases an `arr[i]` whose
+# `arr` is a poly_array with observed elements that all return int
+# from `[]` (IntArray + Method-objects), narrow the outer dispatch
+# return type from poly to int. Without narrowing, the outer call
+# returns sp_RbVal and downstream sites — `total + 1`, `~bits`,
+# `iv += 1`, etc. — fail the C compile or cascade widen ivars to
+# poly.
+
+class Box
+  def initialize
+    @slots = [nil] * 4         # int_array initially
+    @int_arr = [10, 20, 30, 40]
+    @slots[0] = method(:double_at)   # widens via obj_Method_ptr_array
+    @slots[1] = @int_arr             # then widens to poly_array
+    @total = 0
+  end
+
+  def double_at(i)
+    i * 2
+  end
+
+  # Direct ivar access: narrowing fires via `InstanceVariableReadNode`.
+  def via_ivar(i)
+    @slots[i][i]
+  end
+
+  # Local-variable alias: narrowing fires via `LocalVariableReadNode`
+  # with the AST-walking fallback in `find_lv_ivar_alias_in_ast`.
+  def via_local(i)
+    cache = @slots
+    cache[i][i]
+  end
+
+  def run
+    # IntArray arm of @slots[1]: returns @int_arr[1] = 20.
+    @total = via_ivar(1)
+    @total += 1
+    puts @total                # 21
+    # Method arm of @slots[0]: returns double_at(0) = 0.
+    @total = via_local(0)
+    @total += 1
+    puts @total                # 1
+  end
+end
+
+Box.new.run

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

@@ -0,0 +1,2 @@
+21
+1

data/vendor/spinel/test/if_static_false_skips_dead_branch_compile.rb

@@ -0,0 +1,50 @@
+# `compile_cond_expr` already returns the literal "FALSE" for a
+# predicate whose static type is `nil` (e.g. an attr-style read
+# of an ivar only ever assigned `nil`). The if/unless emit then
+# wraps the dead body in `if (FALSE) { … }`, but the body's C
+# statements still pass through gcc — and they often type-error
+# against ivars/methods whose shapes only make sense when the
+# predicate is true. Skipping body emission lets the rest of
+# the program compile.
+
+class Profiler
+  def initialize
+    # `@mode` is statically nil — only ever assigned this literal.
+    # The read in the predicate below folds to `if (FALSE)`.
+    @mode = nil
+  end
+
+  def run
+    # Dead branch when @mode is nil. Pre-fix, spinel emits the
+    # body anyway: `sp_str_sub("...", "MODE", iv_mode)` with
+    # iv_mode typed as `mrb_int` (its only init being `= nil`)
+    # — the 3rd arg fails -Wint-conversion.
+    if @mode
+      out = "label_MODE".sub("MODE", @mode)
+      puts out
+    end
+    puts "ran"
+  end
+end
+
+# `if @nil_ivar; ... else; ... end` with a trailing stmt forces
+# the if into statement position (compile_if_stmt). The else arm
+# is the live one when the predicate is statically nil.
+class Either
+  def initialize
+    @verbose = nil
+  end
+
+  def run
+    if @verbose
+      out = "label_MODE".sub("MODE", @verbose)
+      puts out
+    else
+      puts "quiet"
+    end
+    puts "done"
+  end
+end
+
+Profiler.new.run
+Either.new.run

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

@@ -0,0 +1,3 @@
+ran
+quiet
+done

data/vendor/spinel/test/implicit_self_param_poly.rb

@@ -0,0 +1,17 @@
+class TokenSink
+  def initialize
+    @value = ""
+  end
+
+  def set_token(value)
+    @value = value.to_s
+  end
+
+  def run
+    set_token(1)
+    set_token("done")
+    puts @value
+  end
+end
+
+TokenSink.new.run

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

@@ -0,0 +1 @@
+done

data/vendor/spinel/test/index_write.rb

@@ -0,0 +1,106 @@
+# Indexed-slot compound writes — `a[i] OP= v`, `a[i] &&= v`,
+# `a[i] ||= v`, `a[i], b[j] = ...`. Was four tests; merged here.
+# The op_assign section's `class Vec` is unique; locals reused
+# across the originals (`xs`, `counts`, etc.) get per-section
+# prefixes so the merged script's type inference doesn't unify
+# them or carry hash content across sections.
+
+class Vec
+  attr_accessor :data
+  def initialize(n)
+    @data = Array.new(n, 0.5)
+  end
+end
+
+# === Operator-write (`a[i] OP= v`) ===
+# Float / Int / hash receivers, both directly and through an
+# object field. IndexOperatorWriteNode is distinct from a `.[]=`
+# call; without the dedicated codegen the update is dropped.
+
+vop1 = Vec.new(4)
+vop1.data[0] += 1.5
+vop1.data[1] -= 0.5
+vop1.data[2] *= 4.5
+vop1.data[3] /= 0.5
+puts vop1.data[0]   # 2  (spinel strips ".0")
+puts vop1.data[1]   # 0
+puts vop1.data[2]   # 2.25
+puts vop1.data[3]   # 1
+
+ints_op = Array.new(3, 10)
+ints_op[0] += 5
+ints_op[1] -= 3
+ints_op[2] *= 2
+puts ints_op[0]     # 15
+puts ints_op[1]     # 7
+puts ints_op[2]     # 20
+
+counts_op = {"a" => 1, "b" => 2}
+counts_op["a"] += 10
+counts_op["b"] += 20
+puts counts_op["a"] # 11
+puts counts_op["b"] # 22
+
+# Same pattern through a method call on an object: `obj.attr[i] += x`.
+vop2 = Vec.new(3)
+iop = 0
+while iop < 3
+  vop2.data[iop] += 0.25
+  iop += 1
+end
+puts vop2.data[0]   # 0.75
+puts vop2.data[1]   # 0.75
+puts vop2.data[2]   # 0.75
+
+# === And-write (`a[i] &&= v`) ===
+# Reads a[i]; if truthy, sets a[i] = v. Stick to non-zero values
+# so the C-truthy semantic agrees with Ruby's truthy semantic.
+xs_aw = [1, 2, 3, 4, 5]
+xs_aw[0] &&= 10              # truthy -> fires
+xs_aw[2] &&= 30              # truthy -> fires
+xs_aw[4] &&= xs_aw[4] * 100  # truthy -> fires; recv/idx evaluated once
+puts xs_aw[0]                # 10
+puts xs_aw[1]                # 2
+puts xs_aw[2]                # 30
+puts xs_aw[3]                # 4
+puts xs_aw[4]                # 500
+
+counts_aw = {"alice" => 30, "bob" => 25}
+counts_aw["alice"] &&= 31    # truthy -> fires
+counts_aw["carol"] &&= 50    # unset (returns 0) -> doesn't fire
+puts counts_aw["alice"]      # 31
+puts counts_aw["bob"]        # 25
+puts counts_aw.length        # 2 (carol not added)
+
+# === Or-write (`a[i] ||= v`) ===
+# Reads a[i]; if falsy, sets a[i] = v. Receiver and index are
+# evaluated exactly once even though the source has them on both
+# sides of the implicit `a[i] = a[i] || v`.
+counts_or = {"alice" => 0, "bob" => 5}
+counts_or["carol"] ||= 10    # never set -> fires
+counts_or["bob"]   ||= 99    # 5 truthy -> no-op
+puts counts_or["alice"]      # 0
+puts counts_or["bob"]        # 5
+puts counts_or["carol"]      # 10
+
+# === Target (multi-assign LHS into indexed slots) ===
+# `a[0], b[1] = 1, 2` -- each LHS slot is an IndexTargetNode.
+xs_t = [10, 20, 30]
+ys_t = [100, 200, 300]
+xs_t[0], ys_t[2] = 1, 999
+puts xs_t[0]                 # 1
+puts xs_t[1]                 # 20
+puts ys_t[2]                 # 999
+
+# Same-array two-slot swap.
+zs_t = [1, 2, 3, 4, 5]
+zs_t[0], zs_t[4] = zs_t[4], zs_t[0]
+puts zs_t[0]                 # 5
+puts zs_t[4]                 # 1
+
+# Hash slot mixed with array slot in one multi-assign.
+counts_t = {"a" => 0, "b" => 0}
+arr_t = [0, 0, 0]
+counts_t["a"], arr_t[1] = 42, 99
+puts counts_t["a"]           # 42
+puts arr_t[1]                # 99

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

@@ -0,0 +1,30 @@
+2.0
+0.0
+2.25
+1.0
+15
+7
+20
+11
+22
+0.75
+0.75
+0.75
+10
+2
+30
+4
+500
+31
+25
+2
+0
+5
+10
+1
+20
+999
+5
+1
+42
+99

data/vendor/spinel/test/inference_method_set.rb

@@ -0,0 +1,35 @@
+# Parameter type inference must pick a class whose surface contains
+# ALL methods called on the param, regardless of class definition
+# order. Issue #35: previously the inferer locked in the first class
+# matching ANY single reader, ignoring later accesses, so swapping
+# Block and Cell changed the outcome.
+
+class Block
+  attr_reader :x
+
+  def initialize(x)
+    @x = x
+  end
+end
+
+class Cell
+  attr_reader :x, :block
+
+  def initialize
+    @x = 0
+  end
+
+  def block=(block)
+    @block = block
+  end
+end
+
+def move_to(other)
+  other.block = Block.new(other.x)
+  other
+end
+
+c = Cell.new
+move_to(c)
+puts c.x         # 0
+puts c.block.x   # 0

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

@@ -0,0 +1,2 @@
+0
+0

data/vendor/spinel/test/inherit.rb

@@ -0,0 +1,52 @@
+# Test inheritance and super
+
+class Animal
+  def initialize(name)
+    @name = name
+  end
+
+  def name
+    @name
+  end
+
+  def speak
+    "..."
+  end
+
+  def describe
+    name
+  end
+end
+
+class Dog < Animal
+  def initialize(name, breed)
+    super(name)
+    @breed = breed
+  end
+
+  def breed
+    @breed
+  end
+
+  def speak
+    "Woof!"
+  end
+end
+
+class Cat < Animal
+  def speak
+    "Meow!"
+  end
+end
+
+# Basic inheritance
+dog = Dog.new("Rex", "Labrador")
+puts dog.name       # Rex (inherited)
+puts dog.breed      # Labrador
+puts dog.speak      # Woof! (overridden)
+puts dog.describe   # Rex (inherited, calls name)
+
+cat = Cat.new("Whiskers")
+puts cat.name       # Whiskers (inherited)
+puts cat.speak      # Meow! (overridden)
+puts cat.describe   # Whiskers (inherited)

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

@@ -0,0 +1,7 @@
+Rex
+Labrador
+Woof!
+Rex
+Whiskers
+Meow!
+Whiskers

data/vendor/spinel/test/inherited_method_param_widen.rb

@@ -0,0 +1,49 @@
+# Issue #286: a parent class's instance method param needs to widen
+# from subclass call sites too, not just from same-class call sites.
+# Previously scan_new_calls's bare-call branch only checked
+# `find_method_idx` (top-level methods); a `bar(arg)` inside a
+# subclass that resolves through inheritance to the parent's `bar`
+# would leave the parent's param frozen at its initial type and
+# fail to type-check at the call site.
+#
+# Fix: when the bare call is inside a class method body
+# (@current_class_idx >= 0), walk up the inheritance chain via
+# find_method_owner to locate the ancestor that defines the
+# method, then widen *that* class's @cls_meth_ptypes from the
+# call-site arg types — same shape the recv >= 0 branch already
+# uses for explicit-receiver calls.
+
+class T
+  def assert_eq(expected, actual)
+    if expected == actual
+      puts "ok"
+    else
+      puts "ng"
+    end
+  end
+end
+
+class Article
+  def initialize
+    @id = 0
+  end
+  def write_str(s)
+    @id = s   # widens @id to poly (#247)
+  end
+  def id
+    @id
+  end
+end
+
+class T2 < T
+  def test_it
+    a = Article.new
+    a.write_str("hi")
+    # Bare call to inherited assert_eq, passing a poly value (a.id).
+    # Without the fix, `T#assert_eq`'s `actual` param stays at int
+    # and the call site emits a type-mismatched store.
+    assert_eq("hi", a.id)
+  end
+end
+
+T2.new.test_it

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

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

data/vendor/spinel/test/init_locals.rb

@@ -0,0 +1,43 @@
+# Regression test for issue #17: locals inside `initialize` were not
+# declared in the generated `_new` constructor (and `_initialize`
+# helper for value-type classes), so cc rejected the body with
+# `'lv_x' undeclared`.
+
+class Test
+  attr_reader :a
+  def initialize
+    x = 1
+    @a = x
+  end
+end
+
+class Sum
+  attr_reader :total
+  def initialize(n)
+    s = 0
+    i = 0
+    while i < n
+      s = s + i
+      i = i + 1
+    end
+    @total = s
+  end
+end
+
+class Compound
+  attr_reader :result
+  def initialize(x, y)
+    a = x * 2
+    b = y + 1
+    @result = a + b
+  end
+end
+
+t = Test.new
+puts t.a              # 1
+
+s = Sum.new(5)
+puts s.total          # 10
+
+c = Compound.new(3, 4)
+puts c.result         # 11

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

@@ -0,0 +1,3 @@
+1
+10
+11

data/vendor/spinel/test/initialize_param_poly_call_sites.rb

@@ -0,0 +1,20 @@
+# Regression test: when an `initialize` parameter is widened to "poly"
+# by conflicting Foo.new(...) call sites, the param type must stay poly
+# end-to-end. The extended merge logic explicitly returns existing_pt
+# when it is "poly" so that body inference (which can return a narrower
+# concrete type via super-call propagation or via the @ivar's type when
+# the ivar was seeded by a literal write elsewhere) does not silently
+# narrow the param back.
+
+class Box
+  def initialize(v)
+    @v = v
+  end
+
+  def show
+    puts @v
+  end
+end
+
+Box.new("hello").show
+Box.new(42).show

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

@@ -0,0 +1,2 @@
+hello
+42

data/vendor/spinel/test/initialize_param_through_call.rb

@@ -0,0 +1,15 @@
+# Regression test: an initialize parameter that is never written to an
+# ivar must still pick up its type from `Foo.new(...)` call sites.
+#
+# Before the fix, body inference (which returns "int" when no `@x = x`
+# write is found) unconditionally overwrote the call-site-inferred type,
+# silently miscompiling code where the parameter was a string, array, or
+# any other concrete type.
+
+class Greeter
+  def initialize(name)
+    puts name
+  end
+end
+
+Greeter.new("hello")

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

@@ -0,0 +1 @@
+hello

data/vendor/spinel/test/initialize_void_wrapper_gc_save.rb

@@ -0,0 +1,40 @@
+# Issue #314 follow-up: the synthesized void
+# `sp_<C>_initialize` super-chain wrapper inherits @in_gc_scope
+# from the prior `sp_<C>_new` constructor emit. When that left
+# @in_gc_scope at 1, declare_method_locals' `@in_gc_scope == 0`
+# guard skipped emitting `SP_GC_SAVE()` at the top of the void
+# wrapper. But the body's bare `return` (e.g. `return if x.nil?`)
+# still emitted `SP_GC_RESTORE()` — which references `_gc_saved`
+# that the missing SP_GC_SAVE never declared.
+#
+# Fix: reset @in_gc_scope to 0 when entering the void wrapper so
+# declare_method_locals decides cleanly.
+#
+# The void wrapper is only emitted when a subclass calls `super`,
+# so this reproducer needs the inheritance shape. The body uses
+# a String pointer local (which forces declare_method_locals'
+# has_gc_locals branch to want SP_GC_SAVE) and an early bare
+# `return` (which forces compile_return_stmt to emit
+# SP_GC_RESTORE).
+
+class Base
+  attr_reader :extra
+  def initialize(skip)
+    note = "base"
+    if skip
+      return        # bare `return` — emits SP_GC_RESTORE()
+    end
+    @extra = note
+  end
+end
+
+class Child < Base
+  def initialize
+    super(false)    # calls sp_Base_initialize (the void wrapper)
+  end
+end
+
+# Push into a [Child] array so neither class is value-typed —
+# the void wrapper is only emitted for heap classes.
+all = [Child.new, Child.new]
+puts all.length          # 2

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

@@ -0,0 +1 @@
+2