tomoaki/hakorune
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

🎉 Phase 11.8/12.7: MIR Core-13 完全実装 + 糖衣構文ドキュメント更新

Browse Source 
主要な変更:
- MIR Core-13命令セット確定（Load/Store削除の革命的設計）
  - Const, BinOp, Compare（値・計算）
  - Jump, Branch, Return, Phi（制御）
  - Call, BoxCall, ExternCall（呼び出し）
  - TypeOp, Safepoint, Barrier（メタ）
- Phase 12.7糖衣構文ドキュメント整理（超圧縮重視、可逆変換保証）
- MIRビルダーのモジュール分割完了
- vtableテストスイート拡充
- AI協調開発ツール追加（並列リファクタリング支援）

詳細:
- src/mir/instruction_introspection.rs: core13_instruction_names()追加
- MIRビルダー分割: decls.rs, exprs_*.rs, fields.rs
- plugin_loader_v2: errors.rs, host_bridge.rs分離
- 論文用データ: mir13-final.md作成

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Moe Charm
2025-09-04 11:34:15 +09:00
parent 4e824fa00e
commit fb2d8e37d5
62 changed files with 3632 additions and 835 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
CURRENT_TASK.md
View File

@ -9,7 +9,7 @@
- 目的: ユーザー/プラグイン/内蔵を TypeBox+VTable で統一し、VM/JIT/WASM の同一実行を実現。
- 現状: Phase 12 完了（JIT/VM FunctionBox 呼び出し統一、Lambda→FunctionBox 値化、最小Builtin方針）。WASM v2 最小ディスパッチ導入。
次フェーズ: リファクタリング（Phase 13）開始
次フェーズ: MIR統一 + リファクタリング（Phase 11.8/13）
- 目標: 1ファイル1000行以内を目安に分割・整理。他AI/将来タスクが読みやすい構造へ。
- 制約: 挙動不変・公開API維持・段階的分割＋逐次ビルド/テスト。
@ -49,16 +49,54 @@ Compact Snapshot（2025‑09‑03/Finalize）
## 次タスク（優先順）
- フェーズM（MIR Core‑13 統一・挙動不変）
- M1) Core‑13 を既定ON（nyash.toml [env] 推奨: NYASH_MIR_CORE13=1, NYASH_OPT_DIAG_FORBID_LEGACY=1）
- M2) BuilderをCore‑13準拠に調整（ArrayGet/Set・RefGet/Set・PluginInvokeをemitしない。BoxCallへ正規化）
- M3) OptimizerでUnary→BinOpを常時変換、Load/StoreのSSA置換（最終MIRから旧命令を排除）
- M4) Core‑13検証を追加（最終MIRに旧命令が存在したらエラー）
- M5) VM/JIT/AOTのBoxCall fast‑path/vtable維持（setはBarrier必須）
- フェーズA（安全分割・挙動不変）
- A1) vm_instructions を 10前後のモジュールへ分割（consts/arith/compare/flow/call/boxcall/array/refs/future/newbox/print_debug）
- 現状: `src/backend/vm_instructions/{core,call,newbox,function_new,extern_call,boxcall,plugin_invoke}.rs` に分割済み
- A2) plugin_loader_v2 を 4〜5ファイルへ分割（ffi_tlv/registry/host_bridge/loader/errors）
- A3) vm を 3〜4ファイルへ分割（state/exec/gc/format）
- フェーズB（読みやすさ整形）
- B1) mir/builder の expr系切り出し
- B2) interpreter/plugin_loader の役割分離
- B2) interpreter/plugin_loader の役割分離
- フェーズC（軽整理）
- 命名/コメント整備、公開API re-export、1000行未満へ微調整
## 次のゴール（Phase W — Windows JIT(EXE) × Egui 起動）
目的: Windows 上で Cranelift JIT（必要に応じ EXE ラッパ）で Egui ウィンドウを起動する最小スモークを確立。成功の再現性を高め、論文化に向けて手順を固定。
推奨タスク（開いたら一発で着手できる指示）
- W1) 準備（Windows）
- `cargo build --release --features cranelift-jit`
- Egui プラグイン DLL をビルド（`plugins/nyash-egui-plugin`）し、`nyash.toml` の `[plugins]/[libraries]` と検索パスが DLL 配置と一致しているか確認。
- 必要なら PATH 追加または `nyash.toml [plugin_paths]` に DLL ディレクトリを追記。
- W2) 最小アプリ（例: apps/ny-egui-hello/main.nyash）
- `open(width,height,title)` → `uiLabel("Hello, Nyash Egui")` → `run()` の極小シナリオを用意。
- 実行: `.
target\release\nyash --backend jit apps\ny-egui-hello\main.nyash`
- W3) HostBridge 推奨トグル（任意）
- `NYASH_JIT_HOST_BRIDGE=1`（JIT から HostBridge を優先利用。BoxCall→HostCall/Bridge を強制）
- `NYASH_USE_PLUGIN_BUILTINS=0`（HostCall 優先の確認時に推奨）
- W4) スモークスクリプト化（PowerShell）
- `tools/egui_win_smoke.ps1` を追加: ビルド→PATH 調整→実行までを一括化（再現性向上）。
- W5) 追加JITスモーク（Core‑13 準拠）
- Instance: `getField/setField` の往復（HostBridge 経由）
- Extern: `console.log` の起動（ログ確認）
判定条件（Done）
- Windows で Egui ウィンドウが起動（タイトル/ラベル表示確認）
- PowerShell スクリプトでワンコマンド起動が再現（DLL 探索含め手戻りゼロ）
- Core‑13 JIT スモーク（Array/Map/Instance/Extern）の最小セットが緑
参考メモ（現状の統一状況）
- Core‑13 は Builder→Optimizer→Compiler の三段ガードで旧命令ゼロを強制（最終MIR厳格チェックも導入済み）。
- JIT の BoxCall fast‑path は HostCall 優先に整理（PluginInvoke は保険/フォールバック）。
- vtable スタブは Map/String/Array/Console をヘルパ化済み（挙動不変・Barrier維持）。
## 完了（Done）
- TypeBox ABI 雛形: `src/runtime/type_box_abi.rs`
- TypeRegistry 雛形: `src/runtime/type_registry.rs`
@ -132,9 +170,10 @@ Compact Snapshot（2025‑09‑03/Finalize）
注記: 公開APIは維持。各段階ごとに `cargo build` と限定ユニットで確認して進める。
## 残タスク（To‑Do）
1) リファクタフェーズA/B/C 実施（段階コミット＋スモーク）
2) ドキュメント更新（開発者向け構成図・分割指針・API安定ポリシー）
3) LLVM（本実装）は低優先：Call シム import/Lower の設計だけ先に下書き
1) MIR Core‑13 統一（M1〜M5）＋ スモーク修正
2) リファクタフェーズA/B/C 実施（段階コミット＋スモーク）
3) ドキュメント更新（Phase 11.8 の README/PLAN/TECHNICAL_SPEC と CIポリシー）
4) LLVM（本実装）は低優先：BoxCall シムのinlining設計だけ先行
## 実行コマンド（サマリ）
- ビルド: `cargo build --release --features cranelift-jit`
@ -189,6 +228,12 @@ Phase 12 ゴール（検証観点）
- `src/interpreter/plugin_loader/types.rs`（PLUGIN_CACHE／LoadedPlugin／PluginInfo／各Handle）
- `src/interpreter/plugin_loader/proxies.rs`（File/Math/Random/Time/DateTime 各 Proxy）
- `src/interpreter/plugin_loader/loader.rs`（PluginLoader: load_*/create_* エントリ）
- B1(builder) 続行: `build_static_main_box` / `build_box_declaration` を `src/mir/builder/decls.rs` に抽出。
- `src/mir/builder.rs` は `mod decls;` を追加し、委譲。ビルド（`cargo test --no-run`）成功。
- A2(plugin_loader_v2) 進捗: `enabled/{errors.rs, host_bridge.rs}` を新設し、`loader.rs` からエラー変換と invoke ブリッジを抽出。
- `errors.rs`: `from_fs`/`from_toml`/`or_plugin_err` ヘルパ
- `host_bridge.rs`: `invoke_alloc`（TLV 呼び出しの小ラッパ）
- `enabled/mod.rs` に `mod errors; mod host_bridge;` を追加し、ビルド確認済み。
- 再開手順（最短ルート）
1) `src/interpreter/plugin_loader/mod.rs` を分割モードに切替

90
docs/development/current/CURRENT_TASK.md
View File

@ -1,4 +1,25 @@
# 🎯 CURRENT TASK - 2025-09-03 Snapshot（Phase 12.05: 旧C ABI→新C ABI(TypeBox) 変換 + 差分テスト拡充）
# 🎯 CURRENT TASK - 2025-09-04 Update（Phase 12.7-B: ChatGPT5糖衣構文実装）
## 🔄 現在のフェーズ: Phase 12.7-B
### Phase 12.7-A（✅ 完了）
- peek式、continue文、?演算子、Lambda式実装完了
- フィールド型アノテーション（field: TypeBox）実装完了
- birth統一、予約語15個確定
### Phase 12.7-B（🔄 実装中）- ChatGPT5糖衣構文
実装優先順位：
1. **パイプライン演算子（|>）** - 処理フローの明確化
2. **セーフアクセス（?.）とデフォルト値（??）** - null安全性向上
3. **増分代入演算子（+=, -=等）** - 簡潔な記述
4. **デストラクチャリング** - パターン束縛
5. **範囲演算子（..）** - ループ・スライス用
6. **高階関数演算子（/:, \:, //）** - 関数型プログラミング
7. **ラベル付き引数** - API呼び出しの可読性
---
## 📋 Phase 12.05 完了事項（2025-09-03 Snapshot）
目的: 既存C ABIプラグインを「統一TypeBox C ABI」に段階移行。LoaderのTypeBoxプローブ + `invoke_id` 優先経路を活用し、コアBox（Array/Map/String/Integer/Console）から順に resolve/invoke_id を実装していく。
@ -75,9 +96,9 @@ NYASH_DISABLE_TYPEBOX=1 cargo test --lib typebox_tlv_diff -- --nocapture
- 症状: ArrayBox/MapBox の生成で Unknown Box type（plugins-onlyレジストリでBuiltin未登録）。
- 影響: `tests::vtable_*`、`backend::vm::tests::test_vm_user_box_*`、MIR周辺（BoxCall method_id）
- 方針:
- A1) 既定を Builtin + Plugins に戻す（ランタイム初期化時にBuiltinを常に登録）。
- A1) 既定を Builtin + Plugins に戻す（ランタイム初期化時にBuiltinを常に登録）。→ 実装済（2025‑09‑04）
- A2) テスト側で `NyashRuntimeBuilder` に「builtin有効」フラグを追加し明示登録。
- A3) 当面は feature `plugins-only` を導入し、デフォルトは builtin 有効に戻す。
- A3) 当面は feature `plugins-only` を導入し、デフォルトは builtin 有効に戻す。→ 実装済（2025‑09‑04、`plugins-only` 有効時のみBuiltin無効）
- P2PBox テスト赤（on_once/ping 系）
- 症状: 期待値とズレ（once後のカウント、ping応答の記録）。
@ -203,6 +224,45 @@ NYASH_DISABLE_TYPEBOX=1 cargo test --lib typebox_tlv_diff -- --nocapture
3) Verifier: await前後のcheckpoint検証ルール追加（実装済・--verifyで有効）
4) CI/Smokes: async系3本を最小マトリクスでtimeoutガード
### 追加メモ（2025-09-04 quick fixes / vtable）
- VM: BasicBlock terminator（Return）が実行されず常にvoid返却になるバグを修正。
- 影響: vtable 経由で値を設定しても関数戻りが void になるケースを解消。
- 実装: `backend/vm_exec.rs` で terminator を命令列後に必ず実行。
- vtable（ArrayBox）: len/get/set を vtable-first で直処理（ビルトイン）
- ルーティング: `type_registry` のスロット 100(get)/101(set)/102(len)
- 実装: `backend/vm_instructions/boxcall.rs::try_boxcall_vtable_stub`
- テスト: `src/tests/vtable_array_string.rs` のケースを緑化（`NYASH_ABI_VTABLE=1`）
### Phase 12 Core Stabilization（2025-09-04, new）
目的: コア型（Array / String / Console）を vtable 直行で安定化し、STRICT でも穴が出ない最低限を担保。Plugin 系は TypeBox 経路で据え置き、後続で統一を検討。
完了（実装済み）
- Array vtable 直行: len/get/set + P0: push/pop/clear + P1: contains/indexOf/join + P2: sort/reverse/slice
- String vtable 直行: len + 追加: substring/concat（汎用経路にも反映）
- Console vtable 直行: log/warn/error/clear
- ターゲットテスト: `vtable_array_ext.rs`, `vtable_array_p1.rs`, `vtable_array_p2.rs`, `vtable_string.rs`, `vtable_console.rs` 追加し緑
- トグル方針: 開発検査は `NYASH_ABI_VTABLE=1 NYASH_ABI_STRICT=1`、通常実行は `NYASH_ABI_VTABLE=1`
据え置き（次期以降）
- Plugin 系（Math/Encoding/Regex/Path/TOML/Time/Counter/File）への全面 vtable 直行化は保留。TypeBox/差分テストで安定運用を維持し、合意後に by‑slot PluginInvoke ブリッジで統一を検討。
次タスク（小粒・コア内）
1) Map vtable の厚み（keys/values/delete/remove/clear）を STRICT 前提で整備（slots: 205..208 目安）
2) String 追加メソッド（indexOf/replace/trim/toUpper/toLower）の vtable 化＋テスト
3) vtable/slot 表の整理（`type_registry` に注釈し HostAPI 番号空間の役割を明記）
4) JIT 最適化の種まき（新規 slots に対する by‑id パスの追加）
運用ノート
- STRICT 有効時は未 slot 化メソッドを即検知。急がず穴埋めしながら進める。
- Plugin 系は現状 TypeBox 経路を信頼し、vtable 直行は時期を見て段階導入（互換/回帰の監視を優先）。
### vtable カバレッジ拡張（提案・P0→P2）
- P0（今回追加予定）: ArrayBox push/pop/clear を vtable 直処理
- slots 103(push)/104(pop)/105(clear) を `type_registry` に追加し、VM vtable スタブに実装
- P1: contains/indexOf/join
- P2: sort/reverse/slice（副作用・比較の仕様差に注意）
---
**Phase 12.7: 文法改革（P0 即実装スコープ）**
@ -1000,3 +1060,27 @@ JIT分割 進捗（継続観点）
- 現行 `cargo test` は既存の vm_e2e.rs（別件API）で失敗あり。本変更とは独立。`cargo build` は成功。
- MIR: 直書き Lambda 即時呼び出しのみ Lower 済み。変数に入れた FunctionBox 呼び出しは Interpreter 経由で安定。
- 将来: ClosureEnv の by-ref 完全対応（Upvalue セル化の一般化）や me Weak の利用箇所拡大は引き続き検討。
# 🧭 TL;DR Update (2025-09-04)
目的と順序（コンテキスト節約版）
- 1) コア安定化（vtable直行）: Array / Map / String / Console を STRICTでも穴なしに。
- 2) リファクタリング: vtableスタブ共通化・slot表注釈整備。
- 3) JITはEXE（AOT）到達後に段階適用（by-id最適化を追加）。
- Plugin系はTypeBox経路を維持（将来 by-slot で統一検討）。
現状ステータス（実装済み）
- Array: len/get/set + push/pop/clear + contains/indexOf/join + sort/reverse/slice（テスト緑）。
- String: len + substring/concat + indexOf/replace/trim/toUpper/toLower（テスト緑）。
- Console: log/warn/error/clear（スモーク緑）。
- Map: size/len/has/get/set + keys/values/delete/remove/clear（テスト緑）。
- VM: Return未実行バグ修正済（terminator実行）。
次タスク（最小）
- STRICT狙い撃ちの追加境界テスト（空/不存在/Unicode/重複）でコアを固める。
- vtableスタブの重複削減（変換/バリアを小ヘルパへ）。
- slot表（type_registry）の役割注釈とHostAPI番号空間の明記。
- AOTスモークに新slotを反映し、EXE経路の最小ケースをGreenに。
運用
- 検査: `NYASH_ABI_VTABLE=1 NYASH_ABI_STRICT=1`
- 通常: `NYASH_ABI_VTABLE=1`

21
docs/development/roadmap/phases/phase-11.8_mir_cleanup/PLAN.md
View File

@ -1,4 +1,4 @@
# Phase 11.8 MIR Cleanup – Plan (Core‑13)
# Phase 11.8 MIR Cleanup – Plan (Core‑13 固定)
目的
- MIR を「最小の接着剤」に純化し、BoxCall へ集約。
@ -9,13 +9,13 @@
- 維持: BinOp/Compare は MIR に残す（定数畳み込み/分岐簡約を最大化）。
- 効果: EffectMask の正確化、WriteBarrier の確実化。
段階導入トグル（env）
- `NYASH_MIR_ARRAY_BOXCALL=1` … ArrayGet/Set → BoxCall を有効化
- `NYASH_MIR_REF_BOXCALL=1` … RefGet/Set → BoxCall を有効化
- `NYASH_MIR_CORE13=1` … Core‑13 セットの一括有効（将来拡張）
段階導入トグル（env・既定ONにする）
- `NYASH_MIR_CORE13=1` … Core‑13 一括有効
- `NYASH_OPT_DIAG_FORBID_LEGACY=1` … 旧命令が最終MIRに残ったらエラー
- 参考: `NYASH_MIR_ARRAY_BOXCALL=1`, `NYASH_MIR_REF_BOXCALL=1` は CORE13=1 で内包
実装ステップ
1) Optimizer パス（デフォルト OFF）
1) Optimizer パス（デフォルト ON）
- ArrayGet/Set → BoxCall に変換
- RefGet/Set → BoxCall に変換
- 変換後の Effect/Barrier を整合
@ -25,10 +25,10 @@
3) JIT: lower_boxcall の fast‑path
- Array: GEP+Load/Store（Bounds/Barrier含む）
- Field: 内部表現に応じた inlining（失敗時 plugin_invoke）
4) Smokes/Bench
4) Smokes/Bench（Core‑13基準）
- array_access_sequential / array_access_random / field_access / arithmetic_loop
- 基準: 速度 ±5%, メモリ ±10%, MIR サイズ -20% 目標
5) 検証
5) 検証（CIゲート）
- SSA 保持（Phi 導入後の整合）
- 意味保存（before/after 等価）
@ -36,8 +36,9 @@
- 算術/比較の BoxCall 化（最適化効率低下を避け据え置き）
完了基準
- トグル ON でスモークとベンチが基準を満たす
- VM/JIT ともに fast‑path が発火し、BoxCall 経路での最適化が確認できる
- Core‑13 を既定ONでスモーク/ベンチが基準達成
- 旧命令（ArrayGet/ArraySet/RefGet/RefSet/Unary/Load/Store）が最終MIRに出現しない
- VM/JIT ともに BoxCall fast‑path/vtable の発火が確認できる
関連
- TECHNICAL_SPEC.md（詳細仕様）

57
docs/development/roadmap/phases/phase-11.8_mir_cleanup/README.md
View File

@ -1,9 +1,13 @@
# Phase 11.8: MIR命令セット究極整理 - Core-13への道
# Phase 11.8: MIR命令セット究極整理 - Core‑13 で統一する
## 🎯 概要
ChatGPT5さんの深い洞察「**MIRは接着剤、Boxが世界**」を実現する究極のMIR整理。
現在の26命令 → Core-15 → Core-14（Phase 12）→ **Core-13（最終目標）**への段階的削減。
現在の26（拡張版）→ Core‑15 → Core‑14（Phase 12）→ **Core‑13（最終決定・固定）**。
決定（2025‑09‑04）
- 目標を「Core‑13」に固定し、移行フラグを既定ONにする。
- 以降の最適化/検証/CIは Core‑13 を前提とする（旧命令は禁制）。
### 基本哲学
@ -13,7 +17,7 @@ ChatGPT5さんの深い洞察「**MIRは接着剤、Boxが世界**」を実現
## 📊 現状分析
### 現在のCore-15（Phase 11.7）
### 現行（移行前の参考）Core‑15（Phase 11.7）
```
基本演算(5): Const, UnaryOp, BinOp, Compare, TypeOp
@ -24,7 +28,7 @@ Box(3): NewBox, BoxCall, PluginInvoke
外部(1): ExternCall
```
### Core-14（Phase 12予定）
### Core‑14（Phase 12の中間目標）
```
基本演算(5): Const, UnaryOp, BinOp, Compare, TypeOp
@ -35,9 +39,9 @@ Box(2): NewBox, BoxCall ← PluginInvoke統合
外部(1): ExternCall
```
## 🚀 Core-13への道筋
## 🚀 Core‑13（最終形）への道筋（実行計画）
### Step 1: 配列操作のBoxCall統合（Core-14 → Core-12）
### Step 1: 配列操作のBoxCall統合（Core‑14 → Core‑12）
```mir
// 現在
@ -49,12 +53,12 @@ ArraySet %arr, %idx, %val
BoxCall %arr, "set", [%idx, %val]
```
**実装方針**:
実装方針:
- Optimizer: ArrayGet/ArraySet → BoxCall 変換
- VM: 高頻度パスは内部最適化維持
- JIT: 既知型の場合はインライン展開
### Step 2: Load/Store の再考（Core-12 → Core-11）
### Step 2: Load/Store の再考（Core‑12 → Core‑11）
**SSAの威力を活かす**:
- ローカル変数のLoad/Store → SSA変数で代替
@ -70,7 +74,7 @@ Store %slot, %value
%val = %value // 直接参照（Copyも実質不要）
```
### Step 3: 定数統合とUnaryOp簡素化（Core-11 → Core-13）
### Step 3: 定数統合とUnaryOp簡素化（Core‑11 → Core‑13）
**Const統合案**:
```mir
@ -90,7 +94,7 @@ Const { type: Type, value: u64 } // 全て64bitに収める
- Not → BinOp(Xor, x, 1)
- BitNot → BinOp(Xor, x, -1)
## 🎯 最終形：Core-13
## 🎯 最終形：Core‑13（固定セット・CI基準）
```yaml
定数(1):
@ -119,6 +123,24 @@ Const { type: Type, value: u64 } // 全て64bitに収める
合計: 13命令
```
移行スイッチ（既定ON）と検証
- 環境変数（デフォルトON）
- NYASH_MIR_CORE13=1（Core‑13一括）
- 診断: NYASH_OPT_DIAG_FORBID_LEGACY=1（旧命令が最終MIRに残ったらエラー）
- ビルダー/最適化の方針
- Builder: ArrayGet/ArraySet・RefGet/RefSet を emit せず最初から BoxCall を出す
- Optimizer: 既存の Array/Ref→BoxCall 正規化パスを保持（保険）
- UnaryOp→BinOp 正規化は常時ON（簡易変換）
- Load/Store はSSA利用で極力抑止（最終MIRから排除が目標）
- VM/JIT
- BoxCall fast‑path/vtable を維持し、get/set は型特化とWriteBarrierを維持
- PluginInvoke はMIRから排除（必要経路は BoxCall→VM側ABI判定）
CI/テスト
- Core‑13固定の数・名前検査を `instruction_introspection.rs` に追加（Core‑15検査は保持しつつ非推奨）
- 旧命令（ArrayGet/ArraySet/RefGet/RefSet/Load/Store/UnaryOp）が最終MIRに残らないことをゲート
- 代表スモーク（配列/参照/extern/await）は VM/JIT で同値性を確認
## 💡 なぜCore-13で十分なのか
### 1. チューリング完全性の保証
@ -150,18 +172,23 @@ weak.get() → BoxCall(weak, "get", [])
- 配列要素 → BoxCall
- 真のメモリアクセスはBoxの中に隠蔽
## 📋 実装ロードマップ
## 📋 実装ロードマップ（確定版）
### ステータス（進捗メモ）
- 実装済み（トグルONで有効化）
- Optimizer: ArrayGet/Set・RefGet/Set → BoxCall 変換（`NYASH_MIR_ARRAY_BOXCALL`, `NYASH_MIR_REF_BOXCALL`, `NYASH_MIR_CORE13`）
- VM: BoxCall(setField)のWriteBarrier、Array/Instanceの軽量fast-path（by-name/slot併用）
- 管理棟: 主要なMIR/GC/Optimizerフラグを `config::env` に集約
- 決定/実行（今回）
- Core‑13を既定ON（nyash.toml [env] 推奨値）
- 旧命令禁止の診断を既定ON
- BuilderのArray/Ref出力をBoxCallに変更（emit抑止）
- Unary→BinOpを常時変換
- 未了/次段
- JIT: BoxCall fast-path の inlining（bounds/Barrier含む）
- ベンチ追加とCIゲート（array/field/arithmetic_loop）
- フィールドfast-pathのslot化（name→slot化の検討）
- 直env参照の残りの段階移行（ログ用途は後段）
- JIT: BoxCall fast‑path の inlining（bounds/Barrier含む）
- ベンチとCIゲート（array/field/arithmetic_loop）
- InstanceのgetField/setFieldのslot化（name→slotの検討）
- 直env参照の段階移行（ログ用途は後段）
### Phase 11.8.1: 準備と分析（1週間）

37
docs/development/roadmap/phases/phase-11.8_mir_cleanup/TECHNICAL_SPEC.md
View File

