rubyduino 0.1.1

data/vendor/spinel/test/bm_instance_eval.rb

@@ -0,0 +1,209 @@
+# Test instance_eval { block } block-form lifting.
+# Each section's output is compared against CRuby by `make test`.
+
+class Config
+  attr_accessor :port, :host, :debug
+
+  def initialize
+    @port = 0
+    @host = ""
+    @debug = false
+  end
+end
+
+# ---- 1. Top-level basic form ----
+cfg = Config.new
+cfg.instance_eval do
+  self.port = 8080
+  self.host = "localhost"
+  self.debug = true
+end
+puts cfg.port    # 8080
+puts cfg.host    # localhost
+puts cfg.debug   # true
+
+# ---- 2. Two instance_eval calls in sequence (same object) ----
+cfg.instance_eval do
+  self.port = 9090
+end
+puts cfg.port    # 9090
+
+# ---- 3. Methods called inside the block dispatch through self ----
+class Routes
+  attr_accessor :entries
+
+  def initialize
+    @entries = "init".split(",")  # StrArray hint
+    @entries.pop                  # start empty
+  end
+
+  def get(path)
+    @entries.push("GET " + path)
+  end
+
+  def post(path)
+    @entries.push("POST " + path)
+  end
+end
+
+app = Routes.new
+app.instance_eval do
+  get("/")
+  get("/about")
+  post("/login")
+end
+i = 0
+while i < app.entries.length
+  puts app.entries[i]
+  i = i + 1
+end
+
+# ---- 4. instance_eval inside a top-level while loop ----
+counter = Config.new
+i = 0
+while i < 3
+  counter.instance_eval do
+    self.port = self.port + 1
+  end
+  i = i + 1
+end
+puts counter.port  # 3
+
+# ---- 5. instance_eval inside a top-level if branch ----
+flag = Config.new
+cond = 1
+if cond > 0
+  flag.instance_eval do
+    self.debug = true
+  end
+end
+puts flag.debug  # true
+
+# ---- 6. Different objects of different classes interleaved ----
+a = Config.new
+b = Routes.new
+a.instance_eval { self.port = 1 }
+b.instance_eval { get("/x") }
+a.instance_eval { self.port = 2 }
+b.instance_eval { post("/y") }
+puts a.port              # 2
+puts b.entries.length    # 2
+puts b.entries[0]        # GET /x
+puts b.entries[1]        # POST /y
+
+# ---- 7. Reassignment to another instance of the same class ----
+fresh = Config.new
+fresh.instance_eval { self.port = 11 }
+puts fresh.port  # 11
+fresh = Config.new
+fresh.instance_eval { self.port = 22 }
+puts fresh.port  # 22
+
+# ---- 8. Receiver from instance variable inside a class method ----
+# v2 wider-receiver (ivars): @ivar receiver. cls_ivar_type returns the
+# ivar's stored type; @current_class_idx is set by ieval_walk_class_methods
+# when entering each class's instance method bodies, so the lift can
+# resolve `@routes` to obj_Routes without going through a local copy.
+class Boot
+  attr_accessor :routes
+
+  def initialize
+    @routes = Routes.new
+  end
+
+  def install
+    @routes.instance_eval do
+      get("/ivar")
+      post("/ivar")
+    end
+  end
+end
+
+boot = Boot.new
+boot.install
+puts boot.routes.entries.length  # 2
+puts boot.routes.entries[0]      # GET /ivar
+puts boot.routes.entries[1]      # POST /ivar
+
+# ---- 9. Ivar receiver in tail position of a class method ----
+# Same lift but the instance_eval call is the method body's last
+# expression. The pre-existing v1 path always emitted the lift in
+# statement form; here it must round-trip through compile_ieval_call_expr
+# (the comma-expression form) so the enclosing method can still
+# return the receiver. Sister-class with a typed return signature.
+class Configure
+  attr_accessor :routes
+
+  def initialize
+    @routes = Routes.new
+  end
+
+  def setup
+    @routes.instance_eval { get("/tail") }
+  end
+end
+
+cfgr = Configure.new
+ret = cfgr.setup
+puts ret.entries.length  # 1
+puts ret.entries[0]      # GET /tail
+
+# ---- 10. Receiver from a method param ----
+# v2 wider-receiver (params): the param's class comes from the caller,
+# not the body. infer_param_types_from_callsites widens Wire#wire_param's
+# `r` ptype from "int" to obj_Routes when it sees `w.wire_param(shared)`
+# at top level (with `w` declared in scope so the receiver-method
+# branch fires). ieval_walk_class_methods then declares `r: obj_Routes`
+# in scope, and find_var_type resolves the LocalVariableReadNode
+# receiver inside the method body.
+class Wire
+  def wire_param(r)
+    r.instance_eval do
+      get("/param")
+    end
+  end
+end
+
+w = Wire.new
+shared = Routes.new
+w.wire_param(shared)
+puts shared.entries.length  # 1
+puts shared.entries[0]      # GET /param
+
+# ---- 11. Param receiver in tail position ----
+# Same as §10 but the lift is the method body's last expression so
+# the wire_param signature has to match the comma-expression return
+# value. infer_call_type's synthetic-name early case (PR #15
+# follow-up landed in PR #158) handles this once the rewrite fires.
+class WireTail
+  def wire_param(r)
+    r.instance_eval { get("/tail-param") }
+  end
+end
+
+w2 = WireTail.new
+shared2 = Routes.new
+ret2 = w2.wire_param(shared2)
+puts ret2.entries.length  # 1
+puts ret2.entries[0]      # GET /tail-param
+
+# ---- 12. Method-local copy of a class instance ----
+# scan_locals_first_type sees `routes = Routes.new` and declares
+# `routes : obj_Routes` in scope. The method-param case (§10) and
+# this method-local case both flow through the same find_var_type
+# fallback added to ieval_rewrite_call's LocalVariableReadNode branch.
+class WireLocal
+  def setup
+    routes = Routes.new
+    routes.instance_eval do
+      get("/local")
+      post("/local")
+    end
+    routes
+  end
+end
+
+ret3 = WireLocal.new.setup
+puts ret3.entries.length  # 2
+puts ret3.entries[0]      # GET /local
+puts ret3.entries[1]      # POST /local

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

