rubyduino 0.2.0 → 0.2.1

data/vendor/spinel/test/forward_call_class_method_nested.rb

@@ -1,35 +0,0 @@
-# Nested forward-ref: `Outer.new(Inner.new)` where both Outer and
-# Inner are defined later than the construction site. The Inner.new
-# nested arg type must propagate to Outer.initialize's param so the
-# outer Class.new ptype widens correctly.
-
-class Driver
-  def boot
-    @outer = Outer.new(Inner.new(42))
-  end
-  def reach
-    @outer.payload.value
-  end
-end
-
-class Inner
-  def initialize(v)
-    @v = v
-  end
-  def value
-    @v
-  end
-end
-
-class Outer
-  def initialize(inner)
-    @inner = inner
-  end
-  def payload
-    @inner
-  end
-end
-
-d = Driver.new
-d.boot
-puts d.reach

data/vendor/spinel/test/forward_call_class_method_obj.rb

@@ -1,36 +0,0 @@
-# `Class.new(obj_X)` shape: caller passes a user-class instance to a
-# forward-defined Class.new. Mirrors the optcarrot
-# `PPU.new(@conf, @cpu, @video.palette)` site where the callee's
-# obj-typed param flowed in from a yet-to-be-defined sibling class.
-
-class Holder
-  def initialize(name)
-    @name = name
-  end
-  def label
-    "h:#{@name}"
-  end
-end
-
-class Caller
-  def make
-    @h = Holder.new("alpha")
-    @t = Target.new(@h)
-  end
-  def show
-    @t.held_label
-  end
-end
-
-class Target
-  def initialize(h)
-    @holder = h
-  end
-  def held_label
-    @holder.label
-  end
-end
-
-c = Caller.new
-c.make
-puts c.show

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

@@ -1 +0,0 @@
-h:alpha

data/vendor/spinel/test/forward_call_param_type_int_array.rb

@@ -1,34 +0,0 @@
-# File-order caller-first / callee-second: a Caller class invokes a
-# method on a yet-untyped ivar (because the callee class is defined
-# later in the source). Pre-fix codegen left the callee's params at
-# the default `mrb_int` so the IntArray + bool args produced
-# "incompatible-pointer" / "Wint-conversion" errors when the
-# int→class fallback emitted the call. With the forward-ref widening
-# in place the callee picks up `sp_IntArray *` + `mrb_bool` from
-# this single call site.
-
-class Caller
-  def initialize(target)
-    @target = target
-    @arr = [1, 2, 3]
-    @flag = false
-  end
-  def go
-    @target.set_payload(@arr, @flag)
-  end
-end
-
-class Target
-  def set_payload(arr, flag)
-    @arr = arr
-    @flag = flag
-  end
-  def info
-    "len=#{@arr.length} flag=#{@flag}"
-  end
-end
-
-t = Target.new
-c = Caller.new(t)
-c.go
-puts t.info

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

@@ -1 +0,0 @@
-len=3 flag=false

data/vendor/spinel/test/forward_call_param_type_obj.rb

@@ -1,38 +0,0 @@
-# Forward-call with a user-class-typed arg flowing through the
-# caller's ivar to the callee's parameter slot. Mirrors optcarrot's
-# `@ppu.nametables = @mirroring` shape — the callee accepts an
-# `obj_<UserClass>` and the int→class fallback dispatches via the
-# yet-untyped `@ppu` ivar.
-
-class Holder
-  def initialize(name)
-    @name = name
-  end
-  def label
-    "h:#{@name}"
-  end
-end
-
-class Caller
-  def initialize(target)
-    @target = target
-    @holder = Holder.new("alpha")
-  end
-  def go
-    @target.attach(@holder)
-  end
-end
-
-class Target
-  def attach(h)
-    @holder = h
-  end
-  def held_label
-    @holder.label
-  end
-end
-
-t = Target.new
-c = Caller.new(t)
-c.go
-puts t.held_label

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

@@ -1 +0,0 @@
-h:alpha

data/vendor/spinel/test/gc_save_double_in_new.rb

@@ -1,13 +0,0 @@
-class GcSaveDoubleInNew
-  def initialize(path)
-    data = [1, 2, 3]
-    @x = data
-  end
-
-  def step
-    @x.length
-  end
-end
-
-o = GcSaveDoubleInNew.new("a")
-puts o.step

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

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

data/vendor/spinel/test/gc_scan_skip_inherited_ivar.rb

