rubyduino 0.1.1

data/vendor/spinel/test/no_attr_write_shortcut_multi.rb

@@ -0,0 +1,38 @@
+# `obj.x = v` must dispatch to `def x=(v)` when x= is not a registered
+# attr_writer. A multi-statement body never matched the auto-attr_writer
+# pattern (which requires a single `InstanceVariableWriteNode` body), so
+# the fix at the call site is sufficient on its own to make this case
+# work — no auto-classification change required.
+
+class C
+  attr_accessor :real
+
+  def initialize
+    @real = 0
+    @logged = ""
+  end
+
+  # Multi-statement writer. Side-effects on a *different* ivar so we can
+  # tell whether the def actually ran.
+  def logged=(v)
+    @logged = "set:" + v
+    @real = v.length
+  end
+
+  def get_logged
+    @logged
+  end
+end
+
+c = C.new
+
+# attr_accessor path: still short-circuits to field write.
+c.real = 7
+puts c.real           # 7
+
+# Multi-statement def x=: must dispatch (not bypass).
+c.logged = "hello"
+puts c.get_logged     # set:hello
+puts c.real           # 5  (overwritten by the side effect)
+
+puts "done"

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

@@ -0,0 +1,4 @@
+7
+set:hello
+5
+done

data/vendor/spinel/test/no_keywords_param.rb

@@ -0,0 +1,15 @@
+# NoKeywordsParameterNode — `def f(**nil)` explicit kwarg rejection.
+#
+# In CRuby this declares the method rejects keyword arguments;
+# attempting `f(k: 1)` raises ArgumentError. Spinel's keyword-arg
+# handling is already conservative (only known keys accepted), so
+# the explicit `**nil` marker is effectively a no-op at the codegen
+# level. The parser must still recognize the node so Phase 0's
+# UnsupportedNode loud-error doesn't fire.
+
+def add(a, b, **nil)
+  a + b
+end
+
+puts add(1, 2)     # 3
+puts add(10, 20)   # 30

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

@@ -0,0 +1,2 @@
+3
+30

data/vendor/spinel/test/nullable.rb

@@ -0,0 +1,26 @@
+# Test nullable types (T|nil without full poly overhead)
+def find_name(arr, target)
+  result = nil
+  i = 0
+  while i < arr.length
+    if arr[i] == target
+      result = "found:" + target.to_s
+    end
+    i = i + 1
+  end
+  result
+end
+
+r = find_name([10, 20, 30], 20)
+if r.nil?
+  puts "not found"
+else
+  puts r
+end
+
+r2 = find_name([10, 20, 30], 99)
+if r2.nil?
+  puts "not found"
+else
+  puts r2
+end

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

@@ -0,0 +1,2 @@
+found:20
+not found

data/vendor/spinel/test/obj_array.rb

@@ -0,0 +1,26 @@
+class Point
+  attr_accessor :x
+  attr_accessor :y
+  def initialize(x, y)
+    @tag = "p"
+    @x = x
+    @y = y
+  end
+  def to_s
+    x.to_s + "," + y.to_s
+  end
+end
+
+points = [Point.new(1, 2), Point.new(3, 4), Point.new(5, 6)]
+points.each { |p|
+  puts p.to_s
+}
+puts points.length
+
+# push to obj array
+more = []
+more.push(Point.new(10, 20))
+more.push(Point.new(30, 40))
+more.each { |p|
+  puts p.x + p.y
+}

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

@@ -0,0 +1,6 @@
+1,2
+3,4
+5,6
+3
+30
+70

data/vendor/spinel/test/object_new_sentinel.rb