@@ -0,0 +1,27 @@
+8080
+localhost
+true
+9090
+GET /
+GET /about
+POST /login
+3
+true
+2
+2
+GET /x
+POST /y
+11
+22
+2
+GET /ivar
+POST /ivar
+1
+GET /tail
+1
+GET /param
+1
+GET /tail-param
+2
+GET /local
+POST /local

data/vendor/spinel/test/bound_method_array.rb

@@ -0,0 +1,22 @@
+# An array of Methods naturally infers as a ptr_array of
+# obj_Method, since Method is just a regular user class as
+# far as the type system is concerned. Each entry survives the
+# round-trip through sp_PtrArray_get and dispatches to its captured
+# (self, fn) pair.
+
+class C
+  def double(x); x * 2; end
+  def triple(x); x * 3; end
+  def quad(x);   x * 4; end
+
+  def fns
+    [method(:double), method(:triple), method(:quad)]
+  end
+end
+
+c = C.new
+fns = c.fns
+puts fns.length
+puts fns[0].call(5)
+puts fns[1].call(5)
+puts fns[2].call(5)

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

@@ -0,0 +1,4 @@
+3
+10
+15
+20

data/vendor/spinel/test/bound_method_basic.rb

@@ -0,0 +1,27 @@
+# `method(:foo)` inside a class body must yield a value that survives
+# being stored in an ivar / passed across a method-call boundary, then
+# called with `bm.call(x)` or `bm[x]`. Spinel's pre-fix path treated
+# `method(:foo)` as a compile-time alias only — the variable held a
+# placeholder int and the call body silently miscompiled to `return 0`.
+
+class C
+  def initialize
+    @bm = method(:double)
+  end
+
+  def double(x)
+    x * 2
+  end
+
+  def via_call(x)
+    @bm.call(x)
+  end
+
+  def via_bracket(x)
+    @bm[x]
+  end
+end
+
+c = C.new
+puts c.via_call(7)
+puts c.via_bracket(20)

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

@@ -0,0 +1,2 @@
+14
+40

data/vendor/spinel/test/bound_method_gc.rb

@@ -0,0 +1,30 @@
+# GC: a Method captures `self`, and the captured receiver may
+# be reachable only through the Method itself. The auto-generated
+# `sp_Method_gc_scan` walks `iv_self_obj` via `sp_gc_mark`, so
+# the receiver survives any GC cycle that runs before `bm.call`.
+#
+# Counter has only an int ivar, which would normally make it a
+# value-type class — but `detect_method_taken_classes` excludes it
+# so `self` stays a heap-allocated pointer that the Method can
+# safely hold.
+
+class Counter
+  def initialize(start)
+    @n = start
+  end
+  def add(x)
+    @n + x
+  end
+  def own_bm
+    method(:add)
+  end
+end
+
+def make_bm
+  c = Counter.new(100)
+  c.own_bm  # the only handle to `c` is via the returned Method
+end
+
+bm = make_bm
+1000.times { String.new("garbage" * 100) }
+puts bm.call(7)

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

@@ -0,0 +1 @@
+107

data/vendor/spinel/test/bound_method_obj_recv.rb