@@ -1,54 +0,0 @@
-# When parent and child both record the same ivar name, the struct
-# field is contributed once by `emit_parent_fields`. `emit_class_struct`
-# already skips child-side redeclaration, so child's own gc_scan walk
-# must also skip the inherited slot — otherwise it emits a second
-# (often miscast) mark on top of the parent walk's correct mark.
-#
-# Here parent's `@data` is widened to poly (heterogeneous writes), and
-# child also writes `@data` from a method-returned poly value, exercising
-# the inherited-slot path under GC pressure.
-
-class Base
-  def initialize(kind)
-    if kind == 0
-      @data = [1, 2, 3]
-    else
-      @data = "hello"
-    end
-  end
-end
-
-class Holder
-  def initialize(v)
-    @v = v
-  end
-  attr_reader :v
-end
-
-class Child < Base
-  def initialize(h)
-    super(0)
-    @data = h.v
-  end
-end
-
-class Trash
-  def initialize(n)
-    @n = n
-    @s = "padding payload " * 64
-  end
-end
-
-h_str = Holder.new("from-holder")
-Holder.new(123)
-c = Child.new(h_str)
-
-junk = []
-i = 0
-while i < 5000
-  junk << Trash.new(i)
-  i = i + 1
-end
-
-puts junk.length
-puts "ok"

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

@@ -1,2 +0,0 @@
-5000
-ok

data/vendor/spinel/test/heterogeneous_dispatch_int_return_narrow.rb

@@ -1,46 +0,0 @@
-# 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

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

data/vendor/spinel/test/if_static_false_skips_dead_branch_compile.rb

@@ -1,50 +0,0 @@
-# `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

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

data/vendor/spinel/test/implicit_self_param_poly.rb

@@ -1,17 +0,0 @@
-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

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

data/vendor/spinel/test/inherit.rb

@@ -1,52 +0,0 @@
-# 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

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

data/vendor/spinel/test/inherited_method_param_widen.rb

@@ -1,49 +0,0 @@
-# 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/init_locals.rb

@@ -1,43 +0,0 @@
-# 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

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

data/vendor/spinel/test/initialize_param_poly_call_sites.rb

@@ -1,20 +0,0 @@
-# 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

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

data/vendor/spinel/test/initialize_param_through_call.rb

@@ -1,15 +0,0 @@
-# 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_void_wrapper_gc_save.rb

@@ -1,40 +0,0 @@
-# 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/int_array_replace_expr.rb

@@ -1,23 +0,0 @@
-# `Array#replace` in *expression* position on an int_array.
-# The stmt-form arm has long supported this; the expr-form was
-# missing — unresolved-call warning + literal `0` emitted.
-# Surfaced via optcarrot's `def load_battery; ...; @wrk.replace(sav.bytes); end`,
-# where the call sits at the tail of the method (its value is
-# the implicit return).
-
-a = [1, 2, 3]
-b = [10, 20, 30, 40]
-
-# Expression position: assigned. Should yield the (mutated) `a`.
-c = a.replace(b)
-
-# `a` mutated in place
-puts a[0]
-puts a[1]
-puts a[2]
-puts a[3]
-puts a.length
-
-# `c` is the same array (replace returns the receiver)
-puts c[0]
-puts c.length

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

@@ -1,7 +0,0 @@
-10
-20
-30
-40
-4
-10
-4

data/vendor/spinel/test/intarray_slice_assign_from_intarray_ptr_array_first.rb

@@ -1,25 +0,0 @@
-# `arr[start, len] = src` slice-assign where `src` came from
-# `<X>_ptr_array.first` (or `.last`). Spinel's compile_bracket_assign
-# already had a same-prefix slice-assign path for `int_array[i, n] =
-# int_array`, but `infer_type` for `.first` / `.last` fell through
-# to "int" on a `_ptr_array` receiver, so the slice-assign branch's
-# `infer_type(arg_ids[2]) == "int_array"` test missed and the call
-# silently lowered to `arr[start] = len` (using arg_ids[1] as the
-# value, dropping arg_ids[2] entirely).
-
-class C
-  def initialize
-    buf = (0...32).to_a
-    @banks = (0...2).map { buf.slice!(0, 8) }
-    @ref = [0] * 24
-    @ref[5, 8] = @banks.first
-    @ref[15, 8] = @banks.last
-  end
-
-  def show
-    @ref.each { |x| print x, " " }
-    puts
-  end
-end
-
-C.new.show

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

@@ -1 +0,0 @@
-0 0 0 0 0 0 1 2 3 4 5 6 7 0 0 8 9 10 11 12 13 14 15 0 

data/vendor/spinel/test/integer_div.rb

@@ -1,21 +0,0 @@
-# basic
-puts 7.div(2)
-puts 10.div(5)
-
-# exact
-puts 6.div(3)
-
-# negative — floor division rounds toward -infinity
-puts((-7).div(2))
-puts 7.div(-2)
-puts((-7).div(-2))
-
-# zero dividend
-puts 0.div(3)
-
-# one
-puts 1.div(1)
-puts((-1).div(1))
-
-# large
-puts 1000001.div(1000)