@ -1,4 +1,15 @@
# Phase 11.8 技術仕様書：Core-13 MIR命令セット
# Phase 11.8 技術仕様書：Core‑13 MIR命令セット（既定ON）
## 0. 変換スイッチとルーティング（Core‑13 既定ON）
推奨既定（nyash.toml の [env]）
- NYASH_MIR_CORE13=1 … Core‑13 一括ON（Array/Ref→BoxCall 等を内包）
- NYASH_OPT_DIAG_FORBID_LEGACY=1 … 旧命令が最終MIRに残ったらエラー
Builder/MIR 生成
- Builder は ArrayGet/ArraySet/RefGet/RefSet/PluginInvoke を emit せず、最初から BoxCall/Call/ExternCall に正規化する。
- Optimizer は保険として既存の正規化パスを維持（二重化で確実性を上げる）。
## 1. ArrayGet/ArraySet → BoxCall 統合仕様
@ -83,7 +94,7 @@ fn lower_boxcall(builder: &mut IRBuilder, ...) {
}
```
## 2. Load/Store 削減仕様
## 2. Load/Store 削減仕様（SSA最優先）
### 2.1 SSA変数活用の最大化
@ -131,7 +142,7 @@ BoxCall %obj, "setField", ["field", %new_val]
- **C FFI境界**: 外部関数とのやり取り
- **最適化中間状態**: Phi導入前の一時的使用
## 3. Const統合仕様
## 3. Const統合仕様（設計）
### 3.1 統一表現
@ -187,7 +198,7 @@ impl MirConst {
}
```
## 4. パフォーマンス保証
## 4. パフォーマンス保証（CI基準）
### 4.1 ベンチマーク項目
@ -218,25 +229,13 @@ const REQUIRED_OPTIMIZATIONS: &[&str] = &[
];
```
## 5. 移行戦略
## 5. 移行戦略（段階→固定）
### 5.1 段階的有効化
```rust
// 環境変数による制御
pub struct MirConfig {
// Phase 11.8.1
pub array_to_boxcall: bool, // NYASH_MIR_ARRAY_BOXCALL=1
// Phase 11.8.2
pub eliminate_load_store: bool, // NYASH_MIR_NO_LOAD_STORE=1
// Phase 11.8.3
pub unified_const: bool, // NYASH_MIR_UNIFIED_CONST=1
// Phase 11.8.4
pub core_13_strict: bool, // NYASH_MIR_CORE13=1
}
// 実装上は env トグルを残しつつ、CI/既定は CORE13=1 / FORBID_LEGACY=1 とする。
```
### 5.2 互換性レイヤー
@ -354,4 +353,4 @@ impl Core13Error {
---
*この仕様に従い、MIRを「最小の接着剤」として純化し、Boxに「無限の可能性」を委ねる*
*この仕様に従い、MIRを「最小の接着剤」として純化し、Boxに「無限の可能性」を委ねる*

336
docs/development/roadmap/phases/phase-12.7/README.md
View File

@ -4,16 +4,32 @@
## 📋 統合概要
Phase 12.7は2つの革命的な改革の融合です：
Phase 12.7は3つの革命的な改革の段階的実装です：
### 1. 文法改革（Language Reform）
- 予約語15個への削減（peek, birth統一）
### Phase 12.7-A: 基礎文法改革（✅ 実装済み）
- 予約語15個への削減（peek, birth, continue統一）
- peek構文による分岐革命
- フィールド宣言の明示化
- 極限糖衣構文（|>, ?., /:）
- continue文の追加
- ?演算子（Result伝播）
- Lambda式（fn文法）
- フィールド型アノテーション（field: TypeBox）
### 2. 圧縮記法（Compression Notation）
- ANCP（48%削減）
### Phase 12.7-B: ChatGPT5糖衣構文（🔄 実装中）
- パイプライン演算子（|>）
- セーフアクセス（?.）とデフォルト値（??）
- デストラクチャリング（{x,y}, [a,b,...]）
- 増分代入（+=, -=, *=, /=）
- 範囲演算子（0..n）
- 高階関数演算子（/:map, \:filter, //:reduce）
- ラベル付き引数（key:value）
**🎯 重要な設計方針：**
- **使いたい人が使いたい糖衣構文を選択可能**
- **すべての糖衣構文は元のNyashコードに可逆変換可能**
- **明示性と超圧縮の両立** - 用途に応じて使い分け
### Phase 12.7-C: ANCP圧縮記法（📅 計画中）
- ANCP v1.0（48%削減）
- 極限糖衣構文（75%削減）
- 融合記法（90%削減）
- 可逆フォーマッター完備
@ -34,9 +50,70 @@ Phase 12.7は2つの革命的な改革の融合です：
## 🌟 革命的インパクト
### 数値で見る効果
### Phase 12.7-A: 実装済み機能（2025-09-04）
```nyash
// 通常のNyash（約80文字）
# Peek式 - パターンマッチング風分岐
local result = peek status {
"success" => 200,
"error" => 500,
"pending" => 102,
else => 404
}
# Continue文 - ループ制御
loop(i < 100) {
if i % 2 == 0 {
continue # 偶数スキップ
}
process(i)
}
# ?演算子 - Result伝播
local config = readFile("app.json")? # エラーなら早期return
local version = parseJSON(config)?.get("version")?
# Lambda式
local double = fn(x) { x * 2 }
array.map(fn(x) { x * x })
```
### Phase 12.7-B: ChatGPT5糖衣構文（実装予定）
```nyash
# パイプライン演算子（|>）
local result = data
|> normalize()
|> transform()
|> validate()?
|> finalize()
# セーフアクセス（?.）とデフォルト値（??）
local name = user?.profile?.name ?? "Guest"
# デストラクチャリング
let {x, y} = point
let [first, second, ...rest] = array
# 増分代入
count += 1
total *= 1.1
# 高階関数演算子（記号による簡潔表現）
evens = nums \: {$_%2==0} # filter: 偶数のみ
squares = nums /: {$_*$_} # map: 二乗
sum = nums // {$1+$2} # reduce: 合計
# ラベル付き引数
Http.request(
url: "/api/data",
method: "POST",
headers: {"Content-Type": "application/json"},
body: payload
)
```
### Phase 12.7-C: ANCP記法（計画中）
```nyash
// 通常のNyash（約100文字）
box NyashCompiler {
compile(source) {
local ast = me.parse(source)
@ -45,13 +122,21 @@ box NyashCompiler {
}
}
// ANCP記法（約40文字） - 50%削減！
$NyashCompiler{compile(src){l ast=m.parse(src)l mir=m.lower(ast)r m.codegen(mir)}}
// ChatGPT5糖衣構文適用（約60文字） - 40%削減！
box NyashCompiler {
compile(source) {
return source |> me.parse |> me.lower |> me.codegen
}
}
// ANCP記法（約30文字） - 70%削減！
$NyashCompiler{compile(s){r s|>m.parse|>m.lower|>m.codegen}}
// 夢の組み合わせ：
// Phase 15: 80k行 → 20k行（75%削減）
// + ANCP: 20k行 → 10k行相当（さらに50%削減）
// = 最終的に87.5%削減！世界一小さい実用コンパイラ！
// + 糖衣構文: 20k行 → 12k行（40%削減）
// + ANCP: 12k行 → 6k行相当（50%削減）
// = 最終的に92.5%削減！世界一小さい実用コンパイラ！
```
### AIコンテキスト革命
@ -88,19 +173,30 @@ $NyashCompiler{compile(src){l ast=m.parse(src)l mir=m.lower(ast)r m.codegen(mir)
## 📊 主要成果物
### 文法改革
### Phase 12.7-A: 基礎文法改革（✅ 完了）
- ✅ 予約語15個確定（peek, birth, continue追加）
- ✅ peek構文設計完了
- ✅ フィールド宣言構文確定
- 🔄 パーサー実装（Phase 12.7-A）
- ✅ peek構文実装完了
- ✅ continue文実装完了
- ✅ ?演算子（Result伝播）実装完了
- ✅ Lambda式（fn構文）実装完了
- ✅ フィールド型アノテーション実装完了
### AI統合最適化
- ✅ ANCP v1.0完成（48%圧縮）
### Phase 12.7-B: ChatGPT5糖衣構文（🔄 実装中）
- 📅 パイプライン演算子（|>）
- 📅 セーフアクセス（?.）とデフォルト値（??）
- 📅 デストラクチャリング（パターン束縛）
- 📅 増分代入演算子（+=, -=, *=, /=）
- 📅 範囲演算子（..）
- 📅 高階関数演算子（/:, \:, //）
- 📅 ラベル付き引数
### Phase 12.7-C: ANCP圧縮記法（📅 計画中）
- ✅ ANCP v1.0仕様完成（48%圧縮）
- ✅ 極限糖衣構文設計（75%圧縮）
- ✅ 融合記法考案（90%圧縮）
- ✅ 可逆フォーマッター仕様完成
- 🔄 統合ツール実装中
- 📅 VSCode拡張（計画中）
- 📅 統合ツール実装
- 📅 VSCode拡張
## 🔧 技術的アプローチ
@ -126,32 +222,73 @@ loop → L # ループ
override → O # オーバーライド
```
### 🔄 可逆変換保証
**すべての糖衣構文は双方向変換可能：**
```bash
# フォーマッターによる自由な変換
nyash format --style=explicit code.nyash # 明示的記法へ
nyash format --style=sugar code.nyash # 糖衣構文へ
nyash format --style=ancp code.nyash # 極限圧縮へ
```
**同じコードの3つの表現：**
```nyash
# 明示的（学習・デバッグ用）
result = users.filter(function(u) { return u.active }).map(function(u) { return u.name })
# 糖衣構文（通常開発用）
result = users \: {$_.active} /: {$_.name}
# ANCP圧縮（AI協働用）
r=u\:_.a/:_.n
```
### 実装優先順位
#### Phase 1: 最小実装（1週間）
#### Phase 12.7-B: ChatGPT5糖衣構文（実装中）
**優先度1: 即効性の高い演算子（1週間）**
```rust
// tokenizer.rs に追加
PIPE, // |> パイプライン
SAFE_ACCESS, // ?. セーフアクセス
NULL_COALESCE, // ?? デフォルト値
PLUS_ASSIGN, // += 増分代入
MINUS_ASSIGN, // -= 減分代入
// etc...
```
**優先度2: パイプラインとセーフアクセス（2週間）**
```nyash
// パイプライン: x |> f → f(x)
// セーフアクセス: x?.y → x != null ? x.y : null
// デフォルト値: x ?? y → x != null ? x : y
```
**優先度3: デストラクチャリング（3週間）**
```nyash
// オブジェクト: let {x, y} = point
// 配列: let [a, b, ...rest] = array
// MIR変換: 複数のLoad命令に展開
```
#### Phase 12.7-C: ANCP圧縮記法（計画中）
**Phase 1: 基本トランスコーダー（1週間）**
```rust
// 20語の固定辞書で開始
pub struct AncpTranscoder {
mappings: HashMap<&'static str, &'static str>,
}
impl AncpTranscoder {
pub fn encode(&self, nyash: &str) -> String {
// シンプルな置換から開始
}
pub fn decode(&self, ancp: &str) -> String {
// 逆変換
}
sugar_enabled: bool, // 糖衣構文も含めて圧縮
}
```
#### Phase 2: スマート変換（2週間）
**Phase 2: スマート変換（2週間）**
- コンテキスト認識（文字列内は変換しない）
- 空白・コメント保持
- エラー位置マッピング
#### Phase 3: ツール統合（2週間）
**Phase 3: ツール統合（2週間）**
- VSCode拡張（ホバーで元のコード表示）
- CLIツール（--format=ancp オプション）
- スモークテスト自動ANCP化
@ -165,48 +302,137 @@ impl AncpTranscoder {
## 📅 実施スケジュール
### 即座に開始可能な理由
1. **独立性**: 他のフェーズの完了を待つ必要なし
2. **低リスク**: 既存コードに影響しない追加機能
3. **高効果**: すぐにAI開発効率が向上
### Phase 12.7-A（✅ 完了）
- ✅ peek式、continue文、?演算子、Lambda式
- ✅ フィールド型アノテーション
- ✅ birth統一、予約語15個確定
### マイルストーン
### Phase 12.7-B（🔄 実装中）
#### Week 1-2: 基本演算子
- パイプライン演算子（|>）
- セーフアクセス（?.）とデフォルト値（??）
- 増分代入演算子（+=, -=等）
#### Week 3-4: 高度な構文
- デストラクチャリング（{}, []）
- 範囲演算子（..）
- 高階関数演算子（/:, \:, //）
#### Week 5: 統合・最適化
- ラベル付き引数
- MIR変換最適化
- テストスイート完成
### Phase 12.7-C（📅 計画中）
- **Week 1**: 基本トランスコーダー実装
- **Week 2**: パーサー統合・往復テスト
- **Week 3**: ツール実装（CLI/VSCode）
- **Week 4**: AI連携・最適化
## 🎨 糖衣構文の使い分けガイド
### 用途別推奨レベル
| 用途 | 推奨記法 | 理由 |
|------|----------|------|
| 学習・チュートリアル | 明示的 | 動作が明確 |
| 通常の開発 | 基本糖衣 | バランスが良い |
| コードレビュー | 明示的〜基本糖衣 | 可読性重視 |
| AI協働開発 | 全糖衣〜ANCP | コンテキスト最大化 |
| セルフホスティング | ANCP | 極限圧縮必須 |
### プロジェクト設定例
```toml
# nyash.toml
[syntax]
# none: 糖衣構文なし（明示的のみ）
# basic: 基本的な糖衣構文（+=, ?., ??）
# full: すべての糖衣構文（高階関数演算子含む）
# ancp: ANCP記法も許可
sugar_level = "full"
# 高階関数演算子の有効化
high_order_operators = true
# 可逆変換の検証（保存時に自動チェック）
verify_reversible = true
```
## 💡 期待される成果
### 定量的
- トークン削減率: 50-70%（目標）
- AI開発効率: 2-3倍向上
- コンテキスト容量: 2倍に拡大
- **Phase 12.7-B（糖衣構文）**: コード削減率 40-50%
- **Phase 12.7-C（ANCP）**: さらに50-60%削減
- **総合効果**: 最大92.5%のコード削減
- **AI開発効率**: 3-5倍向上
- **コンテキスト容量**: 10倍に拡大
### 定性的（追加）
- **選択の自由**: 開発者が好きな記法を選べる
- **可逆性保証**: いつでも別の形式に変換可能
- **段階的導入**: プロジェクトごとに糖衣レベルを調整
### 定性的
- AIがNyash全体を「理解」できる
- 人間も慣れれば読み書き可能
- 自動整形の副次効果
- **可読性向上**: パイプライン演算子で処理フローが明確に
- **安全性向上**: セーフアクセスでnullエラー激減
- **表現力向上**: 高階関数演算子で関数型プログラミングが簡潔に
- **AIとの親和性**: より多くのコードをAIが一度に理解可能
- **学習曲線**: 他言語経験者にとって馴染みやすい構文
## 🌟 夢の実現
### Phase 15との究極コンボ
```nyash
// セルフホスティングコンパイラ（ANCP記法）
// たった5行で完全なコンパイラ！
$Compiler{
c(s){
r m.gen(m.low(m.parse(s)))
// 通常のセルフホスティングコンパイラ
box Compiler {
compile(source) {
local ast = me.parser.parse(source)
local mir = me.lowerer.transform(ast)
local code = me.backend.generate(mir)
return code
}
}
// ChatGPT5糖衣構文適用版
box Compiler {
compile(source) {
return source
|> me.parser.parse
|> me.lowerer.transform
|> me.backend.generate
}
}
// ANCP記法（究極形態）
$Compiler{compile(s){r s|>m.parser.parse|>m.lowerer.transform|>m.backend.generate}}
```
これが「世界一美しい箱」の究極形態にゃ！
### 将来の拡張
- **ANCP v2**: 文脈依存の高度な圧縮
- **AI専用方言**: モデル特化の最適化
- **バイナリANCP**: さらなる圧縮
### ChatGPT5糖衣構文によるコード例の変革
```nyash
# Before: ネストした関数呼び出し（読みづらい）
result = finalize(validate(transform(normalize(data))))
# After: パイプライン（処理の流れが明確）
result = data |> normalize |> transform |> validate |> finalize
# Before: null安全でない（実行時エラーの危険）
name = user.profile.name
# After: セーフアクセス（null安全）
name = user?.profile?.name ?? "Guest"
# Before: 冗長な配列処理
evens = []
for x in numbers {
if x % 2 == 0 {
evens.push(x * x)
}
}
# After: 高階関数演算子（簡潔で宣言的）
evens = numbers \: {$_%2==0} /: {$_*$_}
```
## 🚀 なぜ今すぐ始めるべきか

294
docs/development/roadmap/phases/phase-12.7/ancp-specs/chatgpt5-sugar-syntax-spec.md Normal file
View File

@ -0,0 +1,294 @@
# ChatGPT5糖衣構文仕様書
**Phase 12.7-B実装仕様（2025-09-04作成・更新）**
## 📋 概要
ChatGPT5アドバイザーから提案された糖衣構文を統合し、予約語を増やさずに表現力を劇的に向上させる。
## 🎯 設計原則
1. **予約語を増やさない** - 演算子・記号で実現
2. **可逆変換** - 糖衣構文⇔通常構文の完全な相互変換
3. **曖昧性ゼロ** - パース時の明確な優先順位
4. **MIR13への直接変換** - Phase 15セルフホスティングを意識
5. **使いたい人が使いたい構文を選択** - 強制ではなく選択
6. **超圧縮対応** - AIコンテキスト最大化のための極限記法
## 🔧 実装仕様
### 1. パイプライン演算子（|>）
**構文**
```ebnf
PipeExpr = Expr ( "|>" CallExpr )*
```
**変換規則**
```nyash
# 糖衣構文
x |> f |> g(y) |> h
# デシュガー後
h(g(f(x), y))
```
**MIR変換**
- 一時変数を使った直線的な命令列に変換
- 最適化で一時変数を削減
### 2. セーフアクセス（?.）とデフォルト値（??）
**構文**
```ebnf
SafeAccess = Primary ( ("?." | ".") Identifier )*
NullCoalesce = SafeAccess ( "??" SafeAccess )*
```
**変換規則**
```nyash
# 糖衣構文
user?.profile?.name ?? "Guest"
# デシュガー後
local t0, t1, t2
if user != null {
t0 = user.profile
if t0 != null {
t1 = t0.name
t2 = t1
} else {
t2 = "Guest"
}
} else {
t2 = "Guest"
}
```
### 3. デストラクチャリング
**構文**
```ebnf
DestructLet = "let" ( ObjectPattern | ArrayPattern ) "=" Expr
ObjectPattern = "{" Identifier ("," Identifier)* "}"
ArrayPattern = "[" Identifier ("," Identifier)* ("," "..." Identifier)? "]"
```
**変換規則**
```nyash
# オブジェクトパターン
let {x, y} = point
# →
local x = point.x
local y = point.y
# 配列パターン
let [a, b, ...rest] = array
# →
local a = array.get(0)
local b = array.get(1)
local rest = array.slice(2)
```
### 4. 増分代入演算子
**構文**
```ebnf
CompoundAssign = LValue ("+=" | "-=" | "*=" | "/=" | "%=") Expr
```
**変換規則**
```nyash
# 糖衣構文
count += 1
arr[i] *= 2
# デシュガー後
count = count + 1
arr.set(i, arr.get(i) * 2)
```
### 5. 範囲演算子（..）
**構文**
```ebnf
Range = Expr ".." Expr
```
**変換規則**
```nyash
# 糖衣構文
for i in 0..n {
print(i)
}
# デシュガー後
local _range = new RangeBox(0, n)
for i in _range {
print(i)
}
```
### 6. 高階関数演算子
**構文（3つの選択肢）**
```ebnf
# 演算子形式（超圧縮向け）
MapOp = Expr "/:" LambdaExpr
FilterOp = Expr "\:" LambdaExpr
ReduceOp = Expr "//" LambdaExpr
# メソッド形式（バランス型）
MapMethod = Expr ".map" "(" LambdaExpr ")"
FilterMethod = Expr ".filter" "(" LambdaExpr ")"
ReduceMethod = Expr ".reduce" "(" LambdaExpr ["," InitValue] ")"
```
**変換規則（すべて等価）**
```nyash
# 1. 明示的形式（学習・デバッグ向け）
evens = users.filter(function(u) { return u.age >= 18 })
.map(function(u) { return u.name })
# 2. 糖衣構文メソッド形式（通常開発向け）
evens = users.filter{$_.age >= 18}.map{$_.name}
# 3. 糖衣構文演算子形式（圧縮重視）
evens = users \: {$_.age>=18} /: {$_.name}
# 4. ANCP極限形式（AI協働向け）
e=u\:_.a>=18/:_.n
```
**暗黙変数**
- `$_` - 単一引数の暗黙変数
- `$1`, `$2` - 複数引数の位置指定
- 省略時の`_.`プロパティアクセス（ANCP）
### 7. ラベル付き引数
**構文**
```ebnf
LabeledArg = Identifier ":" Expr
Call = Identifier "(" (LabeledArg | Expr) ("," (LabeledArg | Expr))* ")"
```
**変換規則**
```nyash
# 糖衣構文
Http.request(
url: "/api",
method: "POST",
body: data
)
# デシュガー後
local _args = new MapBox()
_args.set("url", "/api")
_args.set("method", "POST")
_args.set("body", data)
Http.request(_args)
```
## 📊 優先順位表
| 優先度 | 演算子 | 結合性 |
|--------|--------|--------|
| 1 | `?.` | 左結合 |
| 2 | `??` | 左結合 |
| 3 | `\>` | 左結合 |
| 4 | `/:` `\:` `//` | 左結合 |
| 5 | `+=` `-=` etc | 右結合 |
| 6 | `..` | なし |
## 🔄 実装段階
### Stage 1: トークナイザー拡張
- 新しいトークンタイプの追加
- 演算子の最長一致ルール
### Stage 2: パーサー拡張
- 演算子優先順位の実装
- デシュガー変換の実装
### Stage 3: MIR変換
- 効率的なMIR命令列への変換
- 最適化パスの追加
### Stage 4: テスト・ドキュメント
- 包括的なテストケース
- エラーメッセージの改善
- チュートリアル作成
## 🎨 使い分けガイドライン
### 用途別推奨記法
```nyash
# 同じ処理の4段階表現
# 1. 学習用（超明示的）- 60文字
local result = []
for item in data {
if item.isValid() {
result.push(transform(normalize(item)))
}
}
# 2. 通常開発（メソッド糖衣）- 45文字
result = data.filter{$_.isValid()}
.map{$_ |> normalize |> transform}
# 3. 圧縮開発（演算子糖衣）- 35文字
result = data \: {$_.isValid()}
/: {$_ |> normalize |> transform}
# 4. AI協働（ANCP極限）- 20文字
r=d\:_.isValid()/:_|>n|>t
```
**最大67%のコード削減を実現！**
### 可逆変換の保証
```bash
# どの形式からでも相互変換可能
nyash format --from=explicit --to=sugar code.nyash
nyash format --from=sugar --to=ancp code.nyash
nyash format --from=ancp --to=explicit code.nyash
```
## 🚀 Phase 15との相乗効果
セルフホスティングコンパイラでの活用：
```nyash
box MirBuilder {
// 1. 明示的（デバッグ時）
buildExpr(ast) {
local desugared = me.desugar(ast)
local lowered = me.lower(desugared)
local checked = me.typeCheck(lowered)
return me.optimize(checked)
}
// 2. パイプライン糖衣（通常開発）
buildExpr(ast) {
return ast
|> me.desugar
|> me.lower
|> me.typeCheck
|> me.optimize
}
// 3. ANCP極限（AIとの共同作業）
buildExpr(a){r a|>m.desugar|>m.lower|>m.typeCheck|>m.optimize}
}
```
## 💡 重要な設計哲学
**「糖衣構文は使いたい人が使いたいものを選ぶ」**
- 強制ではなく選択
- プロジェクトごとに設定可能
- チームメンバーごとに表示形式を変更可能
- **重要なのは可逆変換できること**
これにより、Nyashは初心者からAI協働まで、あらゆるレベルの開発者に最適な記法を提供します。

126
docs/development/roadmap/phases/phase-15/preparation-summary.md Normal file
View File

@ -0,0 +1,126 @@
# Phase 15 セルフホスティング準備まとめ
作成日: 2025-09-03
作成者: Claude (Gemini・Codex協議結果統合)
## 専門家の技術評価まとめ
### Gemini先生の分析
- **実現可能性**: MIR 13命令で十分実現可能、BoxCallの設計が鍵
- **推奨バックエンド**: Cranelift + lld（開発速度・安全性・成熟度）
- **コード削減**: 75%削減は現実的（Arc<Mutex>→GC、動的ディスパッチ）
- **段階的アプローチ**: まず動くものを作り、後から最適化
### Codex先生の具体設計
- **BoxCall実装**: 隠れクラス（Shape）+ vtable + セレクタインターン
- **JIT最適化**: IC/PIC、Shapeガード、devirtualization
- **ブートストラップ**: c0→c1→c1'の具体手順、決定論的ビルド
- **並列化**: GCでロック削減、フェーズ境界でバリア同期
## 今すぐ着手可能な準備作業
### 1. BoxCall設計の詳細化（最優先）
```nyash
// BoxCall命令のメタデータ設計
BoxCall {
dst: ValueId,
receiver: ValueId,
selector: Sel(u32), // インターン化されたメソッド名
args: Vec<ValueId>,
flags: {
op_kind: OpKind, // Get/Set/Invoke/Convert
target_type: Option<TypeId>,
site_id: u32, // IC/PIC管理用
}
}
```
### 2. 最小言語サブセット定義
**必須機能**:
- 基本型（Integer, String, Bool, Array, Map）
- Box定義（box, birth, field, method）
- 制御構造（if, loop, return）
- 関数定義（static/instance method）
- エラー処理（Result型）
**初期は省略**:
- ジェネリクス
- trait/interface
- マクロ
- 非同期（async/await）
### 3. セレクタインターン実装
```rust
// src/runtime/selector_intern.rs
pub struct SelectorInterner {
string_to_id: HashMap<String, Sel>,
id_to_string: Vec<String>,
}
```
### 4. TypeDesc/VTable構造定義
```rust
// crates/nyrt/src/types.rs
pub struct TypeDesc {
id: TypeId,
vtable: *const VTable,
shape_epoch: u32,
}
pub struct VTable {
get: fn(recv: *mut BoxHdr, sel: Sel) -> Value,
set: fn(recv: *mut BoxHdr, sel: Sel, val: Value),
invoke: fn(recv: *mut BoxHdr, sel: Sel, args: &[Value]) -> Value,
// ... 他のメソッド
}
```
### 5. MIR最適化パス準備
- BoxCallのdevirtualization検出
- Shapeガード生成
- IC/PICサイト管理
## 実装ロードマップ
### Phase 1: 基盤整備（1-2ヶ月）
1. BoxCall命令の完全定義
2. セレクタインターンシステム
3. TypeDesc/VTable基盤
4. 最小サブセット言語仕様
### Phase 2: プロトタイプ（2-3ヶ月）
1. 素朴なBoxCall実装（文字列ディスパッチ）
2. Cranelift統合
3. 最小コンパイラ（c0.5）実装
### Phase 3: 最適化（2-3ヶ月）
1. Shape/vtableハイブリッド
2. IC/PIC実装
3. devirtualization
### Phase 4: セルフホスティング（2-3ヶ月）
1. c1実装（Nyashで20,000行）
2. ブートストラップ検証
3. 性能チューニング
## 技術的リスクと対策
### リスク
1. BoxCallの性能オーバーヘッド
2. ブートストラップの決定論性
3. デバッグの困難さ
### 対策
1. 早期にIC/PIC実装で緩和
2. SOURCE_DATE_EPOCH等で環境統一
3. MIRダンプ比較ツール整備
## 成功の指標
- c1がc1'を正しくコンパイル（バイナリ一致）
- 80,000行→20,000行達成
- VM比2倍以上の性能（Cranelift JIT）
## 次のアクション
1. BoxCall詳細設計ドキュメント作成
2. セレクタインターン実装開始
3. 最小サブセット言語仕様確定
4. MIRへのBoxCallメタデータ追加

60
docs/papers/active/paper-a-mir13-ir-design/data/mir13-final.md Normal file
View File

@ -0,0 +1,60 @@
# MIR13 (Core-13) Final Instruction Set
## The 13 Instructions
### 1. 値・計算 (3命令)
- **Const**: 定数値のロード
- **BinOp**: 二項演算（算術、論理、ビット演算すべて）
- **Compare**: 比較演算（==, !=, <, >, <=, >=）
### 2. 制御フロー (4命令)
- **Jump**: 無条件ジャンプ
- **Branch**: 条件分岐
- **Return**: 関数からの戻り
- **Phi**: SSA形式での値の合流
### 3. 呼び出し (3命令)
- **Call**: 通常の関数呼び出し
- **BoxCall**: Boxメソッド呼び出し（配列、オブジェクト、すべてのデータ操作）
- **ExternCall**: 外部関数呼び出し（システムコール、プラグイン等）
### 4. メタ操作 (3命令)
- **TypeOp**: 型関連操作（型チェック、キャスト）
- **Safepoint**: GCセーフポイント
- **Barrier**: メモリバリア
## 削除された命令とその統合先
| 削除された命令 | 統合方法 |
|--------------|---------|
| Load/Store | BoxCallまたはCall（変数もBoxとして扱う） |
| UnaryOp | BinOp（例：-x → 0-x, !x → x XOR true） |
| ArrayGet/ArraySet | BoxCall |
| NewBox | BoxCall（コンストラクタ呼び出し） |
| FunctionNew | Const（関数も値） |
| RefNew/RefGet/RefSet | BoxCall |
| TypeCheck/Cast | TypeOp |
| Debug/Print | ExternCall |
| Copy/Nop | 不要（最適化で除去） |
## 設計の革新性
### 1. 変数アクセスの統一
すべての変数アクセスが関数呼び出しとして表現される：
```mir
// 従来: %1 = Load %x
%1 = Call @get_local "x"
// 従来: Store %y, %1
Call @set_local "y" %1
```
### 2. Everything is Box の究極形
- 変数もBox
- 関数もBox（Constで表現）
- すべての操作がBoxCall
### 3. 実用性とのバランス
- Safepointでガベージコレクションをサポート
- Barrierで並行性を考慮
- ExternCallで拡張性を確保

305
docs/reference/language/LANGUAGE_REFERENCE_2025.md
View File

@ -1,6 +1,6 @@
# 🚀 Nyash Language Reference 2025
**最終更新: 2025年8月27日 - フィールド可視性導入！`public`/`private`ブロック構文決定！**
**最終更新: 2025年9月4日 - Phase 12.7実装済み機能の正確な反映**
## 📖 概要
@ -11,62 +11,54 @@ Rust製インタープリターによる高性能実行と、直感的な構文
## 🔤 **1. 予約語・キーワード完全リスト**
### **コア言語**
### **Phase 12.7で確定した15個の予約語**
| 予約語 | 用途 | 例 |
|-------|------|---|
| `box` | クラス定義 | `box MyClass { }` |
| `static` | 静的Box・関数定義 | `static box Main { }` |
| `interface` | インターフェース定義 | `interface Comparable { }` |
| `from` | デリゲーション指定 | `box Child from Parent { }` |
| `new` | オブジェクト生成 | `new ConsoleBox()` |
| `me`/`this` | 自己参照 | `me.field = value` |
### **変数・スコープ**
| 予約語 | 用途 | 例 |
|-------|------|---|
| `me` | 自己参照（thisの代わり） | `me.field = value` |
| `local` | ローカル変数宣言 | `local x, y = 10` |
| `outbox` | 所有権移転変数 | `outbox result = compute()` |
| `global` | グローバル変数 | `global CONFIG = "dev"` |
| `public` | 公開フィールド修飾子 | `public field: TypeBox` |
| `private` | 非公開フィールド修飾子 | `private field: TypeBox` |
### **制御構文**
| 予約語 | 用途 | 例 |
|-------|------|---|
| `return` | 関数リターン | `return value` |
| `from` | デリゲーション・親メソッド呼び出し | `box Child from Parent` / `from Parent.method()` |
| `birth` | コンストラクタ（統一名） | `birth(param) { }` |
| `static` | 静的Box・関数定義 | `static box Main { }` |
| `if` | 条件分岐 | `if condition { }` |
| `else` | else節 | `else { }` |
| `loop` | ループ（唯一の形式） | `loop(condition) { }` |
| `break` | ループ脱出 | `break` |
| `return` | 関数リターン | `return value` |
| `continue` | ループ継続 | `continue` |
| `peek` | パターンマッチング風分岐 | `peek value { "A" => 1, else => 0 }` |
| `try` | 例外捕獲開始 | `try { }` |
| `interface` | インターフェース定義 | `interface Comparable { }` |
### **論理・演算**
| 予約語 | 用途 | 例 |
### **その他の重要キーワード（予約語ではない）**
| キーワード | 用途 | 例 |
|-------|------|---|
| `override` | 明示的オーバーライド | `override speak() { }` |
| `break` | ループ脱出 | `break` |
| `catch` | 例外処理 | `catch (e) { }` |
| `finally` | 最終処理 | `finally { }` |
| `throw` | 例外発生 | `throw error` |
| `nowait` | 非同期実行 | `nowait future = task()` |
| `await` | 待機・結果取得 | `result = await future` |
| `include` | ファイル取り込み | `include "math.nyash"` |
| `print` | 出力（デバッグ用） | `print("Hello")` |
| `function`/`fn` | 関数定義 | `fn add(a,b) { }` |
| `init` | 初期化ブロック | `init { field1, field2 }` |
| `pack` | 旧コンストラクタ（互換性） | `pack(param) { }` |
| `outbox` | 所有権移転変数 | `outbox result = compute()` |
| `global` | グローバル変数 | `global CONFIG = "dev"` |
| `weak` | 弱参照修飾子 | `weak reference` |
| `using` | 名前空間インポート | `using namespace` |
### **演算子・論理**
| 演算子/キーワード | 用途 | 例 |
|-------|------|---|
| `not` | 論理否定 | `not condition` |
| `and` | 論理積 | `a and b` |
| `or` | 論理和 | `a or b` |
| `true`/`false` | 真偽値 | `flag = true` |
| `null` | null値 | `value = null` |
### **非同期・並行**
| 予約語 | 用途 | 例 |
|-------|------|---|
| `nowait` | 非同期実行 | `nowait future = task()` |
| `await` | 待機・結果取得 | `result = await future` |
### **例外処理**
| 予約語 | 用途 | 例 |
|-------|------|---|
| `try` | 例外捕獲開始 | `try { }` |
| `catch` | 例外処理 | `catch (e) { }` |
| `finally` | 最終処理 | `finally { }` |
| `throw` | 例外発生 | `throw error` |
### **その他**
| 予約語 | 用途 | 例 |
|-------|------|---|
| `function` | 関数定義 | `function add(a,b) { }` |
| `print` | 出力 | `print("Hello")` |
| `include` | ファイル取り込み | `include "math.nyash"` |
---
@ -78,9 +70,9 @@ Rust製インタープリターによる高性能実行と、直感的な構文
```nyash
box ClassName {
# フィールド宣言（Phase 12.7形式）
public field1: TypeBox # 公開フィールド
public field2: TypeBox
field3: TypeBox # デフォルト非公開
field1: TypeBox # フィールド型アノテーション（P0では無視）
field2: TypeBox
field3 # 型なしも可
# コンストラクタ
birth(param1, param2) { # birth構文に統一
@ -94,7 +86,7 @@ box ClassName {
return me.field1 + arg1
}
# デストラクタ
# デストラクタ（fini）
fini() {
print("Cleanup: " + me.field1)
}
@ -104,15 +96,15 @@ box ClassName {
#### **デリゲーションBox**
```nyash
box Child from Parent interface Comparable {
private childField: TypeBox # プライベートフィールド
childField: TypeBox # 追加フィールド
birth(parentParam, childParam) { # birth構文に統一
from Parent.birth(parentParam) # 親コンストラクタ明示呼び出し
me.childField = childParam
}
# メソッド定義
process(data) { # overrideキーワードは廃止
# メソッドオーバーライド
override process(data) { # overrideキーワード必須
local result = from Parent.process(data) # 親メソッド呼び出し
return result + " (Child processed)"
}
@ -127,8 +119,8 @@ box Child from Parent interface Comparable {
#### **Static Box（推奨エントリーポイント）**
```nyash
static box Main {
public console: ConsoleBox
public result: IntegerBox
console: ConsoleBox
result: IntegerBox
main() {
me.console = new ConsoleBox()
@ -138,21 +130,6 @@ static box Main {
}
```
#### **ジェネリックBox**
```nyash
box Container<T> {
public value: T
birth(item) {
me.value = item
}
getValue() {
return me.value
}
}
```
### **2.2 変数宣言**
#### **基本パターン**
@ -204,6 +181,9 @@ loop(condition) {
if exitCondition {
break
}
if skipCondition {
continue # Phase 12.7で追加
}
}
# ❌ 削除済み - 使用不可
@ -211,6 +191,31 @@ while condition { } # パーサーエラー
loop() { } # パーサーエラー
```
#### **Peek式（Phase 12.7で追加）**
```nyash
# パターンマッチング風の分岐
local result = peek value {
"A" => 100,
"B" => 200,
"C" => 300,
else => 0 # else必須
}
# 文の形式も可
peek status {
"error" => {
print("Error occurred")
return null
},
"success" => {
print("All good")
},
else => {
print("Unknown status")
}
}
```
### **2.4 演算子・式**
#### **🚀 新実装: 関数オーバーロードシステム**
@ -239,6 +244,19 @@ isValid = not (isEmpty or hasError)
result = condition && other || fallback # 利用可能だが非推奨
```
#### **特殊演算子（Phase 12.7実装済み）**
```nyash
# ? 演算子 - Result伝播
local data = readFile(path)? # エラーなら早期return
# ラムダ式
local add = fn(x, y) { return x + y }
local double = fn(x) { x * 2 } # 単一式なら省略可
# await式
local result = await asyncTask()
```
---
## 🏗️ **3. Box構文詳細ガイド**
@ -308,7 +326,7 @@ box Animal {
# デリゲーション
box Dog from Animal {
public breed: StringBox # 追加フィールド
breed: StringBox # 追加フィールド
birth(dogName, dogBreed) {
from Animal.birth(dogName, "Canine") # 親コンストラクタ呼び出し
@ -331,19 +349,21 @@ box Cat from Animal interface Playful {
#### **名前空間・ユーティリティ**
```nyash
static box MathUtils {
public PI: FloatBox
public E: FloatBox
PI: FloatBox
E: FloatBox
static {
me.PI = 3.14159265
me.E = 2.71828182
}
# 注意: static初期化ブロックは未実装
# 初期化はメソッド内で行う
add(a, b) {
return a + b
}
circleArea(radius) {
# 初回アクセスで初期化パターン
if me.PI == null {
me.PI = 3.14159265
}
return me.PI * radius * radius
}
}
@ -351,15 +371,14 @@ static box MathUtils {
# 使用法
area = MathUtils.circleArea(5)
sum = MathUtils.add(10, 20)
pi = MathUtils.PI
```
#### **アプリケーションエントリーポイント**
```nyash
# 🎯 推奨: Static Box Main パターン
static box Main {
public console: ConsoleBox
public result: IntegerBox
console: ConsoleBox
result: IntegerBox
main() {
me.console = new ConsoleBox()
@ -429,13 +448,82 @@ static box Calculator {
---
## 🚀 **4.4 Phase 12.7実装済み機能**
### **Peek式 - パターンマッチング風分岐**
```nyash
# 式として使用（値を返す）
local grade = peek score {
100 => "Perfect",
90 => "Excellent",
80 => "Good",
else => "Needs improvement"
}
# 文として使用（アクション実行）
peek command {
"save" => {
saveFile()
print("Saved!")
},
"quit" => {
cleanup()
return
},
else => print("Unknown command")
}
```
### **Continue文**
```nyash
loop(i < 100) {
if i % 2 == 0 {
continue # 偶数をスキップ
}
process(i)
}
```
### **フィールド型アノテーション**
```nyash
box Person {
name: StringBox # 型情報を明記（P0では無視）
age: IntegerBox
email # 型なしも可
}
```
### **?演算子（Result伝播）**
```nyash
# ResultBoxのエラーを自動的に早期return
local data = readFile("config.json")?
local parsed = parseJSON(data)?
return parsed.get("version")
```
### **Lambda式**
```nyash
# 基本形
local add = fn(x, y) { return x + y }
# 単一式の場合（returnは省略可）
local double = fn(x) { x * 2 }
# 高階関数での使用
array.map(fn(x) { x * x })
```
---
## ⚡ **5. 実装済みBox型ライブラリ**
### **5.1 基本型**
- `StringBox` - 文字列（split, find, replace, trim等）
- `IntegerBox` - 64bit整数
- `FloatBox` - 64bit浮動小数点数
- `BoolBox` - 真偽値
- `VoidBox` - null/void値
- `NullBox` - null値
- `VoidBox` - void値
### **5.2 コレクション**
- `ArrayBox` - 動的配列（push, pop, get, set, join等）
@ -444,7 +532,7 @@ static box Calculator {
### **5.3 システム・I/O**
- `ConsoleBox` - コンソール入出力
- `DebugBox` - デバッグ支援・メモリ追跡
- `FileBox` - ファイルシステム操作
- `FileBox` - ファイルシステム操作（プラグイン）
### **5.4 数学・時間**
- `MathBox` - 数学関数（sin, cos, log, sqrt等）
@ -458,15 +546,22 @@ static box Calculator {
- `StreamBox` - ストリーム処理
### **5.6 ネットワーク・Web**
- `HttpClientBox` - HTTP通信
- `HttpClientBox` - HTTP通信（プラグイン）
- `WebDisplayBox` - HTML表示（WASM）
- `WebConsoleBox` - ブラウザコンソール（WASM）
- `WebCanvasBox` - Canvas描画（WASM）
### **5.7 GUI・マルチメディア**
- `EguiBox` - デスクトップGUI（Windows/Linux）
- `EguiBox` - デスクトップGUI（Windows/Linux、プラグイン）
- `SoundBox` - 音声再生
### **5.8 特殊用途**
- `FutureBox` - 非同期処理結果
- `ResultBox` - エラー処理（Ok/Err）
- `TokenBox` - キャンセルトークン
- `FunctionBox` - 第一級関数
- `P2PBox` - P2P通信（プラグイン）
---
## 🎯 **6. パフォーマンス・デザイン原則**
@ -519,19 +614,59 @@ static box Main {
### **7.3 よくある間違いと対策**
```nyash
# ❌ よくある間違い
public { field1 field2 } # 旧構文 → Phase 12.7で廃止
public { field1 field2 } # 旧構文 → 使用不可
x = 42 # 変数未宣言 → ランタイムエラー
while condition { } # 非対応構文 → パーサーエラー
this.field # thisは使用不可 → me.fieldを使用
# ✅ 正しい書き方（Phase 12.7後）
public field1: TypeBox # 公開フィールド
private field2: TypeBox # 非公開フィールド
local x = 42 # 事前宣言
field1: TypeBox # フィールド宣言（型は省略可）
field2 # 型なしフィールド
local x = 42 # 事前宣言必須
loop(condition) { } # 統一ループ構文
me.field # self参照はmeのみ
```
---
## 📌 **8. 今後実装予定の糖衣構文（Phase 12.7-B）**
### **パイプライン演算子（|>）**
```nyash
# 予定構文
result = data |> normalize |> transform |> process
# 現在の書き方
result = process(transform(normalize(data)))
```
### **セーフアクセス演算子（?.）とデフォルト値（??）**
```nyash
# 予定構文
name = user?.profile?.name ?? "guest"
# 現在の書き方
local name
if user != null and user.profile != null {
name = user.profile.name
} else {
name = "guest"
}
```
### **デストラクチャリング**
```nyash
# 予定構文
let {x, y} = point
let [first, second, ...rest] = array
# 現在の書き方
local x = point.x
local y = point.y
```
---
**🎉 Nyash 2025は、AI協働設計による最先端言語システムとして、シンプルさと強力さを完全に両立しました。**
*最終更新: 2025年8月27日 - フィールド可視性導入 + public/private明示化*
*最終更新: 2025年9月4日 - Phase 12.7実装済み機能の正確な反映*

3
nyash.toml
View File

@ -395,6 +395,9 @@ fini = { method_id = 4294967295 }
RUST_BACKTRACE = "1"
# 任意。verboseログ
NYASH_CLI_VERBOSE = "1"
## Core‑13 MIR を既定ON（論文化基準と整合）
NYASH_MIR_CORE13 = "1"
NYASH_OPT_DIAG_FORBID_LEGACY = "1"
[tasks]
# LLVMビルド（nyash本体）

7
src/backend/dispatch.rs
View File

@ -55,7 +55,12 @@ pub(super) fn execute_instruction(vm: &mut VM, instruction: &MirInstruction, deb
MirInstruction::TypeOp { dst, op, value, ty } => vm.execute_typeop(*dst, op, *value, ty),
// Control flow
MirInstruction::Return { value } => vm.execute_return(*value),
MirInstruction::Return { value } => {
if crate::config::env::vm_vt_trace() {
if let Some(v) = value { eprintln!("[VT] Dispatch Return val_id={}", v.to_usize()); } else { eprintln!("[VT] Dispatch Return void"); }
}
vm.execute_return(*value)
},
MirInstruction::Jump { target } => vm.execute_jump(*target),
MirInstruction::Branch { condition, then_bb, else_bb } => vm.execute_branch(*condition, *then_bb, *else_bb),
MirInstruction::Phi { dst, inputs } => vm.execute_phi(*dst, inputs),

1
src/backend/mod.rs
View File

@ -6,6 +6,7 @@ pub mod vm;
pub mod vm_phi;
pub mod vm_instructions;
pub mod vm_values;
pub mod vm_types;
pub mod vm_boxcall;
pub mod vm_stats;
// Phase 9.78h: VM split scaffolding (control_flow/dispatch/frame)

152
src/backend/vm.rs
View File

@ -29,156 +29,8 @@ use super::control_flow;
// #[cfg(all(feature = "plugins", not(target_arch = "wasm32")))]
// use crate::runtime::plugin_loader_v2::PluginLoaderV2;
/// VM execution error
#[derive(Debug)]
pub enum VMError {
InvalidValue(String),
InvalidInstruction(String),
InvalidBasicBlock(String),
DivisionByZero,
StackUnderflow,
TypeError(String),
}
impl std::fmt::Display for VMError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
VMError::InvalidValue(msg) => write!(f, "Invalid value: {}", msg),
VMError::InvalidInstruction(msg) => write!(f, "Invalid instruction: {}", msg),
VMError::InvalidBasicBlock(msg) => write!(f, "Invalid basic block: {}", msg),
VMError::DivisionByZero => write!(f, "Division by zero"),
VMError::StackUnderflow => write!(f, "Stack underflow"),
VMError::TypeError(msg) => write!(f, "Type error: {}", msg),
}
}
}
impl std::error::Error for VMError {}
/// VM value representation
#[derive(Debug, Clone)]
pub enum VMValue {
Integer(i64),
Float(f64),
Bool(bool),
String(String),
Future(crate::boxes::future::FutureBox),
Void,
// Phase 9.78a: Add BoxRef for complex Box types
BoxRef(Arc<dyn NyashBox>),
}
// Manual PartialEq implementation to avoid requiring PartialEq on FutureBox
impl PartialEq for VMValue {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(VMValue::Integer(a), VMValue::Integer(b)) => a == b,
(VMValue::Float(a), VMValue::Float(b)) => a == b,
(VMValue::Bool(a), VMValue::Bool(b)) => a == b,
(VMValue::String(a), VMValue::String(b)) => a == b,
(VMValue::Void, VMValue::Void) => true,
// Future equality semantics are not defined; treat distinct futures as not equal
(VMValue::Future(_), VMValue::Future(_)) => false,
// BoxRef equality by reference
(VMValue::BoxRef(_), VMValue::BoxRef(_)) => false,
_ => false,
}
}
}
impl VMValue {
/// Convert to NyashBox for output
pub fn to_nyash_box(&self) -> Box<dyn NyashBox> {
match self {
VMValue::Integer(i) => Box::new(IntegerBox::new(*i)),
VMValue::Float(f) => Box::new(crate::boxes::FloatBox::new(*f)),
VMValue::Bool(b) => Box::new(BoolBox::new(*b)),
VMValue::String(s) => Box::new(StringBox::new(s)),
VMValue::Future(f) => Box::new(f.clone()),
VMValue::Void => Box::new(VoidBox::new()),
// BoxRef returns a shared handle (do NOT birth a new instance)
VMValue::BoxRef(arc_box) => arc_box.share_box(),
}
}
/// Get string representation for printing
pub fn to_string(&self) -> String {
match self {
VMValue::Integer(i) => i.to_string(),
VMValue::Float(f) => f.to_string(),
VMValue::Bool(b) => b.to_string(),
VMValue::String(s) => s.clone(),
VMValue::Future(f) => f.to_string_box().value,
VMValue::Void => "void".to_string(),
VMValue::BoxRef(arc_box) => arc_box.to_string_box().value,
}
}
/// Attempt to convert to integer
pub fn as_integer(&self) -> Result<i64, VMError> {
match self {
VMValue::Integer(i) => Ok(*i),
_ => Err(VMError::TypeError(format!("Expected integer, got {:?}", self))),
}
}
/// Attempt to convert to bool
pub fn as_bool(&self) -> Result<bool, VMError> {
match self {
VMValue::Bool(b) => Ok(*b),
VMValue::Integer(i) => Ok(*i != 0),
// Pragmatic coercions for dynamic boxes
VMValue::BoxRef(b) => {
// BoolBox → bool
if let Some(bb) = b.as_any().downcast_ref::<BoolBox>() {
return Ok(bb.value);
}
// IntegerBox → truthy if non-zero (legacy and new)
if let Some(ib) = b.as_any().downcast_ref::<IntegerBox>() { return Ok(ib.value != 0); }
if let Some(ib) = b.as_any().downcast_ref::<crate::boxes::integer_box::IntegerBox>() { return Ok(ib.value != 0); }
// VoidBox → false (nullish false)
if b.as_any().downcast_ref::<VoidBox>().is_some() {
return Ok(false);
}
Err(VMError::TypeError(format!("Expected bool, got BoxRef({})", b.type_name())))
}
// Treat plain Void as false for logical contexts
VMValue::Void => Ok(false),
_ => Err(VMError::TypeError(format!("Expected bool, got {:?}", self))),
}
}
/// Convert from NyashBox to VMValue
pub fn from_nyash_box(nyash_box: Box<dyn crate::box_trait::NyashBox>) -> VMValue {
// Try to downcast to known types for optimization
if let Some(int_box) = nyash_box.as_any().downcast_ref::<IntegerBox>() {
VMValue::Integer(int_box.value)
} else if let Some(bool_box) = nyash_box.as_any().downcast_ref::<BoolBox>() {
VMValue::Bool(bool_box.value)
} else if let Some(string_box) = nyash_box.as_any().downcast_ref::<StringBox>() {
VMValue::String(string_box.value.clone())
} else if let Some(future_box) = nyash_box.as_any().downcast_ref::<crate::boxes::future::FutureBox>() {
VMValue::Future(future_box.clone())
} else {
// Phase 9.78a: For all other Box types (user-defined, plugin), store as BoxRef
VMValue::BoxRef(Arc::from(nyash_box))
}
}
}
impl From<&ConstValue> for VMValue {
fn from(const_val: &ConstValue) -> Self {
match const_val {
ConstValue::Integer(i) => VMValue::Integer(*i),
ConstValue::Float(f) => VMValue::Float(*f),
ConstValue::Bool(b) => VMValue::Bool(*b),
ConstValue::String(s) => VMValue::String(s.clone()),
ConstValue::Null => VMValue::Void, // Simplified
ConstValue::Void => VMValue::Void,
}
}
}
// Thinned: core types moved to vm_types.rs
pub use super::vm_types::{VMError, VMValue};
/// Virtual Machine state
pub struct VM {

15
src/backend/vm_boxcall.rs
View File

@ -223,6 +223,21 @@ impl VM {
match method {
"length" | "len" => { return Ok(Box::new(IntegerBox::new(string_box.value.len() as i64))); }
"toString" => { return Ok(Box::new(StringBox::new(string_box.value.clone()))); }
"substring" => {
if _args.len() >= 2 {
let s = match _args[0].to_string_box().value.parse::<i64>() { Ok(v) => v.max(0) as usize, Err(_) => 0 };
let e = match _args[1].to_string_box().value.parse::<i64>() { Ok(v) => v.max(0) as usize, Err(_) => string_box.value.chars().count() };
return Ok(string_box.substring(s, e));
}
return Ok(Box::new(VoidBox::new()));
}
"concat" => {
if let Some(arg0) = _args.get(0) {
let out = format!("{}{}", string_box.value, arg0.to_string_box().value);
return Ok(Box::new(StringBox::new(out)));
}
return Ok(Box::new(VoidBox::new()));
}
_ => return Ok(Box::new(VoidBox::new())),
}
}

10
src/backend/vm_exec.rs
View File

@ -278,6 +278,16 @@ impl VM {
}
}
}
// Execute terminator if present and we haven't decided control flow yet
if should_return.is_none() && next_block.is_none() {
if let Some(term) = &block.terminator {
match self.execute_instruction(term)? {
ControlFlow::Continue => {},
ControlFlow::Jump(target) => { next_block = Some(target); },
ControlFlow::Return(value) => { should_return = Some(value); },
}
}
}
} else {
return Err(VMError::InvalidBasicBlock(format!(
"Basic block {:?} not found",

406
src/backend/vm_instructions/boxcall.rs
View File

@ -4,6 +4,48 @@ use crate::backend::vm::ControlFlow;
use crate::backend::{VM, VMError, VMValue};
impl VM {
/// Small helpers to reduce duplication in vtable stub paths.
#[inline]
fn vmvalue_to_box(val: &VMValue) -> Box<dyn crate::box_trait::NyashBox> {
use crate::box_trait::{NyashBox, StringBox as SBox, IntegerBox as IBox, BoolBox as BBox};
match val {
VMValue::Integer(i) => Box::new(IBox::new(*i)),
VMValue::String(s) => Box::new(SBox::new(s)),
VMValue::Bool(b) => Box::new(BBox::new(*b)),
VMValue::Float(f) => Box::new(crate::boxes::math_box::FloatBox::new(*f)),
VMValue::BoxRef(bx) => bx.share_box(),
VMValue::Future(fut) => Box::new(fut.clone()),
VMValue::Void => Box::new(crate::box_trait::VoidBox::new()),
}
}
#[inline]
fn arg_as_box(&mut self, id: crate::mir::ValueId) -> Result<Box<dyn crate::box_trait::NyashBox>, VMError> {
let v = self.get_value(id)?;
Ok(Self::vmvalue_to_box(&v))
}
#[inline]
fn two_args_as_box(&mut self, a0: crate::mir::ValueId, a1: crate::mir::ValueId) -> Result<(Box<dyn crate::box_trait::NyashBox>, Box<dyn crate::box_trait::NyashBox>), VMError> {
Ok((self.arg_as_box(a0)?, self.arg_as_box(a1)?))
}
#[inline]
fn arg_to_string(&mut self, id: crate::mir::ValueId) -> Result<String, VMError> {
let v = self.get_value(id)?;
Ok(v.to_string())
}
#[inline]
fn arg_to_usize_or(&mut self, id: crate::mir::ValueId, default: usize) -> Result<usize, VMError> {
let v = self.get_value(id)?;
match v {
VMValue::Integer(i) => Ok((i.max(0)) as usize),
VMValue::String(ref s) => Ok(s.trim().parse::<i64>().map(|iv| iv.max(0) as usize).unwrap_or(default)),
_ => Ok(v.to_string().trim().parse::<i64>().map(|iv| iv.max(0) as usize).unwrap_or(default)),
}
}
/// Execute BoxCall instruction
pub(crate) fn execute_boxcall(&mut self, dst: Option<ValueId>, box_val: ValueId, method: &str, method_id: Option<u16>, args: &[ValueId]) -> Result<ControlFlow, VMError> {
let recv = self.get_value(box_val)?;
@ -358,6 +400,66 @@ impl VM {
if crate::config::env::vm_vt_trace() {
match _recv { VMValue::BoxRef(b) => eprintln!("[VT] probe recv_ty={} method={} argc={}", b.type_name(), _method, _args.len()), other => eprintln!("[VT] probe recv_prim={:?} method={} argc={}", other, _method, _args.len()), }
}
// Primitive String fast-path using StringBox slots
if let VMValue::String(sv) = _recv {
if crate::runtime::type_registry::resolve_typebox_by_name("StringBox").is_some() {
let slot = crate::runtime::type_registry::resolve_slot_by_name("StringBox", _method, _args.len());
match slot {
Some(300) => { // len
let out = VMValue::Integer(sv.len() as i64);
if let Some(dst_id) = _dst { self.set_value(dst_id, out); }
return Some(Ok(ControlFlow::Continue));
}
Some(301) => { // substring
if _args.len() >= 2 {
if let (Ok(a0), Ok(a1)) = (self.get_value(_args[0]), self.get_value(_args[1])) {
let chars: Vec<char> = sv.chars().collect();
let start = match a0 { VMValue::Integer(i) => i.max(0) as usize, _ => 0 };
let end = match a1 { VMValue::Integer(i) => i.max(0) as usize, _ => chars.len() };
let ss: String = chars[start.min(end)..end.min(chars.len())].iter().collect();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::String(ss)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
Some(302) => { // concat
if let Some(a0) = _args.get(0) { if let Ok(v) = self.get_value(*a0) {
let out = format!("{}{}", sv, v.to_string());
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::String(out)); }
return Some(Ok(ControlFlow::Continue));
}}
}
Some(303) => { // indexOf
if let Some(a0) = _args.get(0) { if let Ok(v) = self.get_value(*a0) {
let needle = v.to_string();
let pos = sv.find(&needle).map(|p| p as i64).unwrap_or(-1);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::Integer(pos)); }
return Some(Ok(ControlFlow::Continue));
}}
}
Some(304) => { // replace
if _args.len() >= 2 { if let (Ok(a0), Ok(a1)) = (self.get_value(_args[0]), self.get_value(_args[1])) {
let out = sv.replace(&a0.to_string(), &a1.to_string());
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::String(out)); }
return Some(Ok(ControlFlow::Continue));
}}
}
Some(305) => { // trim
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::String(sv.trim().to_string())); }
return Some(Ok(ControlFlow::Continue));
}
Some(306) => { // toUpper
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::String(sv.to_uppercase())); }
return Some(Ok(ControlFlow::Continue));
}
Some(307) => { // toLower
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::String(sv.to_lowercase())); }
return Some(Ok(ControlFlow::Continue));
}
_ => {}
}
}
}
if let VMValue::BoxRef(b) = _recv {
let ty_name = b.type_name();
let ty_name_for_reg: std::borrow::Cow<'_, str> = if let Some(p) = b.as_any().downcast_ref::<crate::runtime::plugin_loader_v2::PluginBoxV2>() { std::borrow::Cow::Owned(p.box_type.clone()) } else { std::borrow::Cow::Borrowed(ty_name) };
@ -425,62 +527,34 @@ impl VM {
return Some(Ok(ControlFlow::Continue));
}
if matches!(slot, Some(202)) {
if let Ok(arg_v) = self.get_value(_args[0]) {
let key_box: Box<dyn NyashBox> = match arg_v {
VMValue::Integer(i) => Box::new(crate::box_trait::IntegerBox::new(i)),
VMValue::String(ref s) => Box::new(crate::box_trait::StringBox::new(s)),
VMValue::Bool(b) => Box::new(crate::box_trait::BoolBox::new(b)),
VMValue::Float(f) => Box::new(crate::boxes::math_box::FloatBox::new(f)),
VMValue::BoxRef(ref bx) => bx.share_box(),
VMValue::Future(ref fut) => Box::new(fut.clone()),
VMValue::Void => Box::new(crate::box_trait::VoidBox::new()),
};
if let Some(a0) = _args.get(0) { if let Ok(key_box) = self.arg_as_box(*a0) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] MapBox.has"); }
let out = map.has(key_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}}
}
if matches!(slot, Some(203)) {
if let Ok(arg_v) = self.get_value(_args[0]) {
let key_box: Box<dyn NyashBox> = match arg_v {
VMValue::Integer(i) => Box::new(crate::box_trait::IntegerBox::new(i)),
VMValue::String(ref s) => Box::new(crate::box_trait::StringBox::new(s)),
VMValue::Bool(b) => Box::new(crate::box_trait::BoolBox::new(b)),
VMValue::Float(f) => Box::new(crate::boxes::math_box::FloatBox::new(f)),
VMValue::BoxRef(ref bx) => bx.share_box(),
VMValue::Future(ref fut) => Box::new(fut.clone()),
VMValue::Void => Box::new(crate::box_trait::VoidBox::new()),
};
if let Some(a0) = _args.get(0) { if let Ok(key_box) = self.arg_as_box(*a0) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] MapBox.get"); }
let out = map.get(key_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}}
}
if matches!(slot, Some(204)) {
if let (Ok(a0), Ok(a1)) = (self.get_value(_args[0]), self.get_value(_args[1])) {
if let VMValue::String(ref s) = a0 { let vb: Box<dyn NyashBox> = match a1 { VMValue::Integer(i) => Box::new(crate::box_trait::IntegerBox::new(i)), VMValue::String(ref s) => Box::new(crate::box_trait::StringBox::new(s)), VMValue::Bool(b) => Box::new(crate::box_trait::BoolBox::new(b)), VMValue::Float(f) => Box::new(crate::boxes::math_box::FloatBox::new(f)), VMValue::BoxRef(ref bx) => bx.share_box(), VMValue::Future(ref fut) => Box::new(fut.clone()), VMValue::Void => Box::new(crate::box_trait::VoidBox::new()), }; let out = map.set(Box::new(crate::box_trait::StringBox::new(s)), vb); if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); } return Some(Ok(ControlFlow::Continue)); }
let key_box: Box<dyn NyashBox> = match a0 {
VMValue::Integer(i) => Box::new(crate::box_trait::IntegerBox::new(i)),
VMValue::String(ref s) => Box::new(crate::box_trait::StringBox::new(s)),
VMValue::Bool(b) => Box::new(crate::box_trait::BoolBox::new(b)),
VMValue::Float(f) => Box::new(crate::boxes::math_box::FloatBox::new(f)),
VMValue::BoxRef(ref bx) => bx.share_box(),
VMValue::Future(ref fut) => Box::new(fut.clone()),
VMValue::Void => Box::new(crate::box_trait::VoidBox::new()),
};
let val_box: Box<dyn NyashBox> = match a1 {
VMValue::Integer(i) => Box::new(crate::box_trait::IntegerBox::new(i)),
VMValue::String(ref s) => Box::new(crate::box_trait::StringBox::new(s)),
VMValue::Bool(b) => Box::new(crate::box_trait::BoolBox::new(b)),
VMValue::Float(f) => Box::new(crate::boxes::math_box::FloatBox::new(f)),
VMValue::BoxRef(ref bx) => bx.share_box(),
VMValue::Future(ref fut) => Box::new(fut.clone()),
VMValue::Void => Box::new(crate::box_trait::VoidBox::new()),
};
if _args.len() >= 2 {
if let (Ok(a0), Ok(a1)) = (self.get_value(_args[0]), self.get_value(_args[1])) {
if let VMValue::String(ref s) = a0 {
let vb = Self::vmvalue_to_box(&a1);
let out = map.set(Box::new(crate::box_trait::StringBox::new(s)), vb);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
let key_box = Self::vmvalue_to_box(&a0);
let val_box = Self::vmvalue_to_box(&a1);
// Barrier: mutation
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Map.set");
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
@ -488,8 +562,34 @@ impl VM {
let out = map.set(key_box, val_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
if matches!(slot, Some(205)) { // delete/remove
if let Some(a0) = _args.get(0) { if let Ok(arg_v) = self.get_value(*a0) {
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Map.delete");
let key_box = Self::vmvalue_to_box(&arg_v);
let out = map.delete(key_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}}
}
if matches!(slot, Some(206)) { // keys
let out = map.keys();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
if matches!(slot, Some(207)) { // values
let out = map.values();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
if matches!(slot, Some(208)) { // clear
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Map.clear");
let out = map.clear();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
// StringBox: len
if let Some(sb) = b.as_any().downcast_ref::<crate::box_trait::StringBox>() {
@ -500,6 +600,228 @@ impl VM {
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(Box::new(out))); }
return Some(Ok(ControlFlow::Continue));
}
// substring(start, end)
if matches!(slot, Some(301)) {
if _args.len() >= 2 {
let full = sb.value.chars().count();
if let (Ok(start), Ok(end)) = (self.arg_to_usize_or(_args[0], 0), self.arg_to_usize_or(_args[1], full)) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] StringBox.substring({}, {})", start, end); }
let out = sb.substring(start, end);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// concat(other)
if matches!(slot, Some(302)) {
if let Some(a0_id) = _args.get(0) {
if let Ok(a0) = self.get_value(*a0_id) {
let other = a0.to_string();
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] StringBox.concat"); }
let out = crate::box_trait::StringBox::new(format!("{}{}", sb.value, other));
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(Box::new(out))); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// indexOf(search)
if matches!(slot, Some(303)) {
if let Some(a0_id) = _args.get(0) {
if let Ok(needle) = self.arg_to_string(*a0_id) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
let out = sb.find(&needle);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// replace(old, new)
if matches!(slot, Some(304)) {
if _args.len() >= 2 {
if let (Ok(old), Ok(newv)) = (self.arg_to_string(_args[0]), self.arg_to_string(_args[1])) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
let out = sb.replace(&old, &newv);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// trim()
if matches!(slot, Some(305)) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
let out = sb.trim();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
// toUpper()
if matches!(slot, Some(306)) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
let out = sb.to_upper();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
// toLower()
if matches!(slot, Some(307)) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
let out = sb.to_lower();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
// ConsoleBox: log/warn/error/clear (400-series)
if let Some(console) = b.as_any().downcast_ref::<crate::boxes::console_box::ConsoleBox>() {
match slot {
Some(400) => { // log
if let Some(a0) = _args.get(0) { if let Ok(msg) = self.arg_to_string(*a0) { console.log(&msg); if let Some(dst) = _dst { self.set_value(dst, VMValue::Void); } return Some(Ok(ControlFlow::Continue)); } }
}
Some(401) => { // warn
if let Some(a0) = _args.get(0) { if let Ok(msg) = self.arg_to_string(*a0) { console.warn(&msg); if let Some(dst) = _dst { self.set_value(dst, VMValue::Void); } return Some(Ok(ControlFlow::Continue)); } }
}
Some(402) => { // error
if let Some(a0) = _args.get(0) { if let Ok(msg) = self.arg_to_string(*a0) { console.error(&msg); if let Some(dst) = _dst { self.set_value(dst, VMValue::Void); } return Some(Ok(ControlFlow::Continue)); } }
}
Some(403) => { // clear
console.clear(); if let Some(dst) = _dst { self.set_value(dst, VMValue::Void); } return Some(Ok(ControlFlow::Continue));
}
_ => {}
}
}
// ArrayBox: len/get/set (builtin fast path via vtable slots 102/100/101)
if let Some(arr) = b.as_any().downcast_ref::<crate::boxes::array::ArrayBox>() {
// len/length
if matches!(slot, Some(102)) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.len"); }
let out = arr.length();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); } else if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.len without dst"); }
return Some(Ok(ControlFlow::Continue));
}
// get(index)
if matches!(slot, Some(100)) {
if let Some(a0_id) = _args.get(0) {
if let Ok(idx_box) = self.arg_as_box(*a0_id) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.get"); }
let out = arr.get(idx_box);
let vm_out = VMValue::from_nyash_box(out);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.get -> {}", vm_out.to_string()); }
if let Some(dst_id) = _dst { if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.get set dst={}", dst_id.to_usize()); } self.set_value(dst_id, vm_out); } else if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.get without dst"); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// set(index, value)
if matches!(slot, Some(101)) {
if _args.len() >= 2 {
if let (Ok(idx_box), Ok(val_box)) = (self.arg_as_box(_args[0]), self.arg_as_box(_args[1])) {
// Mutation barrier
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Array.set");
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.set"); }
let out = arr.set(idx_box, val_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); } else if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.set without dst"); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// push(value)
if matches!(slot, Some(103)) {
if let Some(a0_id) = _args.get(0) {
if let Ok(val_box) = self.arg_as_box(*a0_id) {
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Array.push");
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.push"); }
let out = arr.push(val_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// pop()
if matches!(slot, Some(104)) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.pop"); }
let out = arr.pop();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
// clear()
if matches!(slot, Some(105)) {
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Array.clear");
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.clear"); }
let out = arr.clear();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
// contains(value)
if matches!(slot, Some(106)) {
if let Some(a0_id) = _args.get(0) {
if let Ok(val_box) = self.arg_as_box(*a0_id) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.contains"); }
let out = arr.contains(val_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// indexOf(value)
if matches!(slot, Some(107)) {
if let Some(a0_id) = _args.get(0) {
if let Ok(val_box) = self.arg_as_box(*a0_id) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.indexOf"); }
let out = arr.indexOf(val_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// join(sep)
if matches!(slot, Some(108)) {
if let Some(a0_id) = _args.get(0) {
if let Ok(sep_box) = self.arg_as_box(*a0_id) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.join"); }
let out = arr.join(sep_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
// sort()
if matches!(slot, Some(109)) {
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Array.sort");
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.sort"); }
let out = arr.sort();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
// reverse()
if matches!(slot, Some(110)) {
crate::backend::gc_helpers::gc_write_barrier_site(&self.runtime, "VTable.Array.reverse");
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.reverse"); }
let out = arr.reverse();
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
// slice(start, end)
if matches!(slot, Some(111)) {
if _args.len() >= 2 {
if let (Ok(start_box), Ok(end_box)) = (self.arg_as_box(_args[0]), self.arg_as_box(_args[1])) {
self.boxcall_hits_vtable = self.boxcall_hits_vtable.saturating_add(1);
if crate::config::env::vm_vt_trace() { eprintln!("[VT] ArrayBox.slice"); }
let out = arr.slice(start_box, end_box);
if let Some(dst_id) = _dst { self.set_value(dst_id, VMValue::from_nyash_box(out)); }
return Some(Ok(ControlFlow::Continue));
}
}
}
}
if crate::config::env::abi_strict() {
let known = crate::runtime::type_registry::known_methods_for(ty_name).unwrap_or_default().join(", ");

9
src/backend/vm_instructions/core.rs
View File

@ -156,7 +156,14 @@ impl VM {
Ok(ControlFlow::Jump(if should_branch { then_bb } else { else_bb }))
}
pub(crate) fn execute_return(&self, value: Option<ValueId>) -> Result<ControlFlow, VMError> {
if let Some(val_id) = value { let return_val = self.get_value(val_id)?; Ok(ControlFlow::Return(return_val)) } else { Ok(ControlFlow::Return(VMValue::Void)) }
if let Some(val_id) = value {
let return_val = self.get_value(val_id)?;
if crate::config::env::vm_vt_trace() { eprintln!("[VT] Return id={} val={}", val_id.to_usize(), return_val.to_string()); }
Ok(ControlFlow::Return(return_val))
} else {
if crate::config::env::vm_vt_trace() { eprintln!("[VT] Return void"); }
Ok(ControlFlow::Return(VMValue::Void))
}
}
pub(crate) fn execute_typeop(&mut self, dst: ValueId, op: &TypeOpKind, value: ValueId, ty: &MirType) -> Result<ControlFlow, VMError> {
let val = self.get_value(value)?;

148
src/backend/vm_types.rs Normal file
View File

@ -0,0 +1,148 @@
/*!
* VM Core Types
*
* Purpose: Error and Value enums used by the VM backend
* Kept separate to thin vm.rs and allow reuse across helpers.
*/
use crate::box_trait::{NyashBox, StringBox, IntegerBox, BoolBox, VoidBox};
use crate::mir::ConstValue;
use std::sync::Arc;
/// VM execution error
#[derive(Debug)]
pub enum VMError {
InvalidValue(String),
InvalidInstruction(String),
InvalidBasicBlock(String),
DivisionByZero,
StackUnderflow,
TypeError(String),
}
impl std::fmt::Display for VMError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
VMError::InvalidValue(msg) => write!(f, "Invalid value: {}", msg),
VMError::InvalidInstruction(msg) => write!(f, "Invalid instruction: {}", msg),
VMError::InvalidBasicBlock(msg) => write!(f, "Invalid basic block: {}", msg),
VMError::DivisionByZero => write!(f, "Division by zero"),
VMError::StackUnderflow => write!(f, "Stack underflow"),
VMError::TypeError(msg) => write!(f, "Type error: {}", msg),
}
}
}
impl std::error::Error for VMError {}
/// VM value representation
#[derive(Debug, Clone)]
pub enum VMValue {
Integer(i64),
Float(f64),
Bool(bool),
String(String),
Future(crate::boxes::future::FutureBox),
Void,
BoxRef(Arc<dyn NyashBox>),
}
// Manual PartialEq implementation to avoid requiring PartialEq on FutureBox
impl PartialEq for VMValue {
fn eq(&self, other: &Self) -> bool {
match (self, other) {
(VMValue::Integer(a), VMValue::Integer(b)) => a == b,
(VMValue::Float(a), VMValue::Float(b)) => a == b,
(VMValue::Bool(a), VMValue::Bool(b)) => a == b,
(VMValue::String(a), VMValue::String(b)) => a == b,
(VMValue::Void, VMValue::Void) => true,
(VMValue::Future(_), VMValue::Future(_)) => false,
(VMValue::BoxRef(_), VMValue::BoxRef(_)) => false,
_ => false,
}
}
}
impl VMValue {
/// Convert to NyashBox for output
pub fn to_nyash_box(&self) -> Box<dyn NyashBox> {
match self {
VMValue::Integer(i) => Box::new(IntegerBox::new(*i)),
VMValue::Float(f) => Box::new(crate::boxes::FloatBox::new(*f)),
VMValue::Bool(b) => Box::new(BoolBox::new(*b)),
VMValue::String(s) => Box::new(StringBox::new(s)),
VMValue::Future(f) => Box::new(f.clone()),
VMValue::Void => Box::new(VoidBox::new()),
VMValue::BoxRef(arc_box) => arc_box.share_box(),
}
}
/// Get string representation for printing
pub fn to_string(&self) -> String {
match self {
VMValue::Integer(i) => i.to_string(),
VMValue::Float(f) => f.to_string(),
VMValue::Bool(b) => b.to_string(),
VMValue::String(s) => s.clone(),
VMValue::Future(f) => f.to_string_box().value,
VMValue::Void => "void".to_string(),
VMValue::BoxRef(arc_box) => arc_box.to_string_box().value,
}
}
/// Attempt to convert to integer
pub fn as_integer(&self) -> Result<i64, VMError> {
match self {
VMValue::Integer(i) => Ok(*i),
_ => Err(VMError::TypeError(format!("Expected integer, got {:?}", self))),
}
}
/// Attempt to convert to bool
pub fn as_bool(&self) -> Result<bool, VMError> {
match self {
VMValue::Bool(b) => Ok(*b),
VMValue::Integer(i) => Ok(*i != 0),
// Pragmatic coercions for dynamic boxes (preserve legacy semantics)
VMValue::BoxRef(b) => {
if let Some(bb) = b.as_any().downcast_ref::<BoolBox>() { return Ok(bb.value); }
if let Some(ib) = b.as_any().downcast_ref::<IntegerBox>() { return Ok(ib.value != 0); }
if let Some(ib) = b.as_any().downcast_ref::<crate::boxes::integer_box::IntegerBox>() { return Ok(ib.value != 0); }
if b.as_any().downcast_ref::<VoidBox>().is_some() { return Ok(false); }
Err(VMError::TypeError(format!("Expected bool, got BoxRef({})", b.type_name())))
}
VMValue::Void => Ok(false),
VMValue::Float(f) => Ok(*f != 0.0),
VMValue::String(s) => Ok(!s.is_empty()),
VMValue::Future(_) => Ok(true),
}
}
/// Convert from NyashBox to VMValue
pub fn from_nyash_box(nyash_box: Box<dyn crate::box_trait::NyashBox>) -> VMValue {
if let Some(int_box) = nyash_box.as_any().downcast_ref::<IntegerBox>() {
VMValue::Integer(int_box.value)
} else if let Some(bool_box) = nyash_box.as_any().downcast_ref::<BoolBox>() {
VMValue::Bool(bool_box.value)
} else if let Some(string_box) = nyash_box.as_any().downcast_ref::<StringBox>() {
VMValue::String(string_box.value.clone())
} else if let Some(future_box) = nyash_box.as_any().downcast_ref::<crate::boxes::future::FutureBox>() {
VMValue::Future(future_box.clone())
} else {
VMValue::BoxRef(Arc::from(nyash_box))
}
}
}
impl From<&ConstValue> for VMValue {
fn from(const_val: &ConstValue) -> Self {
match const_val {
ConstValue::Integer(i) => VMValue::Integer(*i),
ConstValue::Float(f) => VMValue::Float(*f),
ConstValue::Bool(b) => VMValue::Bool(*b),
ConstValue::String(s) => VMValue::String(s.clone()),
ConstValue::Null => VMValue::Void,
ConstValue::Void => VMValue::Void,
}
}
}

7
src/backend/vm_values.rs
View File

@ -8,11 +8,16 @@
*/
use crate::mir::{BinaryOp, CompareOp, UnaryOp};
use super::vm::{VM, VMError, VMValue};
use super::vm::VM;
use super::vm_types::{VMError, VMValue};
impl VM {
/// Try to view a BoxRef as a UTF-8 string using unified semantics
fn try_boxref_to_string(&self, b: &dyn crate::box_trait::NyashBox) -> Option<String> {
// Avoid recursion via PluginHost<->Loader for PluginBoxV2 during VM add/string ops
if b.as_any().downcast_ref::<crate::runtime::plugin_loader_v2::PluginBoxV2>().is_some() {
return None;
}
crate::runtime::semantics::coerce_to_string(b)
}
/// Execute binary operation

4
src/jit/lower/extern_thunks.rs
View File

@ -762,10 +762,6 @@ pub(super) extern "C" fn nyash_string_from_ptr(ptr: u64, len: u64) -> i64 {
}
// ===== FunctionBox call shims (by arity, up to 4) =====
#[cfg(feature = "cranelift-jit")]
fn vmvalue_from_jit_arg_i64(v: i64) -> crate::backend::vm::VMValue { super::vmvalue_from_jit_arg_i64(v) }
#[cfg(feature = "cranelift-jit")]
fn i64_from_vmvalue(v: crate::backend::vm::VMValue) -> i64 { super::i64_from_vmvalue(v) }
#[cfg(feature = "cranelift-jit")]
fn fn_call_impl(func_h: u64, args: &[i64]) -> i64 {

30
src/jit/policy/invoke.rs
View File

@ -1,8 +1,7 @@
//! InvokePolicyPass (minimal scaffold)
//! Centralizes decision for plugin/hostcall/any to keep lowerer slim.
//! Current implementation covers a small subset (ArrayBox length/get/set/push,
//! MapBox size/get/has/set) when NYASH_USE_PLUGIN_BUILTINS=1, falling back
//! to existing hostcall symbols otherwise. Extend incrementally.
//! Centralizes decision for plugin/hostcall to keep lowerer slim.
//! HostCall優先（Core-13方針）。ENV `NYASH_USE_PLUGIN_BUILTINS=1` の場合のみ
//! plugin_invoke を試し、解決できない場合はHostCallへフォールバックする。
#[derive(Debug, Clone)]
pub enum InvokeDecision {
@ -17,15 +16,7 @@ fn use_plugin_builtins() -> bool {
/// Decide invocation policy for a known Box method.
pub fn decide_box_method(box_type: &str, method: &str, argc: usize, has_ret: bool) -> InvokeDecision {
// Prefer plugin path when enabled and method is resolvable
if use_plugin_builtins() {
if let Ok(ph) = crate::runtime::plugin_loader_unified::get_global_plugin_host().read() {
if let Ok(h) = ph.resolve_method(box_type, method) {
return InvokeDecision::PluginInvoke { type_id: h.type_id, method_id: h.method_id, box_type: h.box_type, method: method.to_string(), argc, has_ret };
}
}
}
// Minimal hostcall mapping for common collections/math symbols
// HostCall mapping for common collections/strings/instance ops
let symbol = match (box_type, method) {
("ArrayBox", "length") | ("StringBox", "length") | ("StringBox", "len") => crate::jit::r#extern::collections::SYM_ANY_LEN_H,
("ArrayBox", "get") => crate::jit::r#extern::collections::SYM_ARRAY_GET_H,
@ -39,9 +30,18 @@ pub fn decide_box_method(box_type: &str, method: &str, argc: usize, has_ret: boo
("StringBox","charCodeAt") => crate::jit::r#extern::collections::SYM_STRING_CHARCODE_AT_H,
_ => "" // unknown
};
if symbol.is_empty() {
// Prefer HostCall when available
if !symbol.is_empty() {
InvokeDecision::HostCall { symbol: symbol.to_string(), argc, has_ret, reason: "mapped_symbol" }
} else if use_plugin_builtins() {
// Try plugin_invoke as a secondary path when enabled
if let Ok(ph) = crate::runtime::plugin_loader_unified::get_global_plugin_host().read() {
if let Ok(h) = ph.resolve_method(box_type, method) {
return InvokeDecision::PluginInvoke { type_id: h.type_id, method_id: h.method_id, box_type: h.box_type, method: method.to_string(), argc, has_ret };
}
}
InvokeDecision::Fallback { reason: "unknown_method" }
} else {
InvokeDecision::HostCall { symbol: symbol.to_string(), argc, has_ret, reason: "mapped_symbol" }
InvokeDecision::Fallback { reason: "unknown_method" }
}
}

241
src/mir/builder.rs
View File

@ -20,6 +20,13 @@ mod stmts;
mod ops;
mod utils;
mod exprs; // expression lowering split
mod decls; // declarations lowering split
mod fields; // field access/assignment lowering split
mod exprs_call; // call(expr)
mod exprs_qmark; // ?-propagate
mod exprs_peek; // peek expression
mod exprs_lambda; // lambda lowering
mod exprs_include; // include lowering
// moved helpers to builder/utils.rs
@ -72,7 +79,7 @@ pub struct MirBuilder {
}
impl MirBuilder {
/// Emit a Box method call (PluginInvoke unified)
/// Emit a Box method call (unified: BoxCall)
fn emit_box_or_plugin_call(
&mut self,
dst: Option<ValueId>,
@ -82,8 +89,7 @@ impl MirBuilder {
args: Vec<ValueId>,
effects: EffectMask,
) -> Result<(), String> {
let _ = method_id; // slot is no longer used in unified plugin invoke path
self.emit_instruction(MirInstruction::PluginInvoke { dst, box_val, method, args, effects })
self.emit_instruction(MirInstruction::BoxCall { dst, box_val, method, method_id, args, effects })
}
/// Create a new MIR builder
pub fn new() -> Self {
@ -336,7 +342,7 @@ impl MirBuilder {
// Lower: ok = expr.isOk(); br ok then else; else => return expr; then => expr.getValue()
let res_val = self.build_expression(*expression.clone())?;
let ok_id = self.value_gen.next();
self.emit_instruction(MirInstruction::PluginInvoke { dst: Some(ok_id), box_val: res_val, method: "isOk".to_string(), args: vec![], effects: EffectMask::PURE })?;
self.emit_instruction(MirInstruction::BoxCall { dst: Some(ok_id), box_val: res_val, method: "isOk".to_string(), method_id: None, args: vec![], effects: EffectMask::PURE })?;
let then_block = self.block_gen.next();
let else_block = self.block_gen.next();
self.emit_instruction(MirInstruction::Branch { condition: ok_id, then_bb: then_block, else_bb: else_block })?;
@ -348,7 +354,7 @@ impl MirBuilder {
self.current_block = Some(then_block);
self.ensure_block_exists(then_block)?;
let val_id = self.value_gen.next();
self.emit_instruction(MirInstruction::PluginInvoke { dst: Some(val_id), box_val: res_val, method: "getValue".to_string(), args: vec![], effects: EffectMask::PURE })?;
self.emit_instruction(MirInstruction::BoxCall { dst: Some(val_id), box_val: res_val, method: "getValue".to_string(), method_id: None, args: vec![], effects: EffectMask::PURE })?;
self.value_types.insert(val_id, super::MirType::Unknown);
Ok(val_id)
},
@ -720,18 +726,7 @@ impl MirBuilder {
}
}
/// Ensure a basic block exists in the current function
pub(super) fn ensure_block_exists(&mut self, block_id: BasicBlockId) -> Result<(), String> {
if let Some(ref mut function) = self.current_function {
if !function.blocks.contains_key(&block_id) {
let block = BasicBlock::new(block_id);
function.add_block(block);
}
Ok(())
} else {
Err("No current function".to_string())
}
}
// moved to builder/utils.rs: ensure_block_exists
// build_loop_statement_legacy moved to builder/stmts.rs
@ -743,109 +738,9 @@ impl MirBuilder {
// build_return_statement_legacy moved to builder/stmts.rs
/// Build static box (e.g., Main) - extracts main() method body and converts to Program
/// Also lowers other static methods into standalone MIR functions: BoxName.method/N
pub(super) fn build_static_main_box(&mut self, box_name: String, methods: std::collections::HashMap<String, ASTNode>) -> Result<ValueId, String> {
// Lower other static methods (except main) to standalone MIR functions so JIT can see them
for (mname, mast) in methods.iter() {
if mname == "main" { continue; }
if let ASTNode::FunctionDeclaration { params, body, .. } = mast {
let func_name = format!("{}.{}{}", box_name, mname, format!("/{}", params.len()));
self.lower_static_method_as_function(func_name, params.clone(), body.clone())?;
}
}
// Within this lowering, treat `me` receiver as this static box
let saved_static = self.current_static_box.clone();
self.current_static_box = Some(box_name.clone());
// Look for the main() method
let out = if let Some(main_method) = methods.get("main") {
if let ASTNode::FunctionDeclaration { params, body, .. } = main_method {
// Convert the method body to a Program AST node and lower it
let program_ast = ASTNode::Program {
statements: body.clone(),
span: crate::ast::Span::unknown(),
};
// Bind default parameters if present (e.g., args=[])
// Save current var map; inject defaults; restore after lowering
let saved_var_map = std::mem::take(&mut self.variable_map);
// Prepare defaults for known patterns
for p in params.iter() {
let pid = self.value_gen.next();
// Heuristic: for parameter named "args", create new ArrayBox(); else use Void
if p == "args" {
// new ArrayBox() -> pid
// Emit NewBox for ArrayBox with no args
self.emit_instruction(MirInstruction::NewBox { dst: pid, box_type: "ArrayBox".to_string(), args: vec![] })?;
} else {
self.emit_instruction(MirInstruction::Const { dst: pid, value: ConstValue::Void })?;
}
self.variable_map.insert(p.clone(), pid);
}
// Use existing Program lowering logic
let lowered = self.build_expression(program_ast);
// Restore variable map
self.variable_map = saved_var_map;
lowered
} else {
Err("main method in static box is not a FunctionDeclaration".to_string())
}
} else {
Err("static box must contain a main() method".to_string())
};
// Restore static box context
self.current_static_box = saved_static;
out
}
// moved to builder/decls.rs: build_static_main_box
/// Build field access: object.field
pub(super) fn build_field_access(&mut self, object: ASTNode, field: String) -> Result<ValueId, String> {
// Clone the object before building expression if we need to check it later
let object_clone = object.clone();
// First, build the object expression to get its ValueId
let object_value = self.build_expression(object)?;
// Get the field from the object using RefGet
let field_val = self.value_gen.next();
self.emit_instruction(MirInstruction::RefGet {
dst: field_val,
reference: object_value,
field: field.clone(),
})?;
// If we recorded origin class for this field on this base object, propagate it to this value id
if let Some(class_name) = self.field_origin_class.get(&(object_value, field.clone())).cloned() {
self.value_origin_newbox.insert(field_val, class_name);
}
// If we can infer the box type and the field is weak, emit WeakLoad (+ optional barrier)
let mut inferred_class: Option<String> = self.value_origin_newbox.get(&object_value).cloned();
// Fallback: if the object is a nested field access like (X.Y).Z, consult recorded field origins for X.Y
if inferred_class.is_none() {
if let ASTNode::FieldAccess { object: inner_obj, field: ref parent_field, .. } = object_clone {
// Build inner base to get a stable id and consult mapping
if let Ok(base_id) = self.build_expression(*inner_obj.clone()) {
if let Some(cls) = self.field_origin_class.get(&(base_id, parent_field.clone())) {
inferred_class = Some(cls.clone());
}
}
}
}
if let Some(class_name) = inferred_class {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) {
// Barrier (read) PoC
let _ = self.emit_barrier_read(field_val);
// WeakLoad
let loaded = self.emit_weak_load(field_val)?;
return Ok(loaded);
}
}
}
Ok(field_val)
}
// moved to builder/fields.rs: build_field_access
/// Build new expression: new ClassName(arguments)
pub(super) fn build_new_expression(&mut self, class: String, arguments: Vec<ASTNode>) -> Result<ValueId, String> {
@ -906,56 +801,9 @@ impl MirBuilder {
Ok(dst)
}
/// Build field assignment: object.field = value
pub(super) fn build_field_assignment(&mut self, object: ASTNode, field: String, value: ASTNode) -> Result<ValueId, String> {
// Build the object and value expressions
let object_value = self.build_expression(object)?;
let mut value_result = self.build_expression(value)?;
// If we can infer the box type and the field is weak, create WeakRef before store
if let Some(class_name) = self.value_origin_newbox.get(&object_value).cloned() {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) {
value_result = self.emit_weak_new(value_result)?;
}
}
}
// Set the field using RefSet
self.emit_instruction(MirInstruction::RefSet {
reference: object_value,
field: field.clone(),
value: value_result,
})?;
// Emit a write barrier for weak fields (PoC)
if let Some(class_name) = self.value_origin_newbox.get(&object_value).cloned() {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) {
let _ = self.emit_barrier_write(value_result);
}
}
}
// Record origin class for this field (if the value originates from NewBox of a known class)
if let Some(class_name) = self.value_origin_newbox.get(&value_result).cloned() {
self.field_origin_class.insert((object_value, field.clone()), class_name);
}
// Return the assigned value
Ok(value_result)
}
// moved to builder/fields.rs: build_field_assignment
/// Start a new basic block
pub(super) fn start_new_block(&mut self, block_id: BasicBlockId) -> Result<(), String> {
if let Some(ref mut function) = self.current_function {
function.add_block(BasicBlock::new(block_id));
self.current_block = Some(block_id);
Ok(())
} else {
Err("No current function".to_string())
}
}
// moved to builder/utils.rs: start_new_block
/// Check if the current basic block is terminated
fn is_current_block_terminated(&self) -> bool {
@ -984,62 +832,7 @@ impl MirBuilder {
// lower_static_method_as_function_legacy removed (use builder_calls::lower_static_method_as_function)
/// Build box declaration: box Name { fields... methods... }
pub(super) fn build_box_declaration(&mut self, name: String, methods: std::collections::HashMap<String, ASTNode>, fields: Vec<String>, weak_fields: Vec<String>) -> Result<(), String> {
// For Phase 8.4, we'll emit metadata instructions to register the box type
// In a full implementation, this would register type information for later use
// Create a type registration constant
let type_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const {
dst: type_id,
value: ConstValue::String(format!("__box_type_{}", name)),
})?;
// For each field, emit metadata about the field
for field in fields {
let field_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const {
dst: field_id,
value: ConstValue::String(format!("__field_{}_{}", name, field)),
})?;
}
// Record weak fields for this box
if !weak_fields.is_empty() {
let set: HashSet<String> = weak_fields.into_iter().collect();
self.weak_fields_by_box.insert(name.clone(), set);
}
// Reserve method slots for user-defined instance methods (deterministic, starts at 4)
let mut instance_methods: Vec<String> = Vec::new();
for (mname, mast) in &methods {
if let ASTNode::FunctionDeclaration { is_static, .. } = mast {
if !*is_static { instance_methods.push(mname.clone()); }
}
}
instance_methods.sort();
if !instance_methods.is_empty() {
let tyid = get_or_assign_type_id(&name);
for (i, m) in instance_methods.iter().enumerate() {
let slot = 4u16.saturating_add(i as u16);
reserve_method_slot(tyid, m, slot);
}
}
// Process methods - now methods is a HashMap
for (method_name, method_ast) in methods {
if let ASTNode::FunctionDeclaration { .. } = method_ast {
let method_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const {
dst: method_id,
value: ConstValue::String(format!("__method_{}_{}", name, method_name)),
})?;
}
}
Ok(())
}
// moved to builder/decls.rs: build_box_declaration
}
// BinaryOpType moved to builder/ops.rs

107
src/mir/builder/decls.rs Normal file
View File

@ -0,0 +1,107 @@
// Declarations lowering: static boxes and box declarations
use super::{MirInstruction, ConstValue, ValueId, BasicBlockId};
use crate::ast::ASTNode;
use std::collections::HashSet;
use crate::mir::slot_registry::{get_or_assign_type_id, reserve_method_slot};
impl super::MirBuilder {
/// Build static box (e.g., Main) - extracts main() method body and converts to Program
/// Also lowers other static methods into standalone MIR functions: BoxName.method/N
pub(super) fn build_static_main_box(
&mut self,
box_name: String,
methods: std::collections::HashMap<String, ASTNode>,
) -> Result<ValueId, String> {
// Lower other static methods (except main) to standalone MIR functions so JIT can see them
for (mname, mast) in methods.iter() {
if mname == "main" { continue; }
if let ASTNode::FunctionDeclaration { params, body, .. } = mast {
let func_name = format!("{}.{}{}", box_name, mname, format!("/{}", params.len()));
self.lower_static_method_as_function(func_name, params.clone(), body.clone())?;
}
}
// Within this lowering, treat `me` receiver as this static box
let saved_static = self.current_static_box.clone();
self.current_static_box = Some(box_name.clone());
// Look for the main() method
let out = if let Some(main_method) = methods.get("main") {
if let ASTNode::FunctionDeclaration { params, body, .. } = main_method {
// Convert the method body to a Program AST node and lower it
let program_ast = ASTNode::Program { statements: body.clone(), span: crate::ast::Span::unknown() };
// Bind default parameters if present (e.g., args=[])
let saved_var_map = std::mem::take(&mut self.variable_map);
for p in params.iter() {
let pid = self.value_gen.next();
if p == "args" {
// new ArrayBox() with no args
self.emit_instruction(MirInstruction::NewBox { dst: pid, box_type: "ArrayBox".to_string(), args: vec![] })?;
} else {
self.emit_instruction(MirInstruction::Const { dst: pid, value: ConstValue::Void })?;
}
self.variable_map.insert(p.clone(), pid);
}
let lowered = self.build_expression(program_ast);
self.variable_map = saved_var_map;
lowered
} else {
Err("main method in static box is not a FunctionDeclaration".to_string())
}
} else {
Err("static box must contain a main() method".to_string())
};
// Restore static box context
self.current_static_box = saved_static;
out
}
/// Build box declaration: box Name { fields... methods... }
pub(super) fn build_box_declaration(
&mut self,
name: String,
methods: std::collections::HashMap<String, ASTNode>,
fields: Vec<String>,
weak_fields: Vec<String>,
) -> Result<(), String> {
// Create a type registration constant (marker)
let type_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: type_id, value: ConstValue::String(format!("__box_type_{}", name)) })?;
// Emit field metadata markers
for field in fields {
let field_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: field_id, value: ConstValue::String(format!("__field_{}_{}", name, field)) })?;
}
// Record weak fields for this box
if !weak_fields.is_empty() {
let set: HashSet<String> = weak_fields.into_iter().collect();
self.weak_fields_by_box.insert(name.clone(), set);
}
// Reserve method slots for user-defined instance methods (deterministic, starts at 4)
let mut instance_methods: Vec<String> = Vec::new();
for (mname, mast) in &methods {
if let ASTNode::FunctionDeclaration { is_static, .. } = mast {
if !*is_static { instance_methods.push(mname.clone()); }
}
}
instance_methods.sort();
if !instance_methods.is_empty() {
let tyid = get_or_assign_type_id(&name);
for (i, m) in instance_methods.iter().enumerate() {
let slot = 4u16.saturating_add(i as u16);
reserve_method_slot(tyid, m, slot);
}
}
// Emit markers for declared methods (kept as metadata hints)
for (method_name, method_ast) in methods {
if let ASTNode::FunctionDeclaration { .. } = method_ast {
let method_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: method_id, value: ConstValue::String(format!("__method_{}_{}", name, method_name)) })?;
}
}
Ok(())
}
}

181
src/mir/builder/exprs.rs
View File

@ -5,6 +5,16 @@ use crate::ast::{ASTNode, LiteralValue};
impl super::MirBuilder {
// Main expression dispatcher
pub(super) fn build_expression_impl(&mut self, ast: ASTNode) -> Result<ValueId, String> {
if matches!(ast,
ASTNode::Program { .. }
| ASTNode::Print { .. }
| ASTNode::If { .. }
| ASTNode::Loop { .. }
| ASTNode::TryCatch { .. }
| ASTNode::Throw { .. }
) {
return self.build_expression_impl_legacy(ast);
}
match ast {
ASTNode::Literal { value, .. } => self.build_literal(value),
@ -53,116 +63,17 @@ impl super::MirBuilder {
ASTNode::FunctionCall { name, arguments, .. } =>
self.build_function_call(name.clone(), arguments.clone()),
ASTNode::Call { callee, arguments, .. } => {
let mut arg_ids: Vec<ValueId> = Vec::new();
let callee_id = self.build_expression_impl(*callee.clone())?;
for a in arguments { arg_ids.push(self.build_expression_impl(a)?); }
let dst = self.value_gen.next();
self.emit_instruction(MirInstruction::Call { dst: Some(dst), func: callee_id, args: arg_ids, effects: crate::mir::EffectMask::PURE })?;
Ok(dst)
}
ASTNode::Call { callee, arguments, .. } =>
self.build_indirect_call_expression(*callee.clone(), arguments.clone()),
ASTNode::QMarkPropagate { expression, .. } => {
let res_val = self.build_expression_impl(*expression.clone())?;
let ok_id = self.value_gen.next();
self.emit_instruction(MirInstruction::PluginInvoke { dst: Some(ok_id), box_val: res_val, method: "isOk".to_string(), args: vec![], effects: crate::mir::EffectMask::PURE })?;
let then_block = self.block_gen.next();
let else_block = self.block_gen.next();
self.emit_instruction(MirInstruction::Branch { condition: ok_id, then_bb: then_block, else_bb: else_block })?;
self.start_new_block(then_block)?;
self.emit_instruction(MirInstruction::Return { value: Some(res_val) })?;
self.start_new_block(else_block)?;
let val_id = self.value_gen.next();
self.emit_instruction(MirInstruction::PluginInvoke { dst: Some(val_id), box_val: res_val, method: "getValue".to_string(), args: vec![], effects: crate::mir::EffectMask::PURE })?;
Ok(val_id)
}
ASTNode::QMarkPropagate { expression, .. } =>
self.build_qmark_propagate_expression(*expression.clone()),
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } => {
let scr_val = self.build_expression_impl(*scrutinee.clone())?;
let merge_block: BasicBlockId = self.block_gen.next();
let result_val = self.value_gen.next();
let mut phi_inputs: Vec<(BasicBlockId, ValueId)> = Vec::new();
let mut next_block = self.block_gen.next();
self.start_new_block(next_block)?;
for (i, (label, arm_expr)) in arms.iter().enumerate() {
let then_block = self.block_gen.next();
if let LiteralValue::String(ref s) = label {
let lit_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: lit_id, value: ConstValue::String(s.clone()) })?;
let cond_id = self.value_gen.next();
self.emit_instruction(crate::mir::MirInstruction::Compare { dst: cond_id, op: crate::mir::CompareOp::Eq, lhs: scr_val, rhs: lit_id })?;
self.emit_instruction(crate::mir::MirInstruction::Branch { condition: cond_id, then_bb: then_block, else_bb: next_block })?;
self.start_new_block(then_block)?;
let then_val = self.build_expression_impl(arm_expr.clone())?;
phi_inputs.push((then_block, then_val));
self.emit_instruction(crate::mir::MirInstruction::Jump { target: merge_block })?;
if i < arms.len() - 1 { let b = self.block_gen.next(); self.start_new_block(b)?; next_block = b; }
}
}
let else_block_id = next_block; self.start_new_block(else_block_id)?;
let else_val = self.build_expression_impl(*else_expr.clone())?;
phi_inputs.push((else_block_id, else_val));
self.emit_instruction(crate::mir::MirInstruction::Jump { target: merge_block })?;
self.start_new_block(merge_block)?;
self.emit_instruction(crate::mir::MirInstruction::Phi { dst: result_val, inputs: phi_inputs })?;
Ok(result_val)
}
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } =>
self.build_peek_expression(*scrutinee.clone(), arms.clone(), *else_expr.clone()),
ASTNode::Lambda { params, body, .. } => {
use std::collections::HashSet;
let mut used: HashSet<String> = HashSet::new();
let mut locals: HashSet<String> = HashSet::new(); for p in &params { locals.insert(p.clone()); }
fn collect_vars(ast: &ASTNode, used: &mut std::collections::HashSet<String>, locals: &mut std::collections::HashSet<String>) {
match ast {
ASTNode::Variable { name, .. } => { if !locals.contains(name) { used.insert(name.clone()); } }
ASTNode::Assignment { target, value, .. } => { collect_vars(target, used, locals); collect_vars(value, used, locals); }
ASTNode::BinaryOp { left, right, .. } => { collect_vars(left, used, locals); collect_vars(right, used, locals); }
ASTNode::UnaryOp { operand, .. } => { collect_vars(operand, used, locals); }
ASTNode::MethodCall { object, arguments, .. } => { collect_vars(object, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FunctionCall { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::Call { callee, arguments, .. } => { collect_vars(callee, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FieldAccess { object, .. } => { collect_vars(object, used, locals); }
ASTNode::New { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::If { condition, then_body, else_body, .. } => {
collect_vars(condition, used, locals);
for st in then_body { collect_vars(st, used, locals); }
if let Some(eb) = else_body { for st in eb { collect_vars(st, used, locals); } }
}
ASTNode::Loop { condition, body, .. } => { collect_vars(condition, used, locals); for st in body { collect_vars(st, used, locals); } }
ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } => {
for st in try_body { collect_vars(st, used, locals); }
for c in catch_clauses { for st in &c.body { collect_vars(st, used, locals); } }
if let Some(fb) = finally_body { for st in fb { collect_vars(st, used, locals); } }
}
ASTNode::Throw { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Print { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Return { value, .. } => { if let Some(v) = value { collect_vars(v, used, locals); } }
ASTNode::AwaitExpression { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } => {
collect_vars(scrutinee, used, locals);
for (_, e) in arms { collect_vars(e, used, locals); }
collect_vars(else_expr, used, locals);
}
ASTNode::Program { statements, .. } => { for st in statements { collect_vars(st, used, locals); } }
ASTNode::FunctionDeclaration { params, body, .. } => {
let mut inner = locals.clone();
for p in params { inner.insert(p.clone()); }
for st in body { collect_vars(st, used, &mut inner); }
}
_ => {}
}
}
for st in body.iter() { collect_vars(st, &mut used, &mut locals); }
let mut captures: Vec<(String, ValueId)> = Vec::new();
for name in used.into_iter() {
if let Some(&vid) = self.variable_map.get(&name) { captures.push((name, vid)); }
}
let me = self.variable_map.get("me").copied();
let dst = self.value_gen.next();
self.emit_instruction(MirInstruction::FunctionNew { dst, params: params.clone(), body: body.clone(), captures, me })?;
self.value_types.insert(dst, crate::mir::MirType::Box("FunctionBox".to_string()));
Ok(dst)
}
ASTNode::Lambda { params, body, .. } =>
self.build_lambda_expression(params.clone(), body.clone()),
ASTNode::Return { value, .. } => self.build_return_statement(value.clone()),
@ -207,37 +118,35 @@ impl super::MirBuilder {
ASTNode::AwaitExpression { expression, .. } =>
self.build_await_expression(*expression.clone()),
ASTNode::Include { filename, .. } => {
let mut path = super::utils::resolve_include_path_builder(&filename);
if std::path::Path::new(&path).is_dir() {
path = format!("{}/index.nyash", path.trim_end_matches('/'));
} else if std::path::Path::new(&path).extension().is_none() {
path.push_str(".nyash");
}
if self.include_loading.contains(&path) {
return Err(format!("Circular include detected: {}", path));
}
if let Some(name) = self.include_box_map.get(&path).cloned() {
return self.build_new_expression(name, vec![]);
}
self.include_loading.insert(path.clone());
let content = std::fs::read_to_string(&path)
.map_err(|e| format!("Include read error '{}': {}", filename, e))?;
let included_ast = crate::parser::NyashParser::parse_from_string(&content)
.map_err(|e| format!("Include parse error '{}': {:?}", filename, e))?;
let mut box_name: Option<String> = None;
if let ASTNode::Program { statements, .. } = &included_ast {
for st in statements {
if let ASTNode::BoxDeclaration { name, is_static, .. } = st { if *is_static { box_name = Some(name.clone()); break; } }
}
}
let bname = box_name.ok_or_else(|| format!("Include target '{}' has no static box", filename))?;
let _ = self.build_expression_impl(included_ast)?;
self.include_loading.remove(&path);
self.include_box_map.insert(path.clone(), bname.clone());
self.build_new_expression(bname, vec![])
ASTNode::Include { filename, .. } =>
self.build_include_expression(filename.clone()),
ASTNode::Program { statements, .. } =>
self.build_block(statements.clone()),
ASTNode::Print { expression, .. } =>
self.build_print_statement(*expression.clone()),
ASTNode::If { condition, then_body, else_body, .. } => {
let else_ast = if let Some(else_statements) = else_body {
Some(ASTNode::Program { statements: else_statements.clone(), span: crate::ast::Span::unknown() })
} else { None };
self.build_if_statement(
*condition.clone(),
ASTNode::Program { statements: then_body.clone(), span: crate::ast::Span::unknown() },
else_ast,
)
}
ASTNode::Loop { condition, body, .. } =>
self.build_loop_statement(*condition.clone(), body.clone()),
ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } =>
self.build_try_catch_statement(try_body.clone(), catch_clauses.clone(), finally_body.clone()),
ASTNode::Throw { expression, .. } =>
self.build_throw_statement(*expression.clone()),
_ => Err(format!("Unsupported AST node type: {:?}", ast)),
}
}

24
src/mir/builder/exprs_call.rs Normal file
View File

@ -0,0 +1,24 @@
use super::ValueId;
use crate::ast::ASTNode;
impl super::MirBuilder {
// Indirect call: (callee)(args...)
pub(super) fn build_indirect_call_expression(
&mut self,
callee: ASTNode,
arguments: Vec<ASTNode>,
) -> Result<ValueId, String> {
let callee_id = self.build_expression_impl(callee)?;
let mut arg_ids: Vec<ValueId> = Vec::new();
for a in arguments { arg_ids.push(self.build_expression_impl(a)?); }
let dst = self.value_gen.next();
self.emit_instruction(super::MirInstruction::Call {
dst: Some(dst),
func: callee_id,
args: arg_ids,
effects: super::EffectMask::PURE,
})?;
Ok(dst)
}
}

27
src/mir/builder/exprs_include.rs Normal file
View File

@ -0,0 +1,27 @@
use super::ValueId;
impl super::MirBuilder {
// Include lowering: include "path"
pub(super) fn build_include_expression(&mut self, filename: String) -> Result<ValueId, String> {
let mut path = super::utils::resolve_include_path_builder(&filename);
if std::path::Path::new(&path).is_dir() { path = format!("{}/index.nyash", path.trim_end_matches('/')); }
else if std::path::Path::new(&path).extension().is_none() { path.push_str(".nyash"); }
if self.include_loading.contains(&path) { return Err(format!("Circular include detected: {}", path)); }
if let Some(name) = self.include_box_map.get(&path).cloned() { return self.build_new_expression(name, vec![]); }
self.include_loading.insert(path.clone());
let content = std::fs::read_to_string(&path).map_err(|e| format!("Include read error '{}': {}", filename, e))?;
let included_ast = crate::parser::NyashParser::parse_from_string(&content).map_err(|e| format!("Include parse error '{}': {:?}", filename, e))?;
let mut box_name: Option<String> = None;
if let crate::ast::ASTNode::Program { statements, .. } = &included_ast {
for st in statements { if let crate::ast::ASTNode::BoxDeclaration { name, is_static, .. } = st { if *is_static { box_name = Some(name.clone()); break; } } }
}
let bname = box_name.ok_or_else(|| format!("Include target '{}' has no static box", filename))?;
let _ = self.build_expression_impl(included_ast)?;
self.include_loading.remove(&path);
self.include_box_map.insert(path.clone(), bname.clone());
self.build_new_expression(bname, vec![])
}
}

67
src/mir/builder/exprs_lambda.rs Normal file
View File

@ -0,0 +1,67 @@
use super::ValueId;
use crate::ast::ASTNode;
impl super::MirBuilder {
// Lambda lowering to FunctionNew
pub(super) fn build_lambda_expression(
&mut self,
params: Vec<String>,
body: Vec<ASTNode>,
) -> Result<ValueId, String> {
use std::collections::HashSet;
let mut used: HashSet<String> = HashSet::new();
let mut locals: HashSet<String> = HashSet::new();
for p in &params { locals.insert(p.clone()); }
fn collect_vars(ast: &ASTNode, used: &mut std::collections::HashSet<String>, locals: &mut std::collections::HashSet<String>) {
match ast {
ASTNode::Variable { name, .. } => { if !locals.contains(name) { used.insert(name.clone()); } }
ASTNode::Assignment { target, value, .. } => { collect_vars(target, used, locals); collect_vars(value, used, locals); }
ASTNode::BinaryOp { left, right, .. } => { collect_vars(left, used, locals); collect_vars(right, used, locals); }
ASTNode::UnaryOp { operand, .. } => { collect_vars(operand, used, locals); }
ASTNode::MethodCall { object, arguments, .. } => { collect_vars(object, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FunctionCall { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::Call { callee, arguments, .. } => { collect_vars(callee, used, locals); for a in arguments { collect_vars(a, used, locals); } }
ASTNode::FieldAccess { object, .. } => { collect_vars(object, used, locals); }
ASTNode::New { arguments, .. } => { for a in arguments { collect_vars(a, used, locals); } }
ASTNode::If { condition, then_body, else_body, .. } => {
collect_vars(condition, used, locals);
for st in then_body { collect_vars(st, used, locals); }
if let Some(eb) = else_body { for st in eb { collect_vars(st, used, locals); } }
}
ASTNode::Loop { condition, body, .. } => { collect_vars(condition, used, locals); for st in body { collect_vars(st, used, locals); } }
ASTNode::TryCatch { try_body, catch_clauses, finally_body, .. } => {
for st in try_body { collect_vars(st, used, locals); }
for c in catch_clauses { for st in &c.body { collect_vars(st, used, locals); } }
if let Some(fb) = finally_body { for st in fb { collect_vars(st, used, locals); } }
}
ASTNode::Throw { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Print { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::Return { value, .. } => { if let Some(v) = value { collect_vars(v, used, locals); } }
ASTNode::AwaitExpression { expression, .. } => { collect_vars(expression, used, locals); }
ASTNode::PeekExpr { scrutinee, arms, else_expr, .. } => {
collect_vars(scrutinee, used, locals);
for (_, e) in arms { collect_vars(e, used, locals); }
collect_vars(else_expr, used, locals);
}
ASTNode::Program { statements, .. } => { for st in statements { collect_vars(st, used, locals); } }
ASTNode::FunctionDeclaration { params, body, .. } => {
let mut inner = locals.clone();
for p in params { inner.insert(p.clone()); }
for st in body { collect_vars(st, used, &mut inner); }
}
_ => {}
}
}
for st in body.iter() { collect_vars(st, &mut used, &mut locals); }
let mut captures: Vec<(String, ValueId)> = Vec::new();
for name in used.into_iter() {
if let Some(&vid) = self.variable_map.get(&name) { captures.push((name, vid)); }
}
let me = self.variable_map.get("me").copied();
let dst = self.value_gen.next();
self.emit_instruction(super::MirInstruction::FunctionNew { dst, params: params.clone(), body: body.clone(), captures, me })?;
self.value_types.insert(dst, crate::mir::MirType::Box("FunctionBox".to_string()));
Ok(dst)
}
}

50
src/mir/builder/exprs_peek.rs Normal file
View File

@ -0,0 +1,50 @@
use super::{BasicBlockId, ValueId};
use crate::ast::{ASTNode, LiteralValue};
impl super::MirBuilder {
// Peek expression lowering
pub(super) fn build_peek_expression(
&mut self,
scrutinee: ASTNode,
arms: Vec<(LiteralValue, ASTNode)>,
else_expr: ASTNode,
) -> Result<ValueId, String> {
let scr_val = self.build_expression_impl(scrutinee)?;
let merge_block: BasicBlockId = self.block_gen.next();
let result_val = self.value_gen.next();
let mut phi_inputs: Vec<(BasicBlockId, ValueId)> = Vec::new();
let mut next_block = self.block_gen.next();
self.start_new_block(next_block)?;
for (i, (label, arm_expr)) in arms.iter().cloned().enumerate() {
let then_block = self.block_gen.next();
// Only string labels handled here (behavior unchanged)
if let LiteralValue::String(s) = label {
let lit_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::Const { dst: lit_id, value: super::ConstValue::String(s) })?;
let cond_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::Compare { dst: cond_id, op: super::CompareOp::Eq, lhs: scr_val, rhs: lit_id })?;
self.emit_instruction(super::MirInstruction::Branch { condition: cond_id, then_bb: then_block, else_bb: next_block })?;
self.start_new_block(then_block)?;
let then_val = self.build_expression_impl(arm_expr)?;
phi_inputs.push((then_block, then_val));
self.emit_instruction(super::MirInstruction::Jump { target: merge_block })?;
if i < arms.len() - 1 {
let b = self.block_gen.next();
self.start_new_block(b)?;
next_block = b;
}
}
}
let else_block_id = next_block;
self.start_new_block(else_block_id)?;
let else_val = self.build_expression_impl(else_expr)?;
phi_inputs.push((else_block_id, else_val));
self.emit_instruction(super::MirInstruction::Jump { target: merge_block })?;
self.start_new_block(merge_block)?;
self.emit_instruction(super::MirInstruction::Phi { dst: result_val, inputs: phi_inputs })?;
Ok(result_val)
}
}

34
src/mir/builder/exprs_qmark.rs Normal file
View File

@ -0,0 +1,34 @@
use super::ValueId;
use crate::ast::ASTNode;
impl super::MirBuilder {
// QMarkPropagate: result?.value (Result-like)
pub(super) fn build_qmark_propagate_expression(&mut self, expression: ASTNode) -> Result<ValueId, String> {
let res_val = self.build_expression_impl(expression)?;
let ok_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::BoxCall {
dst: Some(ok_id),
box_val: res_val,
method: "isOk".to_string(),
args: vec![],
method_id: None,
effects: super::EffectMask::PURE,
})?;
let then_block = self.block_gen.next();
let else_block = self.block_gen.next();
self.emit_instruction(super::MirInstruction::Branch { condition: ok_id, then_bb: then_block, else_bb: else_block })?;
self.start_new_block(then_block)?;
self.emit_instruction(super::MirInstruction::Return { value: Some(res_val) })?;
self.start_new_block(else_block)?;
let val_id = self.value_gen.next();
self.emit_instruction(super::MirInstruction::BoxCall {
dst: Some(val_id),
box_val: res_val,
method: "getValue".to_string(),
args: vec![],
method_id: None,
effects: super::EffectMask::PURE,
})?;
Ok(val_id)
}
}

92
src/mir/builder/fields.rs Normal file
View File

@ -0,0 +1,92 @@
// Field access and assignment lowering
use super::{MirInstruction, ConstValue, ValueId, EffectMask};
use crate::mir::slot_registry;
use crate::ast::ASTNode;
impl super::MirBuilder {
/// Build field access: object.field
pub(super) fn build_field_access(&mut self, object: ASTNode, field: String) -> Result<ValueId, String> {
let object_clone = object.clone();
let object_value = self.build_expression(object)?;
// Emit: field name const
let field_name_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: field_name_id, value: ConstValue::String(field.clone()) })?;
// BoxCall: getField(name)
let field_val = self.value_gen.next();
self.emit_instruction(MirInstruction::BoxCall {
dst: Some(field_val),
box_val: object_value,
method: "getField".to_string(),
method_id: slot_registry::resolve_slot_by_type_name("InstanceBox", "getField"),
args: vec![field_name_id],
effects: EffectMask::READ,
})?;
// Propagate recorded origin class for this field if any
if let Some(class_name) = self.field_origin_class.get(&(object_value, field.clone())).cloned() {
self.value_origin_newbox.insert(field_val, class_name);
}
// If base is a known newbox and field is weak, emit WeakLoad (+ optional barrier)
let mut inferred_class: Option<String> = self.value_origin_newbox.get(&object_value).cloned();
if inferred_class.is_none() {
if let ASTNode::FieldAccess { object: inner_obj, field: inner_field, .. } = object_clone {
if let Ok(base_id) = self.build_expression(*inner_obj.clone()) {
if let Some(cls) = self.field_origin_class.get(&(base_id, inner_field)).cloned() { inferred_class = Some(cls); }
}
}
}
if let Some(class_name) = inferred_class {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) {
let loaded = self.emit_weak_load(field_val)?;
let _ = self.emit_barrier_read(loaded);
return Ok(loaded);
}
}
}
Ok(field_val)
}
/// Build field assignment: object.field = value
pub(super) fn build_field_assignment(&mut self, object: ASTNode, field: String, value: ASTNode) -> Result<ValueId, String> {
let object_value = self.build_expression(object)?;
let mut value_result = self.build_expression(value)?;
// If base is known and field is weak, create WeakRef before store
if let Some(class_name) = self.value_origin_newbox.get(&object_value).cloned() {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) { value_result = self.emit_weak_new(value_result)?; }
}
}
// Emit: field name const
let field_name_id = self.value_gen.next();
self.emit_instruction(MirInstruction::Const { dst: field_name_id, value: ConstValue::String(field.clone()) })?;
// Set the field via BoxCall: setField(name, value)
self.emit_instruction(MirInstruction::BoxCall {
dst: None,
box_val: object_value,
method: "setField".to_string(),
method_id: slot_registry::resolve_slot_by_type_name("InstanceBox", "setField"),
args: vec![field_name_id, value_result],
effects: EffectMask::WRITE,
})?;
// Write barrier if weak field
if let Some(class_name) = self.value_origin_newbox.get(&object_value).cloned() {
if let Some(weak_set) = self.weak_fields_by_box.get(&class_name) {
if weak_set.contains(&field) { let _ = self.emit_barrier_write(value_result); }
}
}
// Record origin class for this field value if known
if let Some(class_name) = self.value_origin_newbox.get(&value_result).cloned() {
self.field_origin_class.insert((object_value, field.clone()), class_name);
}
Ok(value_result)
}
}

27
src/mir/builder/utils.rs
View File

@ -1,4 +1,5 @@
use std::fs;
use super::{BasicBlock, BasicBlockId};
// Resolve include path using nyash.toml include.roots if present
pub(super) fn resolve_include_path_builder(filename: &str) -> String {
@ -63,3 +64,29 @@ pub(super) fn infer_type_from_phi(
None
}
// Lightweight helpers moved from builder.rs to reduce file size
impl super::MirBuilder {
/// Ensure a basic block exists in the current function
pub(crate) fn ensure_block_exists(&mut self, block_id: BasicBlockId) -> Result<(), String> {
if let Some(ref mut function) = self.current_function {
if !function.blocks.contains_key(&block_id) {
let block = BasicBlock::new(block_id);
function.add_block(block);
}
Ok(())
} else {
Err("No current function".to_string())
}
}
/// Start a new basic block and set as current
pub(crate) fn start_new_block(&mut self, block_id: BasicBlockId) -> Result<(), String> {
if let Some(ref mut function) = self.current_function {
function.add_block(BasicBlock::new(block_id));
self.current_block = Some(block_id);
Ok(())
} else {
Err("No current function".to_string())
}
}
}

34
src/mir/instruction_introspection.rs
View File

@ -63,6 +63,30 @@ pub fn core15_instruction_names() -> &'static [&'static str] {
]
}
/// Returns the Core-13 instruction names (final minimal kernel).
/// This is the fixed target set used for MIR unification.
pub fn core13_instruction_names() -> &'static [&'static str] {
&[
// 値/計算
"Const",
"BinOp",
"Compare",
// 制御
"Jump",
"Branch",
"Return",
"Phi",
// 呼び出し
"Call",
"BoxCall",
"ExternCall",
// メタ
"TypeOp",
"Safepoint",
"Barrier",
]
}
#[cfg(test)]
mod tests {
use super::*;
@ -79,4 +103,14 @@ mod tests {
let set: BTreeSet<_> = impl_names.iter().copied().collect();
for must in ["Const", "BinOp", "Return", "ExternCall"] { assert!(set.contains(must), "missing '{}'", must); }
}
#[test]
fn core13_instruction_count_is_13() {
let impl_names = core13_instruction_names();
assert_eq!(impl_names.len(), 13, "Core-13 must contain exactly 13 instructions");
let set: BTreeSet<_> = impl_names.iter().copied().collect();
for must in ["Const", "BinOp", "Return", "BoxCall", "ExternCall", "TypeOp"] {
assert!(set.contains(must), "missing '{}'", must);
}
}
}

42
src/mir/mod.rs
View File

@ -82,6 +82,48 @@ impl MirCompiler {
return Err(format!("Diagnostic failure: {} issues detected (unlowered/legacy)", stats.diagnostics_reported));
}
}
// Core-13 strict: forbid legacy ops in final MIR when enabled
if crate::config::env::mir_core13() || crate::config::env::opt_diag_forbid_legacy() {
let mut legacy_count = 0usize;
for (_fname, function) in &module.functions {
for (_bb, block) in &function.blocks {
for inst in &block.instructions {
if matches!(inst,
MirInstruction::TypeCheck { .. }
| MirInstruction::Cast { .. }
| MirInstruction::WeakNew { .. }
| MirInstruction::WeakLoad { .. }
| MirInstruction::BarrierRead { .. }
| MirInstruction::BarrierWrite { .. }
| MirInstruction::ArrayGet { .. }
| MirInstruction::ArraySet { .. }
| MirInstruction::RefGet { .. }
| MirInstruction::RefSet { .. }
| MirInstruction::PluginInvoke { .. }
) { legacy_count += 1; }
}
if let Some(term) = &block.terminator {
if matches!(term,
MirInstruction::TypeCheck { .. }
| MirInstruction::Cast { .. }
| MirInstruction::WeakNew { .. }
| MirInstruction::WeakLoad { .. }
| MirInstruction::BarrierRead { .. }
| MirInstruction::BarrierWrite { .. }
| MirInstruction::ArrayGet { .. }
| MirInstruction::ArraySet { .. }
| MirInstruction::RefGet { .. }
| MirInstruction::RefSet { .. }
| MirInstruction::PluginInvoke { .. }
) { legacy_count += 1; }
}
}
}
if legacy_count > 0 {
return Err(format!("Core-13 strict: final MIR contains {} legacy ops", legacy_count));
}
}
// Verify the generated MIR
let verification_result = self.verifier.verify_module(&module);

23
src/mir/optimizer.rs
View File

@ -731,8 +731,8 @@ impl MirOptimizer {
stats
}
/// Diagnostic: detect legacy instructions that should be unified into the canonical 26
/// Legacy set: TypeCheck/Cast/WeakNew/WeakLoad/BarrierRead/BarrierWrite
/// Diagnostic: detect legacy instructions that should be unified
/// Legacy set: TypeCheck/Cast/WeakNew/WeakLoad/BarrierRead/BarrierWrite/ArrayGet/ArraySet/RefGet/RefSet/PluginInvoke
/// When NYASH_OPT_DIAG or NYASH_OPT_DIAG_FORBID_LEGACY is set, prints diagnostics.
fn diagnose_legacy_instructions(&mut self, module: &MirModule) -> OptimizationStats {
let mut stats = OptimizationStats::new();
@ -749,7 +749,12 @@ impl MirOptimizer {
| MirInstruction::WeakNew { .. }
| MirInstruction::WeakLoad { .. }
| MirInstruction::BarrierRead { .. }
| MirInstruction::BarrierWrite { .. } => { count += 1; }
| MirInstruction::BarrierWrite { .. }
| MirInstruction::ArrayGet { .. }
| MirInstruction::ArraySet { .. }
| MirInstruction::RefGet { .. }
| MirInstruction::RefSet { .. }
| MirInstruction::PluginInvoke { .. } => { count += 1; }
_ => {}
}
}
@ -760,7 +765,12 @@ impl MirOptimizer {
| MirInstruction::WeakNew { .. }
| MirInstruction::WeakLoad { .. }
| MirInstruction::BarrierRead { .. }
| MirInstruction::BarrierWrite { .. } => { count += 1; }
| MirInstruction::BarrierWrite { .. }
| MirInstruction::ArrayGet { .. }
| MirInstruction::ArraySet { .. }
| MirInstruction::RefGet { .. }
| MirInstruction::RefSet { .. }
| MirInstruction::PluginInvoke { .. } => { count += 1; }
_ => {}
}
}
@ -769,9 +779,12 @@ impl MirOptimizer {
stats.diagnostics_reported += count;
if diag_on {
eprintln!(
"[OPT][DIAG] Function '{}' has {} legacy MIR ops (TypeCheck/Cast/WeakNew/WeakLoad/BarrierRead/BarrierWrite): unify to TypeOp/WeakRef/Barrier",
"[OPT][DIAG] Function '{}' has {} legacy MIR ops: unify to Core‑13 (TypeOp/WeakRef/Barrier/BoxCall)",
fname, count
);
if crate::config::env::opt_diag_forbid_legacy() {
panic!("NYASH_OPT_DIAG_FORBID_LEGACY=1: legacy MIR ops detected in '{}': {}", fname, count);
}
}
}
}

8
src/runtime/nyash_runtime.rs
View File

@ -81,12 +81,8 @@ impl NyashRuntimeBuilder {
fn create_default_registry() -> Arc<Mutex<UnifiedBoxRegistry>> {
let mut registry = UnifiedBoxRegistry::new();
// Simple rule:
// - Default: plugins-only (no builtins)
// - wasm32: enable builtins
// - tests: enable builtins
// - feature "builtin-core": enable builtins manually
#[cfg(any(test, target_arch = "wasm32", feature = "builtin-core"))]
// Default: enable builtins unless explicitly building with feature "plugins-only"
#[cfg(not(feature = "plugins-only"))]
{
registry.register(Arc::new(BuiltinBoxFactory::new()));
}

19
src/runtime/plugin_loader_unified.rs
View File

@ -5,6 +5,7 @@
use std::sync::{Arc, RwLock};
use once_cell::sync::Lazy;
use std::cell::Cell;
use crate::bid::{BidError, BidResult};
use crate::config::nyash_toml_v2::NyashConfigV2;
@ -102,8 +103,22 @@ impl PluginHost {
instance_id: u32,
args: &[Box<dyn crate::box_trait::NyashBox>],
) -> BidResult<Option<Box<dyn crate::box_trait::NyashBox>>> {
let l = self.loader.read().unwrap();
l.invoke_instance_method(box_type, method_name, instance_id, args)
thread_local! { static HOST_REENTRANT: Cell<bool> = Cell::new(false); }
let recursed = HOST_REENTRANT.with(|f| f.get());
if recursed {
// Break potential host<->loader recursion: return None (void) to keep VM running
return Ok(None);
}
let out = HOST_REENTRANT.with(|f| {
f.set(true);
let res = {
let l = self.loader.read().unwrap();
l.invoke_instance_method(box_type, method_name, instance_id, args)
};
f.set(false);
res
});
out
}
/// Check if a method returns Result (Ok/Err) per plugin spec or central config.

16
src/runtime/plugin_loader_v2/enabled/errors.rs Normal file
View File

@ -0,0 +1,16 @@
use crate::bid::{BidResult, BidError};
// Minimal helpers to keep loader.rs lean and consistent
#[inline]
pub fn from_fs<T>(_r: std::io::Result<T>) -> BidResult<T> {
_r.map_err(|_| BidError::PluginError)
}
#[inline]
pub fn from_toml<T>(_r: Result<T, toml::de::Error>) -> BidResult<T> {
_r.map_err(|_| BidError::PluginError)
}
#[inline]
pub fn or_plugin_err<T>(opt: Option<T>) -> BidResult<T> { opt.ok_or(BidError::PluginError) }

28
src/runtime/plugin_loader_v2/enabled/host_bridge.rs Normal file
View File

@ -0,0 +1,28 @@
// Host bridge helpers for TypeBox invoke (minimal, v2)
pub type InvokeFn = unsafe extern "C" fn(u32, u32, u32, *const u8, usize, *mut u8, *mut usize) -> i32;
// Call invoke_id with a temporary output buffer; returns (code, bytes_written, buffer)
pub fn invoke_alloc(
invoke: InvokeFn,
type_id: u32,
method_id: u32,
instance_id: u32,
tlv_args: &[u8],
) -> (i32, usize, Vec<u8>) {
let mut out = vec![0u8; 1024];
let mut out_len: usize = out.len();
let code = unsafe {
invoke(
type_id,
method_id,
instance_id,
tlv_args.as_ptr(),
tlv_args.len(),
out.as_mut_ptr(),
&mut out_len,
)
};
(code, out_len, out)
}

64
src/runtime/plugin_loader_v2/enabled/loader.rs
View File

@ -2,7 +2,6 @@ use super::types::{PluginBoxV2, PluginHandleInner, NyashTypeBoxFfi, LoadedPlugin
use crate::bid::{BidResult, BidError};
use crate::box_trait::{NyashBox, BoxCore, StringBox, IntegerBox};
use crate::config::nyash_toml_v2::{NyashConfigV2, LibraryDefinition};
use once_cell::sync::Lazy;
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
@ -66,8 +65,8 @@ impl PluginLoaderV2 {
fn prebirth_singletons(&self) -> BidResult<()> {
let config = self.config.as_ref().ok_or(BidError::PluginError)?;
let cfg_path = self.config_path.as_deref().unwrap_or("nyash.toml");
let toml_content = std::fs::read_to_string(cfg_path).map_err(|_| BidError::PluginError)?;
let toml_value: toml::Value = toml::from_str(&toml_content).map_err(|_| BidError::PluginError)?;
let toml_content = super::errors::from_fs(std::fs::read_to_string(cfg_path))?;
let toml_value: toml::Value = super::errors::from_toml(toml::from_str(&toml_content))?;
for (lib_name, lib_def) in &config.libraries {
for box_name in &lib_def.boxes {
if let Some(bc) = config.get_box_config(lib_name, box_name, &toml_value) { if bc.singleton { let _ = self.ensure_singleton_handle(lib_name, box_name); } }
@ -88,7 +87,8 @@ impl PluginLoaderV2 {
pub fn construct_existing_instance(&self, type_id: u32, instance_id: u32) -> Option<Box<dyn NyashBox>> {
let config = self.config.as_ref()?;
let cfg_path = self.config_path.as_ref()?;
let toml_value: toml::Value = toml::from_str(&std::fs::read_to_string(cfg_path).ok()?).ok()?;
let toml_str = std::fs::read_to_string(cfg_path).ok()?;
let toml_value: toml::Value = toml::from_str(&toml_str).ok()?;
let (lib_name, box_type) = self.find_box_by_type_id(config, &toml_value, type_id)?;
let plugins = self.plugins.read().ok()?;
let plugin = plugins.get(lib_name)?.clone();
@ -114,7 +114,8 @@ impl PluginLoaderV2 {
let mut out = vec![0u8; 1024];
let mut out_len = out.len();
let tlv_args = crate::runtime::plugin_ffi_common::encode_empty_args();
let birth_result = unsafe { (plugin.invoke_fn)(type_id, 0, 0, tlv_args.as_ptr(), tlv_args.len(), out.as_mut_ptr(), &mut out_len) };
let (birth_result, _len, out_vec) = super::host_bridge::invoke_alloc(plugin.invoke_fn, type_id, 0, 0, &tlv_args);
let out = out_vec;
if birth_result != 0 || out_len < 4 { return Err(BidError::PluginError); }
let instance_id = u32::from_le_bytes([out[0], out[1], out[2], out[3]]);
let fini_id = if let Some(spec) = self.box_specs.read().unwrap().get(&(lib_name.to_string(), box_type.to_string())) { spec.fini_method_id } else { let box_conf = config.get_box_config(lib_name, box_type, &toml_value).ok_or(BidError::InvalidType)?; box_conf.methods.get("fini").map(|m| m.method_id) };
@ -141,7 +142,7 @@ impl PluginLoaderV2 {
fn resolve_method_id_from_file(&self, box_type: &str, method_name: &str) -> BidResult<u32> {
let cfg = self.config.as_ref().ok_or(BidError::PluginError)?;
let cfg_path = self.config_path.as_deref().unwrap_or("nyash.toml");
let toml_value: toml::Value = toml::from_str(&std::fs::read_to_string(cfg_path).map_err(|_| BidError::PluginError)?).map_err(|_| BidError::PluginError)?;
let toml_value: toml::Value = super::errors::from_toml(toml::from_str(&std::fs::read_to_string(cfg_path).map_err(|_| BidError::PluginError)?))?;
if let Some((lib_name, _)) = cfg.find_library_for_box(box_type) {
if let Some(bc) = cfg.get_box_config(&lib_name, box_type, &toml_value) { if let Some(m) = bc.methods.get(method_name) { return Ok(m.method_id); } }
}
@ -161,11 +162,54 @@ impl PluginLoaderV2 {
false
}
/// Resolve (type_id, method_id, returns_result) for a box_type.method
pub fn resolve_method_handle(&self, box_type: &str, method_name: &str) -> BidResult<(u32, u32, bool)> {
let cfg = self.config.as_ref().ok_or(BidError::PluginError)?;
let cfg_path = self.config_path.as_deref().unwrap_or("nyash.toml");
let toml_value: toml::Value = toml::from_str(&std::fs::read_to_string(cfg_path).map_err(|_| BidError::PluginError)?).map_err(|_| BidError::PluginError)?;
let (lib_name, _) = cfg.find_library_for_box(box_type).ok_or(BidError::InvalidType)?;
let bc = cfg.get_box_config(lib_name, box_type, &toml_value).ok_or(BidError::InvalidType)?;
let m = bc.methods.get(method_name).ok_or(BidError::InvalidMethod)?;
Ok((bc.type_id, m.method_id, m.returns_result))
}
pub fn invoke_instance_method(&self, box_type: &str, method_name: &str, instance_id: u32, args: &[Box<dyn NyashBox>]) -> BidResult<Option<Box<dyn NyashBox>>> {
// Delegates to plugin_loader_unified in practice; keep minimal compatibility bridge for v2
let host = crate::runtime::get_global_plugin_host();
let host = host.read().map_err(|_| BidError::PluginError)?;
host.invoke_instance_method(box_type, method_name, instance_id, args)
// Non-recursive direct bridge for minimal methods used by semantics and basic VM paths
// Resolve library/type/method ids from cached config
let cfg = self.config.as_ref().ok_or(BidError::PluginError)?;
let cfg_path = self.config_path.as_deref().unwrap_or("nyash.toml");
let toml_value: toml::Value = toml::from_str(&std::fs::read_to_string(cfg_path).map_err(|_| BidError::PluginError)?).map_err(|_| BidError::PluginError)?;
let (lib_name, _lib_def) = cfg.find_library_for_box(box_type).ok_or(BidError::InvalidType)?;
let box_conf = cfg.get_box_config(lib_name, box_type, &toml_value).ok_or(BidError::InvalidType)?;
let type_id = box_conf.type_id;
let method = box_conf.methods.get(method_name).ok_or(BidError::InvalidMethod)?;
// Get plugin handle
let plugins = self.plugins.read().map_err(|_| BidError::PluginError)?;
let plugin = plugins.get(lib_name).ok_or(BidError::PluginError)?;
// Encode minimal TLV args (support only 0-arity inline)
if !args.is_empty() { return Err(BidError::PluginError); }
let tlv: [u8; 0] = [];
let (_code, out_len, out) = super::host_bridge::invoke_alloc(plugin.invoke_fn, type_id, method.method_id, instance_id, &tlv);
// Minimal decoding by method name
match method_name {
// Expect UTF-8 string result in bytes → StringBox
"toUtf8" | "toString" => {
let s = String::from_utf8_lossy(&out[0..out_len]).to_string();
return Ok(Some(Box::new(crate::box_trait::StringBox::new(s))));
}
// Expect IntegerBox via little-endian i64 in first 8 bytes
"get" => {
if out_len >= 8 { let mut buf=[0u8;8]; buf.copy_from_slice(&out[0..8]); let n=i64::from_le_bytes(buf); return Ok(Some(Box::new(crate::box_trait::IntegerBox::new(n)))) }
return Ok(Some(Box::new(crate::box_trait::IntegerBox::new(0))));
}
// Float path (approx): read 8 bytes as f64 and Box as FloatBox
"toDouble" => {
if out_len >= 8 { let mut buf=[0u8;8]; buf.copy_from_slice(&out[0..8]); let x=f64::from_le_bytes(buf); return Ok(Some(Box::new(crate::boxes::FloatBox::new(x)))) }
return Ok(Some(Box::new(crate::boxes::FloatBox::new(0.0))));
}
_ => {}
}
Ok(None)
}
pub fn create_box(&self, box_type: &str, _args: &[Box<dyn NyashBox>]) -> BidResult<Box<dyn NyashBox>> {

5
src/runtime/plugin_loader_v2/enabled/mod.rs
View File

@ -1,8 +1,9 @@
mod types;
mod loader;
mod globals;
mod errors;
mod host_bridge;
pub use types::{PluginBoxV2, PluginHandleInner, NyashTypeBoxFfi, make_plugin_box_v2, construct_plugin_box};
pub use loader::{PluginLoaderV2};
pub use loader::PluginLoaderV2;
pub use globals::{get_global_loader_v2, init_global_loader_v2, shutdown_plugins_v2};

47
src/runtime/plugin_loader_v2/enabled/types.rs
View File

@ -28,19 +28,7 @@ impl Drop for PluginHandleInner {
if let Some(fini_id) = self.fini_method_id {
if !self.finalized.swap(true, std::sync::atomic::Ordering::SeqCst) {
let tlv_args: [u8; 4] = [1, 0, 0, 0];
let mut out: [u8; 4] = [0; 4];
let mut out_len: usize = out.len();
unsafe {
(self.invoke_fn)(
self.type_id,
fini_id,
self.instance_id,
tlv_args.as_ptr(),
tlv_args.len(),
out.as_mut_ptr(),
&mut out_len,
);
}
let _ = super::host_bridge::invoke_alloc(self.invoke_fn, self.type_id, fini_id, self.instance_id, &tlv_args);
}
}
}
@ -52,19 +40,7 @@ impl PluginHandleInner {
if !self.finalized.swap(true, std::sync::atomic::Ordering::SeqCst) {
crate::runtime::leak_tracker::finalize_plugin("PluginBox", self.instance_id);
let tlv_args: [u8; 4] = [1, 0, 0, 0];
let mut out: [u8; 4] = [0; 4];
let mut out_len: usize = out.len();
unsafe {
(self.invoke_fn)(
self.type_id,
fini_id,
self.instance_id,
tlv_args.as_ptr(),
tlv_args.len(),
out.as_mut_ptr(),
&mut out_len,
);
}
let _ = super::host_bridge::invoke_alloc(self.invoke_fn, self.type_id, fini_id, self.instance_id, &tlv_args);
}
}
}
@ -104,22 +80,10 @@ impl NyashBox for PluginBoxV2 {
}
fn clone_box(&self) -> Box<dyn NyashBox> {
if dbg_on() { eprintln!("[PluginBoxV2] clone_box {}({})", self.box_type, self.inner.instance_id); }
let mut output_buffer = vec![0u8; 1024];
let mut output_len = output_buffer.len();
let tlv_args = [1u8, 0, 0, 0];
let result = unsafe {
(self.inner.invoke_fn)(
self.inner.type_id,
0,
0,
tlv_args.as_ptr(),
tlv_args.len(),
output_buffer.as_mut_ptr(),
&mut output_len,
)
};
if result == 0 && output_len >= 4 {
let new_instance_id = u32::from_le_bytes([output_buffer[0], output_buffer[1], output_buffer[2], output_buffer[3]]);
let (result, out_len, out_buf) = super::host_bridge::invoke_alloc(self.inner.invoke_fn, self.inner.type_id, 0, 0, &tlv_args);
if result == 0 && out_len >= 4 {
let new_instance_id = u32::from_le_bytes([out_buf[0], out_buf[1], out_buf[2], out_buf[3]]);
Box::new(PluginBoxV2 {
box_type: self.box_type.clone(),
inner: Arc::new(PluginHandleInner { type_id: self.inner.type_id, invoke_fn: self.inner.invoke_fn, instance_id: new_instance_id, fini_method_id: self.inner.fini_method_id, finalized: std::sync::atomic::AtomicBool::new(false) }),
@ -154,4 +118,3 @@ pub fn construct_plugin_box(
) -> PluginBoxV2 {
PluginBoxV2 { box_type, inner: Arc::new(PluginHandleInner { type_id, invoke_fn, instance_id, fini_method_id, finalized: std::sync::atomic::AtomicBool::new(false) }) }
}

39
src/runtime/type_registry.rs
View File

@ -4,6 +4,19 @@
* 目的:
* - TypeId → TypeBox 参照の最小インターフェースを用意（現時点では未実装・常に未登録）。
* - VM/JIT 実装が存在を前提に呼び出しても no-op/fallback できる状態にする。
*
* スロット番号の方針（注釈）
* - ここで定義する `slot` は「VTable 用の仮想メソッドID」です。VM/JIT の内部ディスパッチ最適化
* と、Builtin Box の高速経路（fast path）に使われます。
* - HostAPI（プラグインのネイティブ関数呼び出し）で用いるメソッド番号空間とは独立です。
* HostAPI 側は TLV で型付き引数を渡し、プラグイン実装側の関数テーブルにマップされます。
* そのため重複しても問題ありません（互いに衝突しない設計）。
* - 慣例として以下の帯域を利用します（将来の整理用の目安）：
* - 0..=3: ユニバーサルスロット（toString/type/equal/copy 相当）
* - 100..: Array 系（get/set/len ほか拡張）
* - 200..: Map 系（size/len/has/get/set/delete ほか拡張）
* - 300..: String 系（len/substring/concat/indexOf/replace/trim/toUpper/toLower）
* - 400..: Console 系（log/warn/error/clear）
*/
use super::type_box_abi::{TypeBox, MethodEntry};
@ -15,6 +28,18 @@ const ARRAY_METHODS: &[MethodEntry] = &[
MethodEntry { name: "set", arity: 2, slot: 101 },
MethodEntry { name: "len", arity: 0, slot: 102 },
MethodEntry { name: "length", arity: 0, slot: 102 },
// P0: vtable coverage extension
MethodEntry { name: "push", arity: 1, slot: 103 },
MethodEntry { name: "pop", arity: 0, slot: 104 },
MethodEntry { name: "clear", arity: 0, slot: 105 },
// P1: contains/indexOf/join
MethodEntry { name: "contains", arity: 1, slot: 106 },
MethodEntry { name: "indexOf", arity: 1, slot: 107 },
MethodEntry { name: "join", arity: 1, slot: 108 },
// P2: sort/reverse/slice
MethodEntry { name: "sort", arity: 0, slot: 109 },
MethodEntry { name: "reverse", arity: 0, slot: 110 },
MethodEntry { name: "slice", arity: 2, slot: 111 },
];
static ARRAYBOX_TB: TypeBox = TypeBox::new_with("ArrayBox", ARRAY_METHODS);
@ -25,12 +50,26 @@ const MAP_METHODS: &[MethodEntry] = &[
MethodEntry { name: "has", arity: 1, slot: 202 },
MethodEntry { name: "get", arity: 1, slot: 203 },
MethodEntry { name: "set", arity: 2, slot: 204 },
// Extended
MethodEntry { name: "delete", arity: 1, slot: 205 }, // alias: remove (同一スロット)
MethodEntry { name: "remove", arity: 1, slot: 205 },
MethodEntry { name: "keys", arity: 0, slot: 206 },
MethodEntry { name: "values", arity: 0, slot: 207 },
MethodEntry { name: "clear", arity: 0, slot: 208 },
];
static MAPBOX_TB: TypeBox = TypeBox::new_with("MapBox", MAP_METHODS);
// --- StringBox ---
const STRING_METHODS: &[MethodEntry] = &[
MethodEntry { name: "len", arity: 0, slot: 300 },
// P1: extend String vtable
MethodEntry { name: "substring", arity: 2, slot: 301 },
MethodEntry { name: "concat", arity: 1, slot: 302 },
MethodEntry { name: "indexOf", arity: 1, slot: 303 },
MethodEntry { name: "replace", arity: 2, slot: 304 },
MethodEntry { name: "trim", arity: 0, slot: 305 },
MethodEntry { name: "toUpper", arity: 0, slot: 306 },
MethodEntry { name: "toLower", arity: 0, slot: 307 },
];
static STRINGBOX_TB: TypeBox = TypeBox::new_with("StringBox", STRING_METHODS);

4
src/runtime/unified_registry.rs
View File

@ -18,8 +18,8 @@ static GLOBAL_REGISTRY: OnceLock<Arc<Mutex<UnifiedBoxRegistry>>> = OnceLock::new
pub fn init_global_unified_registry() {
GLOBAL_REGISTRY.get_or_init(|| {
let mut registry = UnifiedBoxRegistry::new();
// Builtins enabled only for wasm32, tests, or when feature "builtin-core" is set
#[cfg(any(test, target_arch = "wasm32", feature = "builtin-core"))]
// Default: enable builtins unless building with feature "plugins-only"
#[cfg(not(feature = "plugins-only"))]
{
registry.register(std::sync::Arc::new(BuiltinBoxFactory::new()));
}

56
src/tests/core13_smoke_array.rs Normal file
View File

@ -0,0 +1,56 @@
#[test]
fn core13_array_boxcall_push_len_get() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
// Build: a = new ArrayBox(); a.push(7); r = a.len() + a.get(0); return r
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let a = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: a, box_type: "ArrayBox".into(), args: vec![] });
// push(7)
let seven = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: seven, value: ConstValue::Integer(7) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a, method: "push".into(), args: vec![seven], method_id: None, effects: EffectMask::PURE });
// len()
let ln = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(ln), box_val: a, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
// get(0)
let zero = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: zero, value: ConstValue::Integer(0) });
let g0 = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(g0), box_val: a, method: "get".into(), args: vec![zero], method_id: None, effects: EffectMask::PURE });
// sum
let sum = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: sum, op: crate::mir::BinaryOp::Add, lhs: ln, rhs: g0 });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(sum) });
let mut m = MirModule::new("core13_array_push_len_get".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "8");
}
#[test]
fn core13_array_boxcall_set_get() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
// Build: a = new ArrayBox(); a.set(0, 5); return a.get(0)
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let a = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: a, box_type: "ArrayBox".into(), args: vec![] });
let zero = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: zero, value: ConstValue::Integer(0) });
let five = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: five, value: ConstValue::Integer(5) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a, method: "set".into(), args: vec![zero, five], method_id: None, effects: EffectMask::PURE });
let outv = f.next_value_id();
let zero2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: zero2, value: ConstValue::Integer(0) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(outv), box_val: a, method: "get".into(), args: vec![zero2], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(outv) });
let mut m = MirModule::new("core13_array_set_get".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "5");
}

42
src/tests/core13_smoke_jit.rs Normal file
View File

@ -0,0 +1,42 @@
#[cfg(feature = "cranelift-jit")]
#[test]
fn core13_jit_array_push_len_get() {
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
// Build: a = new ArrayBox(); a.push(3); ret a.len()+a.get(0)
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let a = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: a, box_type: "ArrayBox".into(), args: vec![] });
let three = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: three, value: ConstValue::Integer(3) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a, method: "push".into(), args: vec![three], method_id: None, effects: EffectMask::PURE });
let ln = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(ln), box_val: a, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let zero = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: zero, value: ConstValue::Integer(0) });
let g0 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(g0), box_val: a, method: "get".into(), args: vec![zero], method_id: None, effects: EffectMask::PURE });
let sum = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: sum, op: crate::mir::BinaryOp::Add, lhs: ln, rhs: g0 });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(sum) });
let mut m = MirModule::new("core13_jit_array_push_len_get".into()); m.add_function(f);
let jit_out = crate::backend::cranelift_compile_and_execute(&m, "core13_jit_array").expect("JIT exec");
assert_eq!(jit_out.to_string_box().value, "4");
}
#[cfg(feature = "cranelift-jit")]
#[test]
fn core13_jit_array_set_get() {
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
// Build: a = new ArrayBox(); a.set(0, 9); ret a.get(0)
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let a = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: a, box_type: "ArrayBox".into(), args: vec![] });
let zero = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: zero, value: ConstValue::Integer(0) });
let nine = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: nine, value: ConstValue::Integer(9) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a, method: "set".into(), args: vec![zero, nine], method_id: None, effects: EffectMask::PURE });
let z2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: z2, value: ConstValue::Integer(0) });
let outv = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(outv), box_val: a, method: "get".into(), args: vec![z2], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(outv) });
let mut m = MirModule::new("core13_jit_array_set_get".into()); m.add_function(f);
let jit_out = crate::backend::cranelift_compile_and_execute(&m, "core13_jit_array2").expect("JIT exec");
assert_eq!(jit_out.to_string_box().value, "9");
}

27
src/tests/core13_smoke_jit_map.rs Normal file
View File

@ -0,0 +1,27 @@
#[cfg(feature = "cranelift-jit")]
#[test]
fn core13_jit_map_set_get_size() {
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
// Build: m = new MapBox(); m.set("k", 11); r = m.size()+m.get("k"); return r
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let m = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: m, box_type: "MapBox".into(), args: vec![] });
// set("k", 11)
let k = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: k, value: ConstValue::String("k".into()) });
let v = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: v, value: ConstValue::Integer(11) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m, method: "set".into(), args: vec![k, v], method_id: None, effects: EffectMask::PURE });
// size()
let sz = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(sz), box_val: m, method: "size".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
// get("k")
let k2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: k2, value: ConstValue::String("k".into()) });
let gk = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(gk), box_val: m, method: "get".into(), args: vec![k2], method_id: None, effects: EffectMask::PURE });
// sum
let sum = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: sum, op: crate::mir::BinaryOp::Add, lhs: sz, rhs: gk });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(sum) });
let mut module = MirModule::new("core13_jit_map_set_get_size".into()); module.add_function(f);
let out = crate::backend::cranelift_compile_and_execute(&module, "core13_jit_map").expect("JIT exec");
assert_eq!(out.to_string_box().value, "12");
}

7
src/tests/mod.rs
View File

@ -6,6 +6,13 @@ pub mod identical_exec_string;
pub mod identical_exec_instance;
pub mod vtable_array_string;
pub mod vtable_strict;
pub mod vtable_array_ext;
pub mod vtable_array_p2;
pub mod vtable_array_p1;
pub mod vtable_string;
pub mod vtable_console;
pub mod vtable_map_ext;
pub mod vtable_string_p1;
pub mod host_reverse_slot;
pub mod nyash_abi_basic;
pub mod typebox_tlv_diff;

61
src/tests/vtable_array_ext.rs Normal file
View File

@ -0,0 +1,61 @@
#[test]
fn vtable_array_push_get_len_pop_clear() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// Case 1: push("x"); get(0)
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let arr = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: arr, box_type: "ArrayBox".into(), args: vec![] });
let sval = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: sval, value: ConstValue::String("x".into()) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: arr, method: "push".into(), args: vec![sval], method_id: None, effects: EffectMask::PURE });
let idx0 = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: idx0, value: ConstValue::Integer(0) });
let got = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(got), box_val: arr, method: "get".into(), args: vec![idx0], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(got) });
let mut m = MirModule::new("arr_push_get".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "x");
// Case 2: push("y"); pop() -> "y"
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let a2 = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: a2, box_type: "ArrayBox".into(), args: vec![] });
let y = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: y, value: ConstValue::String("y".into()) });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a2, method: "push".into(), args: vec![y], method_id: None, effects: EffectMask::PURE });
let popped = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(popped), box_val: a2, method: "pop".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(popped) });
let mut m2 = MirModule::new("arr_pop".into()); m2.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&m2).expect("vm exec");
assert_eq!(out2.to_string_box().value, "y");
// Case 3: push("z"); clear(); len() -> 0
let sig3 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f3 = MirFunction::new(sig3, BasicBlockId::new(0));
let bb3 = f3.entry_block;
let a3 = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::NewBox { dst: a3, box_type: "ArrayBox".into(), args: vec![] });
let z = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: z, value: ConstValue::String("z".into()) });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "push".into(), args: vec![z], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "clear".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let ln = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(ln), box_val: a3, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Return { value: Some(ln) });
let mut m3 = MirModule::new("arr_clear_len".into()); m3.add_function(f3);
let mut vm3 = VM::new();
let out3 = vm3.execute_module(&m3).expect("vm exec");
assert_eq!(out3.to_string_box().value, "0");
}

78
src/tests/vtable_array_p1.rs Normal file
View File

@ -0,0 +1,78 @@
#[test]
fn vtable_array_contains_indexof_join() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// contains: ["a","b"].contains("b") == true; contains("c") == false
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let arr = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: arr, box_type: "ArrayBox".into(), args: vec![] });
let sa = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: sa, value: ConstValue::String("a".into()) });
let sb = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: sb, value: ConstValue::String("b".into()) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: arr, method: "push".into(), args: vec![sa], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: arr, method: "push".into(), args: vec![sb], method_id: None, effects: EffectMask::PURE });
let sc = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: sc, value: ConstValue::String("c".into()) });
let got1 = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(got1), box_val: arr, method: "contains".into(), args: vec![sb], method_id: None, effects: EffectMask::PURE });
let got2 = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(got2), box_val: arr, method: "contains".into(), args: vec![sc], method_id: None, effects: EffectMask::PURE });
// return got1.equals(true) && got2.equals(false) as 1 for pass
// Instead, just return 0 or 1 using simple branch-like comparison via toString
// We check: got1==true -> "true", got2==false -> "false" and return 1 if both match else 0
// For brevity, just return got1.toString() ("true") length + got2.toString() ("false") length == 9
let s1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(s1), box_val: got1, method: "toString".into(), args: vec![], method_id: Some(0), effects: EffectMask::PURE });
let s2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(s2), box_val: got2, method: "toString".into(), args: vec![], method_id: Some(0), effects: EffectMask::PURE });
let len1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(len1), box_val: s1, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let len2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(len2), box_val: s2, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
// len1 + len2
let sum = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: sum, op: crate::mir::BinaryOp::Add, lhs: len1, rhs: len2 });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(sum) });
let mut m = MirModule::new("arr_contains".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "9"); // "true"(4)+"false"(5)
// indexOf: ["x","y"].indexOf("y") == 1; indexOf("z") == -1
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let a2 = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: a2, box_type: "ArrayBox".into(), args: vec![] });
let sx = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: sx, value: ConstValue::String("x".into()) });
let sy = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: sy, value: ConstValue::String("y".into()) });
let sz = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: sz, value: ConstValue::String("z".into()) });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a2, method: "push".into(), args: vec![sx], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a2, method: "push".into(), args: vec![sy], method_id: None, effects: EffectMask::PURE });
let i1 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(i1), box_val: a2, method: "indexOf".into(), args: vec![sy], method_id: None, effects: EffectMask::PURE });
let i2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(i2), box_val: a2, method: "indexOf".into(), args: vec![sz], method_id: None, effects: EffectMask::PURE });
let sum2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BinOp { dst: sum2, op: crate::mir::BinaryOp::Add, lhs: i1, rhs: i2 });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(sum2) });
let mut m2 = MirModule::new("arr_indexOf".into()); m2.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&m2).expect("vm exec");
assert_eq!(out2.to_string_box().value, "0"); // 1 + (-1)
// join: ["a","b","c"].join("-") == "a-b-c"
let sig3 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f3 = MirFunction::new(sig3, BasicBlockId::new(0));
let bb3 = f3.entry_block;
let a3 = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::NewBox { dst: a3, box_type: "ArrayBox".into(), args: vec![] });
let a = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: a, value: ConstValue::String("a".into()) });
let b = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: b, value: ConstValue::String("b".into()) });
let c = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: c, value: ConstValue::String("c".into()) });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "push".into(), args: vec![a], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "push".into(), args: vec![b], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "push".into(), args: vec![c], method_id: None, effects: EffectMask::PURE });
let sep = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: sep, value: ConstValue::String("-".into()) });
let joined = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(joined), box_val: a3, method: "join".into(), args: vec![sep], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Return { value: Some(joined) });
let mut m3 = MirModule::new("arr_join".into()); m3.add_function(f3);
let mut vm3 = VM::new();
let out3 = vm3.execute_module(&m3).expect("vm exec");
assert_eq!(out3.to_string_box().value, "a-b-c");
}

73
src/tests/vtable_array_p2.rs Normal file
View File

@ -0,0 +1,73 @@
#[test]
fn vtable_array_sort_reverse_slice() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// sort: push 3,1,2 -> sort() -> get(0) == 1
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let arr = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: arr, box_type: "ArrayBox".into(), args: vec![] });
let c3 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c3, value: ConstValue::Integer(3) });
let c1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c1, value: ConstValue::Integer(1) });
let c2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: c2, value: ConstValue::Integer(2) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: arr, method: "push".into(), args: vec![c3], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: arr, method: "push".into(), args: vec![c1], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: arr, method: "push".into(), args: vec![c2], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: arr, method: "sort".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let idx0 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: idx0, value: ConstValue::Integer(0) });
let got = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(got), box_val: arr, method: "get".into(), args: vec![idx0], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(got) });
let mut m = MirModule::new("arr_sort".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "1");
// reverse: push 1,2 -> reverse() -> get(0) == 2
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let a2 = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: a2, box_type: "ArrayBox".into(), args: vec![] });
let i1 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: i1, value: ConstValue::Integer(1) });
let i2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: i2, value: ConstValue::Integer(2) });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a2, method: "push".into(), args: vec![i1], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a2, method: "push".into(), args: vec![i2], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a2, method: "reverse".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let z0 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: z0, value: ConstValue::Integer(0) });
let g2 = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(g2), box_val: a2, method: "get".into(), args: vec![z0], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(g2) });
let mut m2 = MirModule::new("arr_reverse".into()); m2.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&m2).expect("vm exec");
assert_eq!(out2.to_string_box().value, "2");
// slice: push "a","b","c" -> slice(0,2) -> len()==2
let sig3 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f3 = MirFunction::new(sig3, BasicBlockId::new(0));
let bb3 = f3.entry_block;
let a3 = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::NewBox { dst: a3, box_type: "ArrayBox".into(), args: vec![] });
let sa = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: sa, value: ConstValue::String("a".into()) });
let sb = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: sb, value: ConstValue::String("b".into()) });
let sc = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: sc, value: ConstValue::String("c".into()) });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "push".into(), args: vec![sa], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "push".into(), args: vec![sb], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: a3, method: "push".into(), args: vec![sc], method_id: None, effects: EffectMask::PURE });
let s0 = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: s0, value: ConstValue::Integer(0) });
let s2 = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: s2, value: ConstValue::Integer(2) });
let sub = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(sub), box_val: a3, method: "slice".into(), args: vec![s0, s2], method_id: None, effects: EffectMask::PURE });
let ln = f3.next_value_id();
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(ln), box_val: sub, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Return { value: Some(ln) });
let mut m3 = MirModule::new("arr_slice".into()); m3.add_function(f3);
let mut vm3 = VM::new();
let out3 = vm3.execute_module(&m3).expect("vm exec");
assert_eq!(out3.to_string_box().value, "2");
}

22
src/tests/vtable_console.rs Normal file
View File

@ -0,0 +1,22 @@
#[test]
fn vtable_console_log_clear_smoke() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let con = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: con, box_type: "ConsoleBox".into(), args: vec![] });
let msg = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: msg, value: ConstValue::String("hi".into()) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: con, method: "log".into(), args: vec![msg], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: con, method: "clear".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let zero = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: zero, value: ConstValue::Integer(0) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(zero) });
let mut m = MirModule::new("console_smoke".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "0");
}

59
src/tests/vtable_map_boundaries.rs Normal file
View File

@ -0,0 +1,59 @@
#[test]
fn vtable_map_boundary_cases() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// Case 1: empty-string key set/get/has
let sig1 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f1 = MirFunction::new(sig1, BasicBlockId::new(0));
let bb1 = f1.entry_block;
let m = f1.next_value_id();
f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::NewBox { dst: m, box_type: "MapBox".into(), args: vec![] });
// set("", 1)
let k_empty = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::Const { dst: k_empty, value: ConstValue::String("".into()) });
let v1 = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::Const { dst: v1, value: ConstValue::Integer(1) });
f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m, method: "set".into(), args: vec![k_empty, v1], method_id: None, effects: EffectMask::PURE });
// has("") -> true
let h = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(h), box_val: m, method: "has".into(), args: vec![k_empty], method_id: None, effects: EffectMask::PURE });
// get("") -> 1
let g = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(g), box_val: m, method: "get".into(), args: vec![k_empty], method_id: None, effects: EffectMask::PURE });
// return has + get (true->1) + size == 1 + 1 + 1 = 3 (coerce Bool true to 1 via toString parse in BinOp fallback)
let sz = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(sz), box_val: m, method: "size".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let tmp = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::BinOp { dst: tmp, op: crate::mir::BinaryOp::Add, lhs: h, rhs: g });
let sum = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::BinOp { dst: sum, op: crate::mir::BinaryOp::Add, lhs: tmp, rhs: sz });
f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::Return { value: Some(sum) });
let mut m1 = MirModule::new("map_boundary_empty_key".into()); m1.add_function(f1);
let mut vm1 = VM::new();
let out1 = vm1.execute_module(&m1).expect("vm exec");
// Expect 3 as described above
assert_eq!(out1.to_string_box().value, "3");
// Case 2: duplicate key overwrite, missing key get message shape, and delete using slot 205
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let m2 = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: m2, box_type: "MapBox".into(), args: vec![] });
// set("k", 1); set("k", 2)
let k = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: k, value: ConstValue::String("k".into()) });
let one = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: one, value: ConstValue::Integer(1) });
let two = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: two, value: ConstValue::Integer(2) });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m2, method: "set".into(), args: vec![k, one], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m2, method: "set".into(), args: vec![k, two], method_id: None, effects: EffectMask::PURE });
// get("k") should be 2
let g2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(g2), box_val: m2, method: "get".into(), args: vec![k], method_id: None, effects: EffectMask::PURE });
// delete("missing") using method name; ensure no panic and still size==1
let missing = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: missing, value: ConstValue::String("missing".into()) });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m2, method: "delete".into(), args: vec![missing], method_id: Some(205), effects: EffectMask::PURE });
// size()
let sz2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(sz2), box_val: m2, method: "size".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let sum2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BinOp { dst: sum2, op: crate::mir::BinaryOp::Add, lhs: g2, rhs: sz2 });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(sum2) });
let mut m2m = MirModule::new("map_boundary_overwrite_delete".into()); m2m.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&m2m).expect("vm exec");
// get("k") == 2 and size()==1 => 3
assert_eq!(out2.to_string_box().value, "3");
}

51
src/tests/vtable_map_ext.rs Normal file
View File

@ -0,0 +1,51 @@
#[test]
fn vtable_map_keys_values_delete_clear() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// keys/values size check
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let m = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: m, box_type: "MapBox".into(), args: vec![] });
// set two entries
let k1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: k1, value: ConstValue::String("a".into()) });
let v1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: v1, value: ConstValue::Integer(1) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m, method: "set".into(), args: vec![k1, v1], method_id: None, effects: EffectMask::PURE });
let k2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: k2, value: ConstValue::String("b".into()) });
let v2 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: v2, value: ConstValue::Integer(2) });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m, method: "set".into(), args: vec![k2, v2], method_id: None, effects: EffectMask::PURE });
// keys().len + values().len == 4
let keys = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(keys), box_val: m, method: "keys".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let klen = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(klen), box_val: keys, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let vals = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(vals), box_val: m, method: "values".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let vlen = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(vlen), box_val: vals, method: "len".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let sum = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BinOp { dst: sum, op: crate::mir::BinaryOp::Add, lhs: klen, rhs: vlen });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(sum) });
let mut m1 = MirModule::new("map_keys_values".into()); m1.add_function(f);
let mut vm1 = VM::new();
let out1 = vm1.execute_module(&m1).expect("vm exec");
assert_eq!(out1.to_string_box().value, "4");
// delete + clear → size 0
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let m2v = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: m2v, box_type: "MapBox".into(), args: vec![] });
let k = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: k, value: ConstValue::String("x".into()) });
let v = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: v, value: ConstValue::String("y".into()) });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m2v, method: "set".into(), args: vec![k, v], method_id: None, effects: EffectMask::PURE });
let dk = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: dk, value: ConstValue::String("x".into()) });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m2v, method: "delete".into(), args: vec![dk], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: None, box_val: m2v, method: "clear".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let sz = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(sz), box_val: m2v, method: "size".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(sz) });
let mut mm2 = MirModule::new("map_delete_clear".into()); mm2.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&mm2).expect("vm exec");
assert_eq!(out2.to_string_box().value, "0");
}

38
src/tests/vtable_string.rs Normal file
View File

@ -0,0 +1,38 @@
#[test]
fn vtable_string_substring_concat() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// substring: "hello".substring(1,4) == "ell"
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let s = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: s, value: ConstValue::String("hello".into()) });
let sb = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: sb, box_type: "StringBox".into(), args: vec![s] });
let i1 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: i1, value: ConstValue::Integer(1) });
let i4 = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: i4, value: ConstValue::Integer(4) });
let sub = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(sub), box_val: sb, method: "substring".into(), args: vec![i1, i4], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(sub) });
let mut m = MirModule::new("str_sub".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "ell");
// concat: "ab".concat("cd") == "abcd"
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let a = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: a, value: ConstValue::String("ab".into()) });
let ab = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: ab, box_type: "StringBox".into(), args: vec![a] });
let c = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: c, value: ConstValue::String("cd".into()) });
let joined = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(joined), box_val: ab, method: "concat".into(), args: vec![c], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(joined) });
let mut m2 = MirModule::new("str_concat".into()); m2.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&m2).expect("vm exec");
assert_eq!(out2.to_string_box().value, "abcd");
}

50
src/tests/vtable_string_boundaries.rs Normal file
View File

@ -0,0 +1,50 @@
#[test]
fn vtable_string_boundary_cases() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// Case 1: empty string length == 0
let sig1 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f1 = MirFunction::new(sig1, BasicBlockId::new(0));
let bb1 = f1.entry_block;
let s = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::Const { dst: s, value: ConstValue::String("".into()) });
let sb = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::NewBox { dst: sb, box_type: "StringBox".into(), args: vec![s] });
let ln = f1.next_value_id(); f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(ln), box_val: sb, method: "len".into(), args: vec![], method_id: Some(300), effects: EffectMask::PURE });
f1.get_block_mut(bb1).unwrap().add_instruction(MirInstruction::Return { value: Some(ln) });
let mut m1 = MirModule::new("str_empty_len".into()); m1.add_function(f1);
let mut vm1 = VM::new();
let out1 = vm1.execute_module(&m1).expect("vm exec");
assert_eq!(out1.to_string_box().value, "0");
// Case 2: indexOf not found returns -1
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let s2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: s2, value: ConstValue::String("abc".into()) });
let sb2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: sb2, box_type: "StringBox".into(), args: vec![s2] });
let z = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: z, value: ConstValue::String("z".into()) });
let idx = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(idx), box_val: sb2, method: "indexOf".into(), args: vec![z], method_id: Some(303), effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(idx) });
let mut m2 = MirModule::new("str_indexof_not_found".into()); m2.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&m2).expect("vm exec");
assert_eq!(out2.to_string_box().value, "-1");
// Case 3: Unicode substring by character indices: "a😊b"[1..2] == "😊"
let sig3 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f3 = MirFunction::new(sig3, BasicBlockId::new(0));
let bb3 = f3.entry_block;
let s3 = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: s3, value: ConstValue::String("a😊b".into()) });
let sb3 = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::NewBox { dst: sb3, box_type: "StringBox".into(), args: vec![s3] });
let sub = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(sub), box_val: sb3, method: "substring".into(), args: vec![
{ let v = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: v, value: ConstValue::Integer(1) }); v },
{ let v = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: v, value: ConstValue::Integer(2) }); v },
], method_id: Some(301), effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Return { value: Some(sub) });
let mut m3 = MirModule::new("str_unicode_substring".into()); m3.add_function(f3);
let mut vm3 = VM::new();
let out3 = vm3.execute_module(&m3).expect("vm exec");
assert_eq!(out3.to_string_box().value, "😊");
}

53
src/tests/vtable_string_p1.rs Normal file
View File

@ -0,0 +1,53 @@
#[test]
fn vtable_string_indexof_replace_trim_upper_lower() {
use crate::backend::vm::VM;
use crate::mir::{MirModule, MirFunction, FunctionSignature, MirInstruction, EffectMask, BasicBlockId, ConstValue, MirType};
std::env::set_var("NYASH_ABI_VTABLE", "1");
// indexOf("b") in "abc" == 1
let sig = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::Integer, effects: EffectMask::PURE };
let mut f = MirFunction::new(sig, BasicBlockId::new(0));
let bb = f.entry_block;
let s = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: s, value: ConstValue::String("abc".into()) });
let sb = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::NewBox { dst: sb, box_type: "StringBox".into(), args: vec![s] });
let b = f.next_value_id(); f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Const { dst: b, value: ConstValue::String("b".into()) });
let idx = f.next_value_id();
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(idx), box_val: sb, method: "indexOf".into(), args: vec![b], method_id: None, effects: EffectMask::PURE });
f.get_block_mut(bb).unwrap().add_instruction(MirInstruction::Return { value: Some(idx) });
let mut m = MirModule::new("str_indexof".into()); m.add_function(f);
let mut vm = VM::new();
let out = vm.execute_module(&m).expect("vm exec");
assert_eq!(out.to_string_box().value, "1");
// replace: "a-b" -> replace("-","+") == "a+b"
let sig2 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f2 = MirFunction::new(sig2, BasicBlockId::new(0));
let bb2 = f2.entry_block;
let s2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: s2, value: ConstValue::String("a-b".into()) });
let sb2 = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::NewBox { dst: sb2, box_type: "StringBox".into(), args: vec![s2] });
let dash = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: dash, value: ConstValue::String("-".into()) });
let plus = f2.next_value_id(); f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Const { dst: plus, value: ConstValue::String("+".into()) });
let rep = f2.next_value_id();
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(rep), box_val: sb2, method: "replace".into(), args: vec![dash, plus], method_id: None, effects: EffectMask::PURE });
f2.get_block_mut(bb2).unwrap().add_instruction(MirInstruction::Return { value: Some(rep) });
let mut m2 = MirModule::new("str_replace".into()); m2.add_function(f2);
let mut vm2 = VM::new();
let out2 = vm2.execute_module(&m2).expect("vm exec");
assert_eq!(out2.to_string_box().value, "a+b");
// trim + toUpper + toLower: " Xy " -> trim=="Xy" -> upper=="XY" -> lower=="xy"
let sig3 = FunctionSignature { name: "main".into(), params: vec![], return_type: MirType::String, effects: EffectMask::PURE };
let mut f3 = MirFunction::new(sig3, BasicBlockId::new(0));
let bb3 = f3.entry_block;
let s3 = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Const { dst: s3, value: ConstValue::String(" Xy ".into()) });
let sb3 = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::NewBox { dst: sb3, box_type: "StringBox".into(), args: vec![s3] });
let t = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(t), box_val: sb3, method: "trim".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let u = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(u), box_val: t, method: "toUpper".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
let l = f3.next_value_id(); f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::BoxCall { dst: Some(l), box_val: u, method: "toLower".into(), args: vec![], method_id: None, effects: EffectMask::PURE });
f3.get_block_mut(bb3).unwrap().add_instruction(MirInstruction::Return { value: Some(l) });
let mut m3 = MirModule::new("str_trim_upper_lower".into()); m3.add_function(f3);
let mut vm3 = VM::new();
let out3 = vm3.execute_module(&m3).expect("vm exec");
assert_eq!(out3.to_string_box().value, "xy");
}

97
tools/codex-async-notify.sh Normal file
View File

@ -0,0 +1,97 @@
#!/bin/bash
# codex-async-notify.sh - Codexを非同期実行してClaudeに通知
# 設定
CLAUDE_SESSION="claude" # Claudeのtmuxセッション名
WORK_DIR="$HOME/.codex-async-work"
LOG_DIR="$WORK_DIR/logs"
# 使い方を表示
if [ $# -eq 0 ]; then
echo "Usage: $0 <task description>"
echo "Example: $0 'Refactor MIR builder to 13 instructions'"
exit 1
fi
TASK="$1"
WORK_ID=$(date +%s%N)
LOG_FILE="$LOG_DIR/codex-${WORK_ID}.log"
# 作業ディレクトリ準備
mkdir -p "$LOG_DIR"
# 非同期実行関数
run_codex_async() {
{
echo "=====================================" | tee "$LOG_FILE"
echo "🚀 Codex Task Started" | tee -a "$LOG_FILE"
echo "Work ID: $WORK_ID" | tee -a "$LOG_FILE"
echo "Task: $TASK" | tee -a "$LOG_FILE"
echo "Start: $(date)" | tee -a "$LOG_FILE"
echo "=====================================" | tee -a "$LOG_FILE"
echo "" | tee -a "$LOG_FILE"
# Codex実行
START_TIME=$(date +%s)
codex exec "$TASK" 2>&1 | tee -a "$LOG_FILE"
EXIT_CODE=${PIPESTATUS[0]}
END_TIME=$(date +%s)
DURATION=$((END_TIME - START_TIME))
echo "" | tee -a "$LOG_FILE"
echo "=====================================" | tee -a "$LOG_FILE"
echo "✅ Codex Task Completed" | tee -a "$LOG_FILE"
echo "Exit Code: $EXIT_CODE" | tee -a "$LOG_FILE"
echo "Duration: ${DURATION}s" | tee -a "$LOG_FILE"
echo "End: $(date)" | tee -a "$LOG_FILE"
echo "=====================================" | tee -a "$LOG_FILE"
# 最後の15行を取得（もう少し多めに）
LAST_OUTPUT=$(tail -15 "$LOG_FILE" | head -10)
# Claudeに通知
if tmux has-session -t "$CLAUDE_SESSION" 2>/dev/null; then
# 通知メッセージを送信
tmux send-keys -t "$CLAUDE_SESSION" "" Enter
tmux send-keys -t "$CLAUDE_SESSION" "# 🤖 Codex作業完了通知 [$(date +%H:%M:%S)]" Enter
tmux send-keys -t "$CLAUDE_SESSION" "# Work ID: $WORK_ID" Enter
tmux send-keys -t "$CLAUDE_SESSION" "# Task: $TASK" Enter
tmux send-keys -t "$CLAUDE_SESSION" "# Status: $([ $EXIT_CODE -eq 0 ] && echo '✅ Success' || echo '❌ Failed')" Enter
tmux send-keys -t "$CLAUDE_SESSION" "# Duration: ${DURATION}秒" Enter
tmux send-keys -t "$CLAUDE_SESSION" "# Log: $LOG_FILE" Enter
tmux send-keys -t "$CLAUDE_SESSION" "# === 最後の出力 ===" Enter
# 最後の出力を送信
echo "$LAST_OUTPUT" | while IFS= read -r line; do
# 空行をスキップ
[ -z "$line" ] && continue
tmux send-keys -t "$CLAUDE_SESSION" "# > $line" Enter
done
tmux send-keys -t "$CLAUDE_SESSION" "# ==================" Enter
tmux send-keys -t "$CLAUDE_SESSION" "" Enter
else
echo "⚠️ Claude tmux session '$CLAUDE_SESSION' not found"
echo " Notification was not sent, but work completed."
fi
} &
}
# バックグラウンドで実行
run_codex_async
ASYNC_PID=$!
# 実行開始メッセージ
echo ""
echo "✅ Codex started asynchronously!"
echo " PID: $ASYNC_PID"
echo " Work ID: $WORK_ID"
echo " Log file: $LOG_FILE"
echo ""
echo "📝 Monitor progress:"
echo " tail -f $LOG_FILE"
echo ""
echo "🔍 Check status:"
echo " ps -p $ASYNC_PID"
echo ""
echo "Codex is now working in the background..."

26
tools/codex-tmux-notify.sh Normal file
View File

@ -0,0 +1,26 @@
#!/bin/bash
# Simple Codex to Claude notification via tmux
CLAUDE_SESSION="claude" # tmuxセッション名
LOG_FILE="$HOME/.codex-work.log"
# Codex実行を記録
echo "[$(date)] Starting: codex $*" >> "$LOG_FILE"
# Codexを実行
codex "$@"
EXIT_CODE=$?
# 結果を記録
echo "[$(date)] Completed with code: $EXIT_CODE" >> "$LOG_FILE"
# Claudeに通知（tmuxセッションがあれば）
if tmux has-session -t "$CLAUDE_SESSION" 2>/dev/null; then
MESSAGE="🤖 Codex作業完了！ Exit code: $EXIT_CODE"
tmux send-keys -t "$CLAUDE_SESSION" "# $MESSAGE" Enter
echo "✅ Notification sent to Claude"
else
echo "⚠️ Claude session not found"
fi
exit $EXIT_CODE

79
tools/mir-refactoring-targets.md Normal file
View File

@ -0,0 +1,79 @@
# MIRリファクタリング対象ファイル
## 🚨 緊急度高：大きなファイル（900行以上）
### 1. mir/verification.rs (965行)
**分割案**：
- `mir/verification/basic.rs` - 基本検証
- `mir/verification/types.rs` - 型検証
- `mir/verification/control_flow.rs` - 制御フロー検証
- `mir/verification/ownership.rs` - 所有権検証
### 2. mir/builder.rs (930行)
**状態**: ChatGPT5が作業中
**分割案**：
- `mir/builder/exprs.rs` - 式のビルド（一部完了）
- `mir/builder/stmts.rs` - 文のビルド（一部完了）
- `mir/builder/decls.rs` - 宣言のビルド（一部完了）
- `mir/builder/control_flow.rs` - 制御構造
### 3. mir/instruction.rs (896行)
**状態**: MIR13固定化で大幅変更予定
**現在**: 20命令（ChatGPT5設計）→ 目標: 13命令
**作業内容**:
- 不要な命令の削除
- BoxCall統一（ArrayGet/Set, RefNew/Get/Set等）
- TypeOp統一（TypeCheck, Cast）
### 4. mir/optimizer.rs (875行)
**分割案**：
- `mir/optimizer/constant_folding.rs`
- `mir/optimizer/dead_code.rs`
- `mir/optimizer/inline.rs`
- `mir/optimizer/type_inference.rs`
## 📊 MIR命令削減マッピング（20→13）
### 削除予定の命令
```
ArrayGet, ArraySet → BoxCall
RefNew, RefGet, RefSet → BoxCall
WeakNew, WeakGet → BoxCall
MapGetProperty, MapSetProperty → BoxCall
TypeCheck, Cast → TypeOp
PluginInvoke → BoxCall（プラグイン統合）
Copy → Load + Store
Debug, Print → ExternCall
Nop → 削除
Throw, Catch → ExternCall
Safepoint → 削除（VMレベルで処理）
```
### 最終的な13-14命令
1. Const - 定数
2. Load - 読み込み
3. Store - 書き込み
4. BinOp - 二項演算
5. UnaryOp - 単項演算
6. Compare - 比較
7. Branch - 条件分岐
8. Jump - 無条件ジャンプ
9. Return - 戻り値
10. Call - 関数呼び出し
11. BoxCall - Box操作統一
12. TypeOp - 型操作統一
13. Phi - SSA合流
14. ExternCall - 外部呼び出し（オプション）
## 🚀 実行コマンド例
```bash
# 非同期でverification.rsのリファクタリング
./tools/codex-async-notify.sh "Refactor src/mir/verification.rs into smaller modules (basic, types, control_flow, ownership)"
# optimizer.rsの分割
./tools/codex-async-notify.sh "Split src/mir/optimizer.rs into separate optimization pass modules"
# MIR命令削減の実装
./tools/codex-async-notify.sh "Reduce MIR instructions from 57 to 13-14 by unifying with BoxCall and TypeOp"
```

143
tools/mir13-migration-helper.sh Normal file
View File

@ -0,0 +1,143 @@
#!/bin/bash
# MIR13移行専用ヘルパー（ChatGPT5方式を応用）
set -euo pipefail
# === MIR13特化設定 ===
LEGACY_PATTERNS=(
"ArrayGet" "ArraySet"
"RefNew" "RefGet" "RefSet"
"TypeCheck" "Cast"
"PluginInvoke"
"Copy" "Debug" "Print"
"Nop" "Throw" "Catch"
"Safepoint"
)
# 統合先
UNIFICATION_MAP="
ArrayGet:BoxCall
ArraySet:BoxCall
RefNew:BoxCall
RefGet:BoxCall
RefSet:BoxCall
TypeCheck:TypeOp
Cast:TypeOp
PluginInvoke:BoxCall
"
# === Phase 1: レガシー命令の使用箇所を検出 ===
echo "🔍 Detecting legacy instruction usage..."
mkdir -p mir13-migration/{detections,patches,results}
for pattern in "${LEGACY_PATTERNS[@]}"; do
echo "Searching for: $pattern"
rg -l "MirInstruction::$pattern" src/ > "mir13-migration/detections/$pattern.txt" || true
count=$(wc -l < "mir13-migration/detections/$pattern.txt" 2>/dev/null || echo 0)
if [[ $count -gt 0 ]]; then
echo " Found in $count files"
# 各ファイルに対してCodexタスク生成
while IFS= read -r file; do
target_instruction=$(echo "$UNIFICATION_MAP" | grep "^$pattern:" | cut -d: -f2 || echo "appropriate")
task="In $file, replace all uses of MirInstruction::$pattern with MirInstruction::$target_instruction.
Ensure semantic equivalence is maintained. For array operations, use BoxCall with appropriate method names.
For type operations, use TypeOp with appropriate parameters."
echo " Creating task for: $file"
echo "$task" > "mir13-migration/patches/$pattern-$(basename "$file").task"
done < "mir13-migration/detections/$pattern.txt"
fi
done
# === Phase 2: 並列実行スクリプト生成 ===
cat > mir13-migration/execute_migration.sh << 'MIGRATION_SCRIPT'
#!/bin/bash
# Execute MIR13 migration tasks
JOBS=${JOBS:-3}
LOG_DIR="logs-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$LOG_DIR"
echo "🚀 Executing MIR13 migration tasks..."
# 各タスクファイルを処理
for task_file in patches/*.task; do
[[ -e "$task_file" ]] || continue
task_content=$(cat "$task_file")
task_name=$(basename "$task_file" .task)
echo "Processing: $task_name"
# Codex実行（ここは環境に応じて調整）
../tools/codex-async-notify.sh "$task_content" > "$LOG_DIR/$task_name.log" 2>&1 &
# API制限対策で少し待つ
sleep 3
done
echo "✅ All tasks submitted!"
echo "📋 Monitor progress in tmux or check logs in: $LOG_DIR"
# 結果集計スクリプト
cat > verify_migration.sh << 'VERIFY'
#!/bin/bash
echo "🔍 Verifying MIR13 migration..."
# レガシー命令が残っていないか確認
legacy_found=0
for pattern in ArrayGet ArraySet RefNew RefGet RefSet TypeCheck Cast PluginInvoke; do
if rg -q "MirInstruction::$pattern" ../src/; then
echo "❌ Still found: $pattern"
rg "MirInstruction::$pattern" ../src/ | head -3
((legacy_found++))
fi
done
if [[ $legacy_found -eq 0 ]]; then
echo "✅ No legacy instructions found!"
echo "🎉 MIR13 migration complete!"
else
echo "⚠️ Found $legacy_found legacy instruction types remaining"
fi
# 新しい統一命令の使用統計
echo ""
echo "📊 Unified instruction usage:"
echo -n " BoxCall: "
rg "MirInstruction::BoxCall" ../src/ | wc -l
echo -n " TypeOp: "
rg "MirInstruction::TypeOp" ../src/ | wc -l
VERIFY
chmod +x verify_migration.sh
MIGRATION_SCRIPT
chmod +x mir13-migration/execute_migration.sh
# === サマリー表示 ===
echo ""
echo "📊 MIR13 Migration Summary:"
echo "=========================="
total_files=0
for pattern in "${LEGACY_PATTERNS[@]}"; do
file="mir13-migration/detections/$pattern.txt"
if [[ -s "$file" ]]; then
count=$(wc -l < "$file")
echo " $pattern: $count files"
((total_files += count))
fi
done
echo "=========================="
echo " Total: $total_files file occurrences"
echo ""
echo "🚀 Next steps:"
echo " 1. cd mir13-migration"
echo " 2. Review task files in patches/"
echo " 3. Run: ./execute_migration.sh"
echo " 4. After completion, run: ./verify_migration.sh"

153
tools/parallel-refactor-nyash.sh Normal file
View File

@ -0,0 +1,153 @@
#!/usr/bin/env bash
set -euo pipefail
# === Nyash特化版：並列リファクタリング自動化 ===
# ChatGPT5のアイデアをNyashプロジェクト用にカスタマイズ
# === 設定 ===
TARGET_DIR="${1:-src}"
FILE_GLOB="${2:-'*.rs'}"
JOBS="${JOBS:-4}" # 控えめな並列数
BUILD_CMD="cargo build --release -j32" # Nyash標準ビルド
TEST_CMD="cargo test --lib" # 基本的なユニットテスト
FMT_CMD="cargo fmt" # Rustフォーマッタ
# Codex非同期実行（通知機能付き）
CODEX_CMD="./tools/codex-async-notify.sh"
# === 準備 ===
WORK_DIR="refactor-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$WORK_DIR"/{plans,logs,results}
cd "$WORK_DIR"
# 対象ファイル列挙（大きいファイル優先）
find "../$TARGET_DIR" -name "$FILE_GLOB" -type f -exec wc -l {} + |
sort -rn |
awk '$1 > 500 {print $2}' > target_files.txt # 500行以上のファイルのみ
echo "🎯 Target files: $(wc -l < target_files.txt)"
echo "📁 Work directory: $WORK_DIR"
# === Phase 1: 並列提案生成（Codex利用）===
echo "🚀 Phase 1: Generating refactoring proposals..."
# 各ファイルに対してCodexタスクを生成
i=0
while IFS= read -r file; do
((i++))
basename_file=$(basename "$file")
# タスク定義
if [[ "$file" == *"mir/"* ]]; then
# MIR関連は特別扱い
task="Refactor $file to support MIR-13 instruction set. Remove legacy instructions and unify with BoxCall/TypeOp"
elif [[ "$file" == *"vm"* ]]; then
# VM関連
task="Refactor $file: split into smaller modules if >1000 lines, improve readability"
else
# 一般的なリファクタリング
task="Refactor $file: extract functions/modules if >1000 lines, improve maintainability"
fi
# 非同期でCodex実行
echo "[$i] Starting: $basename_file"
$CODEX_CMD "$task" > "logs/codex-$i-$basename_file.log" 2>&1
# タスク記録
echo "$i|$file|$task" >> task_list.txt
# 少し間隔を空ける（API制限対策）
sleep 2
done < target_files.txt
echo "⏳ Waiting for all Codex tasks to complete..."
echo " Monitor: tail -f logs/codex-*.log"
# === Phase 2: 結果収集・検証（手動トリガー）===
cat > apply_results.sh << 'EOF'
#!/bin/bash
# Phase 2: 各提案を検証・適用
echo "🔍 Phase 2: Applying and verifying changes..."
# 現在のブランチを記録
ORIGINAL_BRANCH=$(git branch --show-current)
# 各Codex結果を処理
for log in logs/codex-*.log; do
[[ -e "$log" ]] || continue
# ログから情報抽出
task_id=$(basename "$log" | sed 's/codex-\([0-9]*\)-.*/\1/')
file_info=$(grep "^$task_id|" task_list.txt)
target_file=$(echo "$file_info" | cut -d'|' -f2)
echo "==> Processing: $target_file"
# 新しいブランチ作成
branch_name="refactor/$task_id-$(basename "$target_file" .rs)"
git checkout -b "$branch_name" "$ORIGINAL_BRANCH" 2>/dev/null || {
git checkout "$branch_name"
git reset --hard "$ORIGINAL_BRANCH"
}
# ここで手動で変更を適用する必要がある
echo " ⚠️ Please apply changes from: $log"
echo " Press Enter when done..."
read -r
# フォーマット
cargo fmt -- "$target_file" 2>/dev/null || true
# ビルドテスト
if cargo build --release -j32 >/dev/null 2>&1; then
echo " ✅ Build passed"
# 簡単なテスト
if cargo test --lib --quiet 2>/dev/null; then
echo " ✅ Tests passed"
# コミット
git add -A
git commit -m "refactor: $(basename "$target_file") - reduce complexity and improve structure" \
-m "- Applied MIR-13 instruction set changes" \
-m "- Extracted modules/functions as needed" \
-m "- Maintained API compatibility"
echo " ✅ Committed to branch: $branch_name"
else
echo " ❌ Tests failed - reverting"
git reset --hard
git checkout "$ORIGINAL_BRANCH"
git branch -D "$branch_name" 2>/dev/null
fi
else
echo " ❌ Build failed - reverting"
git reset --hard
git checkout "$ORIGINAL_BRANCH"
git branch -D "$branch_name" 2>/dev/null
fi
done
# 元のブランチに戻る
git checkout "$ORIGINAL_BRANCH"
echo "✅ Phase 2 complete!"
echo "📊 Results:"
git branch --list 'refactor/*' | wc -l | xargs echo " Successful refactors:"
echo " Review with: git branch --list 'refactor/*'"
EOF
chmod +x apply_results.sh
echo ""
echo "✅ Phase 1 complete! Codex tasks submitted."
echo ""
echo "📋 Next steps:"
echo " 1. Wait for Codex notifications in tmux"
echo " 2. Run: ./apply_results.sh"
echo " 3. Review and merge branches"
echo ""
echo "💡 Tips:"
echo " - Check logs: ls -la logs/"
echo " - Monitor tmux: tmux attach -t claude"