@@ -0,0 +1,41 @@
+# `<obj>.method(:bar)` — bind to a receiver that's not the current
+# `self`. The Method's iv_self_obj must end up holding the
+# receiver, not the *enclosing* class's `self`.
+#
+# Note: Method#call(x) lowers to a function pointer cast to
+# `(void *, mrb_int...) -> mrb_int`, so the bound underlying method
+# must return an int. Non-int returns are out of scope for this PR.
+
+class Worker
+  def initialize(base)
+    @base = base
+  end
+  def shout(x)
+    @base + x
+  end
+end
+
+# (a) bound on a local variable
+def via_local
+  w = Worker.new(100)
+  w.method(:shout)
+end
+puts via_local.call(42)   # 142
+
+# (b) bound on an ivar from another class
+class Boss
+  def initialize
+    @worker = Worker.new(1000)
+  end
+  def via_ivar
+    @worker.method(:shout)
+  end
+end
+puts Boss.new.via_ivar.call(99)   # 1099
+
+# (c) array of Methods on a non-self receiver
+def fns
+  w = Worker.new(10)
+  [w.method(:shout), w.method(:shout)]
+end
+fns.each {|bm| puts bm.call(7) }   # 17, 17

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

@@ -0,0 +1,4 @@
+142
+1099
+17
+17

data/vendor/spinel/test/bound_method_single_eval.rb

@@ -0,0 +1,37 @@
+# Issue #215 / Gemini-review-critical: the receiver expression in
+# `<recv>.method(:foo).call(args)` and `<recv>.method(:foo)[args]`
+# must be evaluated exactly once. The Method#call lowering reads
+# both `iv_fn_ptr` and `iv_self_obj` off the receiver — a naive
+# `((cast)rc->iv_fn_ptr)((void *)rc->iv_self_obj, args)` evaluates
+# `rc` twice, so a side-effecting receiver fires its side effect
+# twice (and pays the cost twice).
+#
+# This test exercises a Method whose source receiver is the result
+# of a side-effecting call. The side-effect counter must increment
+# exactly once per `bm.call`, not twice.
+
+class Worker
+  def initialize(base)
+    @base = base
+  end
+  def shout(x)
+    @base + x
+  end
+end
+
+$count = 0
+
+def make_worker
+  $count = $count + 1
+  Worker.new(100)
+end
+
+# Chained: the receiver of `.call` is the whole make_worker.method(...)
+# expression. Double-eval would fire the side effect twice.
+puts make_worker.method(:shout).call(7)   # 107
+puts $count                                # 1
+
+# Same shape via Method#[].
+$count = 0
+puts make_worker.method(:shout)[42]        # 142
+puts $count                                # 1

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

@@ -0,0 +1,4 @@
+107
+1
+142
+1

data/vendor/spinel/test/box_pointer_to_poly.rb

@@ -0,0 +1,27 @@
+# `box_val_to_poly` and `box_expr_to_poly` previously fell through
+# to `sp_box_int(val)` for any pointer-typed expression they didn't
+# explicitly recognize (hashes, mutable strings, etc.), yielding
+# -Wint-conversion errors and silently truncating the pointer to a
+# 64-bit int. The fix routes pointer types through `sp_box_obj`.
+#
+# Triggers the path: a method whose return type is widened to poly
+# across branches (here: hash and string). The hash branch's
+# `return {a: 1, ...}` runs through `box_expr_to_poly`, which
+# without the fix emitted `sp_box_int(<sp_SymIntHash *>)` and gcc
+# rejected with "passing argument 1 of sp_box_int makes integer
+# from pointer without a cast".
+#
+# The test only verifies the program compiles and runs — round-
+# tripping the hash back out of the poly slot is the caller's
+# problem since the cls_id of 0 erases the concrete type.
+
+def get(flag)
+  if flag > 0
+    return {a: 1, b: 2, c: 3}
+  end
+  "hello"
+end
+
+x = get(0)
+y = get(1)
+puts "ok"

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

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

data/vendor/spinel/test/box_unbox_local_assign_cond.rb

@@ -0,0 +1,22 @@
+# `infer_type(LocalVariableWriteNode)` returned the RHS's static
+# type rather than the slot's. `compile_cond_expr` uses the
+# expression type to pick between `sp_poly_truthy(...)` and a
+# direct test. Without the slot-type report, an
+# `if (sprite = arr[i])` expression where `sprite`'s slot is poly
+# (widened by other writers) but the RHS is scalar fell through
+# to a direct test on the boxed value, which gcc rejects.
+
+class C
+  def initialize
+    @arr = [10, "twenty", :thirty]   # poly_array
+  end
+  def find(i)
+    if (entry = @arr[i])             # entry-slot is poly (widened by all the writes below)
+      entry
+    end
+  end
+end
+
+c = C.new
+puts c.find(0).to_s
+puts c.find(1).to_s

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

@@ -0,0 +1,2 @@
+10
+twenty