@@ -0,0 +1,18 @@
+# Issue #63: `Object.new.freeze` constants used as identity sentinels
+# generated `sp_Object *` declarations against a type that didn't exist
+# in the runtime, plus the `freeze` call fell through the dispatcher
+# and the constant was assigned `0` (NULL) instead of the new object.
+# After the fix:
+#   - lib/sp_runtime.h defines sp_Object and sp_Object_new (a fresh
+#     GC-managed allocation per call so `==` is identity)
+#   - codegen emits sp_Object_new() for `Object.new`
+#   - the receiver-passthrough `freeze` arm in compile_object_method_expr
+#     keeps the chain alive so the constant gets the actual pointer.
+
+NO_DIRECT_CALL = Object.new.freeze
+HASH_MISS = Object.new.freeze
+
+# Distinct sentinels: their addresses differ.
+puts NO_DIRECT_CALL == HASH_MISS         # false
+puts NO_DIRECT_CALL == NO_DIRECT_CALL    # true
+puts HASH_MISS == HASH_MISS              # true

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

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

data/vendor/spinel/test/object_truthy.rb

@@ -0,0 +1,31 @@
+# Regression test for issue #20: a value-typed object used directly
+# as a condition must be treated as truthy. C cannot use a struct as
+# a scalar in `if (...)`, so the codegen wraps value-type objects
+# with `((expr), 1)` to evaluate side effects then yield 1.
+
+class Value
+  def initialize(x)
+    @x = x
+  end
+end
+
+# Direct constructor in postfix-if predicate
+puts "1 ok" if Value.new(0)
+
+# Value-typed local in if-statement
+v = Value.new(1)
+puts "2 ok" if v
+
+# Inside a loop
+i = 0
+while i < 1
+  puts "3 ok" if Value.new(0)
+  i += 1
+end
+
+# Ternary if-expression
+puts (Value.new(2) ? "4 yes" : "4 no")
+
+# unless: value-type is always truthy, so the body must be skipped
+puts "5 not run" unless Value.new(3)
+puts "5 done"

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

@@ -0,0 +1,5 @@
+1 ok
+2 ok
+3 ok
+4 yes
+5 done

data/vendor/spinel/test/op_assign_user_operator.rb

@@ -0,0 +1,36 @@
+# `slot OP= rhs` desugars to `slot = slot OP rhs`. When the slot
+# is obj-typed and the class defines OP as a user method, codegen
+# must dispatch through that method. The previous version emitted
+# raw C `slot OP= rhs` for every slot type — on an obj pointer
+# that compiled to pointer arithmetic, silently miscompiling the
+# Ruby semantics.
+
+class Box
+  def initialize(n)
+    @n = n
+    @arr = []
+    @arr << n   # force heap layout (sp_Box *), not value-type
+  end
+  attr_reader :n
+
+  def +(other); Box.new(@n + other); end
+  def -(other); Box.new(@n - other); end
+end
+
+# Instance-variable op-assign in stmt position.
+class IvarStmt
+  def initialize
+    @b = Box.new(10)
+    @b += 5
+  end
+  attr_reader :b
+end
+puts IvarStmt.new.b.n          # 15
+
+# Local-variable op-assign in stmt position.
+def local_stmt
+  b = Box.new(20)
+  b -= 3
+  b.n
+end
+puts local_stmt                # 17

data/vendor/spinel/test/open_class.rb

@@ -0,0 +1,27 @@
+# Test: open class support for built-in types
+# Extension methods on String, Integer, Float
+
+class String
+  def shout
+    upcase + "!"
+  end
+
+  def whisper
+    downcase + "..."
+  end
+end
+
+class Integer
+  def double
+    self * 2
+  end
+
+  def square
+    self * self
+  end
+end
+
+puts "hello".shout
+puts "HELLO WORLD".whisper
+puts 5.double
+puts 7.square

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

@@ -0,0 +1,4 @@
+HELLO!
+hello world...
+10
+49

data/vendor/spinel/test/optional_string_param_method.rb

@@ -0,0 +1,11 @@
+def parse(source, file_path = nil)
+  if file_path
+    puts file_path.length
+  else
+    puts source.length
+  end
+end
+
+parse("abc", "name.rb")
+parse("abc")
+parse("longer", "another_name.rb")

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

@@ -0,0 +1,3 @@
+7
+3
+15

data/vendor/spinel/test/param_inference_if_predicate.rb

@@ -0,0 +1,90 @@
+# Issue #314 (A): `infer_cls_meth_param_from_body`'s walker missed
+# IfNode predicates and else-branches when collecting param method
+# usages, leaving the param at the "int" default and routing
+# `<param>.method(...)` accesses through the int-class fallback —
+# which silently picks the first user class that defines the
+# method and casts the int to that class's struct pointer.
+#
+# Body shape:
+#   def update(p)
+#     if p.title.nil?      # predicate uses p — was invisible
+#       nil
+#     else
+#       self.title = p.title   # else-branch uses p — was invisible
+#     end
+#   end
+#
+# `collect_param_methods` walked @nd_body but not @nd_predicate /
+# @nd_subsequent / @nd_else_clause. With ONLY `p.title` inside an
+# `if/else`, called == [] and the param-from-body inference skipped
+# the method entirely.
+#
+# Fix: extend the walk to predicate, subsequent, else_clause,
+# collection (for-in), block, elements, parts, conditions
+# (case/when). Now `called=["title"]` is collected and
+# `class_has_all_methods` picks a class that defines `title`.
+#
+# Surfaced via Roundhouse's emitted real-blog where `Article#update
+# (p)`'s body has exactly this shape and the resulting `mrb_int lv_p`
+# routed `p.title` and `p.body` to two different user classes
+# (ArticleRow for one, ActionResponse for the other) — same `lv_p`
+# cast to two different struct pointers, structurally invalid C.
+
+class P
+  def title
+    @title
+  end
+  def title=(v)
+    @title = v
+  end
+  def body
+    @body
+  end
+  def body=(v)
+    @body = v
+  end
+end
+
+class App
+  # `p` is used ONLY inside the if-predicate (`p.title.nil?`),
+  # nowhere in the IfNode's body or else-branch. Pre-fix the
+  # collect_param_methods walker missed @nd_predicate /
+  # @nd_subsequent / @nd_else_clause, so called == [] and the
+  # param-from-body inference left `p` at "int". The
+  # int-class fallback then routed `p.title` through
+  # `((sp_<first-class-with-title> *)lv_p)->iv_title` — picking
+  # whichever user class happened to be declared first that has
+  # a `title` method. In Roundhouse that's a wildly different
+  # struct than the actual `ArticleParams` the call site passes.
+  def status(p)
+    if p.title.nil?
+      "no-title"
+    else
+      "has-title"
+    end
+  end
+end
+
+# IMPORTANT: don't call `App#status` directly — the call-site
+# widening pass would pin `p` to obj_P and mask the body-walker
+# bug. The test verifies that body-walker-derived inference fires
+# even without a call site, by ensuring the C compiles cleanly
+# despite multiple user classes (P, Other) that define `title`.
+
+class Other
+  def title; "wrong"; end
+end
+
+# Pin both classes' instances at the top level so they appear in
+# the symbol table.
+o = Other.new
+puts o.title             # wrong
+
+q = P.new
+q.title = "hello"
+puts q.title             # hello
+
+# `App#status` is defined but never called — purely body-walker
+# determines `p`'s type. Pre-fix: left at "int", emitted broken C
+# routing through whichever class came first.
+puts "compiled-cleanly"

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

@@ -0,0 +1,3 @@
+wrong
+hello
+compiled-cleanly

data/vendor/spinel/test/param_narrow_from_body_call.rb

@@ -0,0 +1,34 @@
+# Stage 1 of body-side type narrowing (B' direction): if a method's
+# parameter is referenced in the body via `param.<m>` where `<m>` is
+# defined on exactly one user class (and isn't a common operator /
+# built-in-overlap method like `length`/`each`/`+`/...), the param's
+# default `int` type narrows to `obj_<C>`.
+#
+# Without this narrowing the param stayed at `int` until a call-site
+# arg-type widened it. For methods that are only ever called via a
+# poly receiver (e.g. through `obj.method(:m)` or a heterogeneous
+# poly_array dispatch), no concrete call site exists — caller-side
+# widening can't fire — and the body would emit raw int operations
+# against the param's expected user-class type.
+
+class CPU
+  def peek_a(addr); addr * 2 + 1; end
+  def cycles_advance(n); n + 100; end
+end
+
+# Two separate methods that each take a CPU param. Neither has a
+# direct call-site arg whose type spinel statically knows to be CPU
+# at the time scan_new_calls runs (caller-side widening), so the
+# narrow has to come from the body's method-call shapes.
+
+def fetch(cpu, addr)
+  cpu.peek_a(addr)        # peek_a is only on CPU → narrow cpu to obj_CPU
+end
+
+def step(cpu, n)
+  cpu.cycles_advance(n)   # cycles_advance only on CPU → narrow
+end
+
+c = CPU.new
+puts fetch(c, 7)          # 15
+puts step(c, 3)           # 103

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

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

data/vendor/spinel/test/param_widens_when_body_assigns_string.rb

@@ -0,0 +1,21 @@
+# A method body that reassigns one of its parameters to a value
+# of an incompatible type (here: int call sites + string body
+# write) needs the param's slot widened to `poly` so the
+# generated C can hold both shapes via sp_RbVal. Without the
+# widening the parameter slot stays at the call-site-inferred
+# `mrb_int`, and the body's `lv_x = "forever"` assignment is
+# `mrb_int = const char *` — rejected by gcc under
+# `-Wint-conversion`.
+
+class Logger
+  def report(label, hclk)
+    hclk = "forever" if hclk == 4294967295
+    puts label
+    puts hclk
+  end
+end
+
+l = Logger.new
+l.report("running", 1234)
+l.report("running", 4294967295)
+l.report("done", 17)

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

@@ -0,0 +1,6 @@
+running
+1234
+running
+forever
+done
+17

data/vendor/spinel/test/pattern.rb

@@ -0,0 +1,41 @@
+# Test pattern matching (case/in)
+
+# Type-based matching
+def describe(val)
+  case val
+  in Integer
+    "integer: #{val}"
+  in String
+    "string: #{val}"
+  in Float
+    "float"
+  in true | false
+    "boolean"
+  in nil
+    "nil"
+  end
+end
+
+puts describe(42)       # integer: 42
+puts describe("hello")  # string: hello
+puts describe(3.14)     # float
+puts describe(true)     # boolean
+puts describe(nil)      # nil
+
+# Value matching
+def check(x)
+  case x
+  in 0
+    "zero"
+  in 1
+    "one"
+  in Integer
+    "other int"
+  end
+end
+
+puts check(0)   # zero
+puts check(1)   # one
+puts check(99)  # other int
+
+puts "done"

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

@@ -0,0 +1,9 @@
+integer: 42
+string: hello
+float
+boolean
+nil
+zero
+one
+other int
+done

data/vendor/spinel/test/poly.rb

@@ -0,0 +1,24 @@
+# Test polymorphic variables (sp_RbValue)
+
+# Variable holding different types
+x = 1
+puts x      # 1
+x = "hello"
+puts x      # hello
+
+# Polymorphic method parameter
+def show(val)
+  puts val
+end
+show(42)
+show("world")
+show(true)
+show(3.14)
+
+# Nilable
+y = "found"
+puts y      # found
+y = nil
+puts y.nil? # true — but this needs nil tracking
+
+puts "done"

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

@@ -0,0 +1,9 @@
+1
+hello
+42
+world
+true
+3.14
+found
+true
+done

data/vendor/spinel/test/poly2.rb

@@ -0,0 +1,34 @@
+# Test Phase 2: heterogeneous arrays, bimorphic dispatch
+
+# Heterogeneous array
+arr = [1, "two", 3.0, true, nil]
+arr.each do |x|
+  puts x
+end
+# 1, two, 3.0, true, (blank)
+
+# Array with mixed types
+nums = [10, 20, 30]
+puts nums.length  # 3
+
+# Duck typing (bimorphic)
+class Dog
+  def speak
+    "Woof!"
+  end
+end
+
+class Cat
+  def speak
+    "Meow!"
+  end
+end
+
+def make_noise(animal)
+  puts animal.speak
+end
+
+make_noise(Dog.new)  # Woof!
+make_noise(Cat.new)  # Meow!
+
+puts "done"

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

@@ -0,0 +1,9 @@
+1
+two
+3.0
+true
+
+3
+Woof!
+Meow!
+done

data/vendor/spinel/test/poly_arith.rb

@@ -0,0 +1,34 @@
+# Test arithmetic on polymorphic values
+
+def calc(a, b)
+  a + b
+end
+
+puts calc(10, 20)         # 30
+puts calc(1.5, 2.5)       # 4.0
+puts calc("hello", " world")  # hello world
+
+# Mixed numeric
+def double(x)
+  x * 2
+end
+
+puts double(5)     # 10
+puts double(3.14)  # 6.28
+
+# Comparison
+def bigger?(a, b)
+  a > b
+end
+
+puts bigger?(10, 5)     # true
+puts bigger?(1.0, 2.0)  # false
+
+# to_s on poly
+def show(x)
+  puts x.to_s
+end
+show(42)
+show("hi")
+
+puts "done"

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

@@ -0,0 +1,10 @@
+30
+4.0
+hello world
+10
+6.28
+true
+false
+42
+hi
+done

data/vendor/spinel/test/poly_array_literal_callnode_typed_elem.rb

@@ -0,0 +1,37 @@
+# `[A, B]` outer literal where A and B are non-ArrayNode expressions
+# returning a typed `<X>_ptr_array` (e.g. `(0..N).map { ... }`).
+# Without the fix, compile_array_literal's poly_array branch hits
+# `box_value_to_poly(et, val)` for the CallNode element, which lowers
+# to `sp_box_ptr_array(val)` — cls_id PTR_ARRAY only, the inner
+# element type is erased. Subsequent `arr[b][i][j]` reads dispatch
+# through the PTR_ARRAY arm at level 1, which boxes the next-level
+# element as `sp_box_obj(p, 0)` (cls_id 0, "unknown obj"), and the
+# level-2 dispatch can't match any cls_id arm — every leaf read
+# returns 0.
+#
+# With the fix, the runtime conversion loop iterates the typed
+# PtrArray and pushes each inner with `sp_box_<inner-type>` (e.g.
+# `sp_box_int_array(...)` for an IntArray element), so the cls_id
+# chain stays tagged through every level.
+
+class C
+  def initialize
+    @a = [(0..3).map { |i| [i * 10, i * 10 + 1, i * 10 + 2] },
+          (0..3).map { |i| [i * 100, i * 100 + 1, i * 100 + 2] }]
+  end
+  def get(b, i, j); @a[b][i][j]; end
+  def out_len; @a.length; end
+  def mid_len(b); @a[b].length; end
+  def in_len(b, i); @a[b][i].length; end
+end
+
+c = C.new
+puts c.out_len           # 2
+puts c.mid_len(0)        # 4
+puts c.in_len(0, 0)      # 3
+puts c.get(0, 0, 0)      # 0
+puts c.get(0, 1, 1)      # 11
+puts c.get(0, 3, 2)      # 32
+puts c.get(1, 0, 0)      # 0
+puts c.get(1, 2, 1)      # 201
+puts c.get(1, 3, 2)      # 302

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

@@ -0,0 +1,9 @@
+2
+4
+3
+0
+11
+32
+0
+201
+302