diff --git a/CURRENT_TASK.md b/CURRENT_TASK.md index 792ff376..12e821ac 100644 --- a/CURRENT_TASK.md +++ b/CURRENT_TASK.md @@ -99,16 +99,22 @@ Update (2025-11-15 — Phase 25.1a: Stage1 build pipeline hotfix progress) - `tools/hakorune_emit_mir.sh` の Program→MIR 部分については、provider 経路が安定していることを確認しつつ、selfhost builder 経路（MirBuilderBox.emit_from_program_json_v0）が Stage1 CLI に対して stub MIR を返してしまう根本課題を Phase 25.1b で解く（現時点では `HAKO_SELFHOST_BUILDER_FIRST=0` を維持）。 - デバッグ導線（マージ後 Hako を `/tmp/hako_builder_merged.hako` に保存 etc.）は既に整備済みで、次のフェーズで原因特定と修正を行う。 - `.hako → MIR(JSON) → EXE` スモークは provider-first（`HAKO_SELFHOST_BUILDER_FIRST=0`）でグリーン。selfhost-first（`=1`）は Stage1 CLI の Program(JSON) を完全には扱えないため stub MIR になり、EXE が空挙動になる。MirBuilderBox 側の対応後（Phase 25.1b 以降）に再度 selfhost-first へ戻す予定。*** - - Phase 25.1b の具体タスク（selfhost builder 拡張）: +- Phase 25.1b の具体タスク（selfhost builder 拡張）: - `Program.defs` を MirBuilder 側で反映し、`HakoCli` 内の各メソッドを MIR 関数として生成する。 - `func_lowering` / `call_resolve` 相当の処理を Hako 側でも実装し、`Call("cmd_emit_*")` を `Global` resolve できるようにする。 - Loop / branch / boxcall など Stage1 CLI で出現する全ステートメントを lowering するため、`lang/src/mir/builder/internal/*` の helper を統合。 - JSON 出力を jsonfrag ベースで構築し、functions 配列に複数関数を格納可能にする。 - 上記の完了後、selfhost-first を既定に戻し Stage1 CLI EXE の JSON stdout 契約（Rust/llvmlite と同等）を仕上げる。 - ループについては LoopForm 正規化を前提とし、LoopForm の制約を満たさない形（キャリア3変数以上・順序再配置不能など）は selfhost builder では扱わず、タグ付き Fail‑Fast で検知する（PHI ノード生成は既存 LoopForm/LowerLoop helper に一元化）。 - - docs: `docs/development/roadmap/phases/phase-25.1b/README.md` を design deep‑dive 版に更新し、FuncLoweringBox / MirBuilderBox の現状把握と拡張方針（Fail‑Fast ポリシー・LoopForm/PHI ポリシー・Step0〜6 の実装順序など）を整理済み。Step0（Fail‑Fast/観測導線）は 2025-11-15 実装済み（defs_only/no_match タグ＋ `_lower_func_body` トレース）、Step1 は `HAKO_MIR_BUILDER_REQUIRE_MAIN=1` トグルによる main 必須チェックを inject_funcs に入れるところまで完了。Step2 では `FuncBodyBasicLowerBox` を追加して Local/If/Return パターンを既存の minimal lowers で箱化し、`_lower_func_body` から段階的に呼び出せるようにした。Step3（LoopForm対応）も 2025-11-15 実装完了：`FuncBodyBasicLowerBox._try_lower_loop` から `LowerLoopSumBcBox`/`LowerLoopSimpleBox` を呼び、LoopForm正規化済みループをMIRに落とす導線を確立、PHI/キャリア処理は既存Loop lowersに完全委譲、制約外は `[builder/funcs:unsupported:loopform]` でFail-Fast。Step4（MethodCall/ExternCall パリティ）は Rust 層 (`builder_calls.rs` / extern handler) と Stage‑B Program(JSON) の形を読み解いた設計メモに基づき、`FuncBodyBasicLowerBox._try_lower_return_method` による ArrayBox.size/get（params ベース receiver）と StringBox.length（引数なし）の最小カバーを実装しつつ、新箱 `ExternCallLowerBox`（`lang/src/mir/builder/func_body/extern_call_box.hako`）で `Return(hostbridge.extern_invoke(\"env.codegen\",\"emit_object\"|\"link_object\", Var(arg)))` を `externcall env.codegen.emit_object|link_object`＋`ret` に落とす経路を追加した。`FuncLoweringBox._lower_func_body` から BasicLowerBox の次に ExternCallLowerBox を呼ぶよう配線済み。Step1/Step2 の一環として `CliEntryLowerBox` / `CliRunShapeScannerBox` / `CliRunLowerBox` を追加し、Stage1 CLI エントリ（`Main.main`→`HakoCli.run`）と `HakoCli.run` の JSON 形状をタグ付きで観測できるようにした。`CliRunLowerBox` には `_check_shape`＋`_emit_mir` を実装し、MVP 用の `HakoCli.run`（argc 初期化・args.size/get・run/build/emit/check 4分岐・unknown=2）のみを `HAKO_MIR_BUILDER_CLI_RUN=1` ガード付きで selfhost builder から MIR に降ろせるようにした（Stage1 本番の run にはまだ適用していない）。*** + - 新規: Stage‑3 VM で `"" + MapBox` に頼らないよう、Rust parity の Box 型情報 API を設計・実装する。 + - Hako 側には `lang/src/shared/common/box_type_inspector_box.hako`（`BoxTypeInspectorBox`）を追加し、`method kind(value)` / `is_map(value)` / `is_array(value)` 等の API を提供する。 + - Stage0 Rust には `env.box_introspect` extern を追加し、`hostbridge.extern_invoke("env.box_introspect","kind",[value]) -> { kind: "MapBox", type_name: "MapBox", type_id: … }` のような応答を返す（plugin loader v2 経由）。Stage‑3 VM から `BoxTypeInspectorBox._describe` → `hostbridge.extern_invoke("env.box_introspect","kind",[value])` → `env.box_introspect.kind` provider という経路が動作することを確認する。 + - `BoxHelpers` / `JsonEmitBox` / `LoopOptsBox.build2` / `MirSchemaBox` など、Box 種別に依存するすべての箇所はこの API で判定し、`String + Box` を禁止する（fallback は「env/provider が使えないデバッグ専用」として限定）。 + - doc: Phase 25.1b README に Step3.1 として記載済み。`CURRENT_TASK.md` にも同タスク項目を追記。*** + - 進捗（2025-11-16）: BoxHelpers / MirSchemaBox / JsonEmitBox が BoxTypeInspectorBox 経由に差し替わり、`"" + MapBox` 依存が排除された。Stage‑3 VM 経路で `BoxTypeInspectorBox.kind` / `is_map` / `is_array` が MapBox / ArrayBox を正しく認識し、小さな Hako テストで env.box_introspect.kind provider 経路が end‑to‑end で動作することを確認済み。次は LoopOptsBox.build2 / JsonEmitBox._quote 等の残差に適用して multi-carrier LoopForm の selfhost-first を復旧する。 + - docs: `docs/development/roadmap/phases/phase-25.1b/README.md` を design deep‑dive 版に更新し、FuncLoweringBox / MirBuilderBox の現状把握と拡張方針（Fail‑Fast ポリシー・LoopForm/PHI ポリシー・Step0〜6 の実装順序など）を整理済み。Step0（Fail‑Fast/観測導線）は 2025-11-15 実装済み（defs_only/no_match タグ＋ `_lower_func_body` トレース）、Step1 は `HAKO_MIR_BUILDER_REQUIRE_MAIN=1` トグルによる main 必須チェックを inject_funcs に入れるところまで完了。Step2 では `FuncBodyBasicLowerBox` を追加して Local/If/Return パターンを既存の minimal lowers で箱化し、`_lower_func_body` から段階的に呼び出せるようにした。Step3（LoopForm対応）も 2025-11-15 実装完了：`FuncBodyBasicLowerBox._try_lower_loop` から `LowerLoopSumBcBox`/`LowerLoopSimpleBox` を呼び、LoopForm正規化済みループをMIRに落とす導線を確立、PHI/キャリア処理は既存Loop lowersに完全委譲、制約外は `[builder/funcs:unsupported:loopform]` でFail-Fast。Step4（MethodCall/ExternCall パリティ）は Rust 層 (`builder_calls.rs` / extern handler) と Stage‑B Program(JSON) の形を読み解いた設計メモに基づき、`FuncBodyBasicLowerBox._try_lower_return_method` による ArrayBox.size/get（params ベース receiver）と StringBox.length（引数なし）の最小カバーを実装しつつ、新箱 `ExternCallLowerBox`（`lang/src/mir/builder/func_body/extern_call_box.hako`）で `Return(hostbridge.extern_invoke(\"env.codegen\",\"emit_object\"|\"link_object\", Var(arg)))` を `externcall env.codegen.emit_object|link_object`＋`ret` に落とす経路を追加した。`FuncLoweringBox._lower_func_body` から BasicLowerBox の次に ExternCallLowerBox を呼ぶよう配線済み。Step1/Step2 の一環として `CliEntryLowerBox` / `CliRunShapeScannerBox` / `CliRunLowerBox` を追加し、Stage1 CLI エントリ（`Main.main`→`HakoCli.run`）と `HakoCli.run` の JSON 形状をタグ付きで観測できるようにした。`CliRunLowerBox` には `_check_shape`＋`_emit_mir` を実装し、MVP 用の `HakoCli.run`（argc 初期化・args.size/get・run/build/emit/check 4分岐・unknown=2）のみを `HAKO_MIR_BUILDER_CLI_RUN=1` ガード付きで selfhost builder から MIR に降ろせるようにした（Stage1 本番の run にはまだ適用していない）。さらに Stage‑B 側の func_scan トグル（`HAKO_STAGEB_FUNC_SCAN`）は「未設定なら既定ON、`\"0\"` のときだけ OFF」とするように compiler_stageb.hako を変更し、Stage‑B を直接叩いたときに env 立て忘れで defs が欠落するバグを構造的に防ぐようにした。*** - LoopForm 複雑ケースについては、「Rust 側の LoopForm/PHI 実装をオラクルとし、同じ .hako を provider-first と selfhost-first の両方で通す」方針を docs に追記。LoopForm/PHI のロジック自体は Hako 側では `lower_loop_*_box.hako` 群に閉じ込め、FuncLowering/MirBuilder 本体は `_rebind` 呼び出しのみを行う。Rust は Stage‑B/MIR→LLVM の検証と既存 provider 経路の「正解」としてだけ使う。 - - 新しい LoopForm 用 helper 箱 `lower_loop_multi_carrier_box.hako` を追加し、multi-carrier ループ（fib 風）を Program(JSON v0) 上で検出して `[mirbuilder/internal/loop:multi_carrier:detected]` タグを出すだけの足場を用意（Phase 25.1b ではまだ LoopFormBox への委譲は行わず、Fail-Fast ポリシーを維持）。 + - 新しい LoopForm 用 helper 箱 `lower_loop_multi_carrier_box.hako` を追加し、multi-carrier ループ（fib 風）を Program(JSON v0) 上で検出して `[mirbuilder/internal/loop:multi_carrier:detected:limit_kind=const|param,...]` を出しつつ `LoopFormBox.build2(mode="multi_count")` へ委譲（limit が `Int` だけでなく `Var(n)`＝パラメータ参照でも処理可能に）。 - スモーク構成について、「Rust builder 用スモークと selfhost builder 用スモークをペアで置く」ルール（`*_provider_vm.sh` / `*_selfhost_vm.sh` 命名、同じ .hako を共有）を phase-25.1b README に記載。今後は loop/method/extern/Stage1 CLI 用の selfhost-first canary を `phase251` 配下に追加していく。 Update (2025-11-16 — Stage‑B using resolver alias 化 & 環境導線) @@ -212,6 +218,42 @@ Helper (2025-11-14 — numeric_core 開発用ラッパ追加) - こうして生成した MIR(JSON) に対して `NYASH_AOT_NUMERIC_CORE_STRICT=1` + `NYASH_LLVM_DUMP_MIR_IN=...` を使えば、LLVM/EXE ラインでも同じ MIR を共有できる。 +Update (2025-11-16 — Phase 25.1b: selfhost builder multi-carrier & BoxTypeInspector 経路の一段落) +- 状況: + - selfhost builder 側の LoopForm multi-carrier 経路（`LowerLoopMultiCarrierBox` → `LoopFormBox.build_loop_multi_carrier`）は設計と骨格実装まで到達済みで、Box 型情報 API（`BoxTypeInspectorBox` / `env.box_introspect.kind`）もひととおり配線済み。 + - fib multi-carrier 経路と selfhost multi-carrier smoke 用 canary（`tools/smokes/v2/profiles/quick/core/phase251/selfhost_mir_loopform_multi_carrier_vm.sh`）は、BoxTypeInspector 経由の multi-carrier LoopForm で PASS するところまで到達した（`[mirbuilder/internal/loop:multi_carrier:detected:limit_kind=param,...]` と `[funcs/basic:loop.multi_carrier] -> TestBox.fib/1` ログを確認済み）。 + - 進捗（Codex run, 2025-11-16）: + - `BoxTypeInspectorBox._describe` → `hostbridge.extern_invoke("env.box_introspect","kind",[value])` → `env.box_introspect.kind` provider → plugin loader v2 の BoxIntrospect 実装までの経路を Stage‑3 VM で確認済み（MapBox / ArrayBox に対して kind / is_map / is_array が正しく返る）。 + - selfhost builder 経由の fib multi-carrier emit（`tools/hakorune_emit_mir.sh tmp/fib_multi.hako tmp/fib_multi_mir.json`）では、`env.box_introspect.kind` / `JSON.stringify` 起因の Invalid instruction が消え、child rc=0 で完走する。ログには multi-carrier detection タグと `[funcs/basic:loop.multi_carrier] -> TestBox.fib/1` が出力される。 + - 出力 MIR(JSON) には `"name":"TestBox.fib/1"` を持つ関数が含まれており、selfhost-first multi-carrier 経路が Box 型 API 依存で起動できることを確認済み。ただしトップレベル JSON 形（`{"functions":[{...main...},{...kind:\"MIR\"...}]}` と provider 側の module 形の差）は残っており、これは 25.1c 以降の構造タスクとして整理予定。 +- 追加メモ（Stage‑B / selfhost CLI canary 周りの現状把握）: + - `tools/smokes/v2/profiles/quick/core/phase251/selfhost_cli_run_basic_vm.sh` で使っている簡易 HakoCli.run サンプルに対しては、現時点でも Stage‑B (`compiler_stageb.hako`) 実行中に VM エラー: + - `❌ VM error: Invalid value: use of undefined value ValueId(N)` が発生し、Program(JSON v0) が一行としては出力されない（`tools/hakorune_emit_mir.sh` 側でも Program 抽出に失敗している）。 + - `NYASH_VM_VERIFY_MIR=1` を立てて `compiler_stageb.hako` を直接実行すると、Stage‑B が生成した MIR に対して多数の `Undefined value %0 used in block ...` 診断が出る: + - 例: `Stage1UsingResolverBox._collect_using_entries/1`, `ParserStringUtilsBox.skip_ws/2`, `ParserIdentScanBox.scan_ident/2`, `ParserBox.parse_stmt2/2` など。 + - これは BoxTypeInspector / env.box_introspect.kind とは独立した、Stage‑B パイプライン（ParserBox→Stage1UsingResolver→FuncScannerBox 等）の MIR 生成側の既知問題として切り出す。 + - 現状の方針: + - `.hako → Program(JSON v0) → MIR(JSON)` のうち、multi-carrier fib などの core ケースについては selfhost builder 経路が PASS 済みであり、Stage‑B の不整合は「Stage1 CLI 相当の大きめ入力でのみ顕在化している VM/MIR バグ」として扱う。 + - `tools/hakorune_emit_mir.sh` の `diagnose_stageb_failure()` に `Invalid value: use of undefined value` 向けの診断メッセージを追加し、今後同様の症状が出たときに `NYASH_VM_VERIFY_MIR=1`＋`docs/private/roadmap/phases/phase-20.33/DEBUG.md` へ誘導できるようにした（構造バグとして Stage‑B/MIR 側で追う）。 + - selfhost CLI canary（HakoCli.run/2 lowering）は、Stage‑B 側の MIR 整合性が改善されるまでは「Stage‑B 側に起因する未解決バグ」として保留し、BoxIntrospect / multi‑carrier 経路の進行とは切り離して扱う。 +- Next tasks (Phase 25.1b → 25.1c handoff / Codex): + 1. Rust 層 Call/ExternCall 契約のドキュメント固定（Step 4.1） + - `src/mir/builder/builder_calls.rs` / `src/backend/mir_interpreter/handlers/{calls,externs,extern_provider}.rs` / `src/runtime/plugin_loader_v2/enabled/extern_functions.rs` をベースに、「MethodCall/ExternCall/hostbridge.extern_invoke/ env.codegen/env.mirbuilder」の SSOT を Phase 25.1b README に記録（実施済み）。 + 2. Stage1 CLI defs / MethodCall / ExternCall 拡張（Step4 本体） + - 対象: `lang/src/runner/launcher.hako` 内で実際に使われている `FileBox` / `ArrayBox` / `MapBox` / `String` メソッドと `hostbridge.extern_invoke("env.codegen", "emit_object"|"link_object", args)` などを selfhost builder 側でも lowering できるようにする（ただし Rust 側の SSOT に合わせて挙動をコピーするだけで、新仕様は足さない）。 + 3. selfhost builder 出力 MIR(JSON) のトップレベル形の正規化（25.1c 構造タスク） + - 現状の selfhost-first 出力（`{"functions":[{name:\"main\",...},{kind:\"MIR\",...}]}`）を、Rust provider と同じく「トップレベルが MIR module（kind=MIR, functions=[...])」の形に揃える（LoopForm / LoopOpts / JsonEmit 側の責務分離込みで要整理）。 + 4. Stage1 CLI run / launcher 用 canary の拡張 + - 既存の `tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_selfhost_vm.sh` は入口検出タグ（`[builder/cli:entry_detected]` / `[builder/cli:run_shape]`）まで PASS しているので、今後は `HAKO_MIR_BUILDER_CLI_RUN=1` を使った run 本体の MIR 生成 canary を追加し、Step4 の MethodCall/ExternCall パリティを継続的に検証する。 + 5. Ny selfhost パイプライン（Ny→JSON v0）の現状と無限ループ疑い（構造的デバッグタスク） + - Ny selfhost は `.ny`/Nyash 用の補助ルートであり、`.hako → Program(JSON v0) → MIR(JSON)` の Stage‑B/MirBuilder/selfhost builder 経路とは別レイヤ（`src/runner/selfhost.rs`）に置く。 + - Phase 25.1b で `NYASH_USE_NY_COMPILER` の既定値を OFF に変更し、明示的に `NYASH_USE_NY_COMPILER=1` を立てない限り Runner から `try_run_selfhost_pipeline` が呼ばれないようにした（Ny selfhost は opt-in のみ）。`.hako` 実行や `tools/hakorune_emit_mir.sh` 経由のメイン経路はこの影響を受けない。 + - Python MVP ハーネス（`tools/ny_parser_mvp.py`）も `NYASH_NY_COMPILER_USE_PY=1` のときだけ起動するようにし、selfhost パイプラインからの Python 依存は既定では完全に外した。 + - 一方で Ny selfhost を明示 ON（`NYASH_USE_NY_COMPILER=1`）かつ inline 経路（`inline_selfhost_emit.hako`）を通した場合、`ParserBox.parse_program2` 周辺で 60s タイムアウトし、その後の VM 実行で `Undefined variable: local`（Stage‑3 キーワード）エラーが出ていることを確認。これは Ny selfhost の parser/Stage‑3/using 周りに無限ループ相当のバグが残っている疑いとして切り出す。 + - Phase 25.1b 本体では `.hako` selfhost builder 側のフォールバック禁止と BoxTypeInspector/LoopForm 経路の整備までをゴールとし、Ny selfhost 側は `src/runner/selfhost.rs` のログ強化（`[ny-compiler] inline timeout ...`＋`[ny-inline:hint]`）で「どこで止まっているか」が見える状態まで整えた上で、25.1c 以降の別タスクとして原因究明・修正を進める。 + - Ny selfhost 経路とは別に、Stage‑B (`compiler_stageb.hako`) 側の失敗が selfhost CLI の canary に見えてきている。`[plugin/missing] vm providers not loaded: ["FileBox", "ConsoleBox", "ArrayBox", "MapBox", "StringBox", "IntegerBox"]` はあくまで「プラグイン版コア Box が見つからない」という警告であり、Program(JSON v0) emit の必須条件ではない（core‑ro モードではプラグイン無しでもコンパイラ本体は動ける設計）。現状の Stage‑B 失敗は、プラグイン不足ではなく、別の構文/using/Stage‑3 周りのエラーが rc=1 を返している可能性が高く、これは selfhost CLI フェーズとは独立に compiler_stageb.hako 側のバグとして追いかける予定。 + + Update (2025-11-14 — 21.8 kickoff: MatI64/IntArrayCore builder integration) - Context: - 21.5: AotPrep/CollectionsHot v1 + microbench整備まで完了（linidx/maplin ≒ C=100%）。arraymap/matmul は次フェーズ送り。 diff --git a/docs/development/roadmap/phases/phase-25.1b/README.md b/docs/development/roadmap/phases/phase-25.1b/README.md index 4b49bbde..4ce525ed 100644 --- a/docs/development/roadmap/phases/phase-25.1b/README.md +++ b/docs/development/roadmap/phases/phase-25.1b/README.md @@ -17,17 +17,43 @@ Status: Step0〜3 実装済み・Step4（Method/Extern）実装フェーズ - `FuncScannerBox` ＋ `HAKO_STAGEB_FUNC_SCAN=1` により、`static box` メソッド（暗黙の `me` 引数付き）も defs に載る。 - using 解決: - `Stage1UsingResolverBox`（`lang/src/compiler/entry/using_resolver_box.hako`）＋ `HAKO_STAGEB_MODULES_LIST` で `nyash.toml` の `[modules]` を参照し、`using lang.mir.builder.MirBuilderBox` 等をファイル結合前に解決。 - - Stage‑B entry 側は string literal using を廃止し、`using lang.compiler.entry.using_resolver as Stage1UsingResolverBox` のように module alias を使用する。 +- Stage‑B entry 側は string literal using を廃止し、`using lang.compiler.entry.using_resolver as Stage1UsingResolverBox` のように module alias を使用する。 + +#### Stage‑B func_scan トグルのデフォルト（HAKO_STAGEB_FUNC_SCAN） + +- 目的: + - Stage‑B を直接叩いたときに `HAKO_STAGEB_FUNC_SCAN` を立て忘れても、`HakoCli.run` や `TestBox.fib` のようなメソッド定義が `Program.defs` にきちんと入るようにする（selfhost builder / FuncLowering 側の前提を崩さない）。 +- 実装（compiler_stageb.hako 内）: + - 以前: `HAKO_STAGEB_FUNC_SCAN=1` のときだけ `FuncScannerBox.scan_all_boxes` を呼び出し、それ以外は defs を生成しなかった。 + - 現在: `HAKO_STAGEB_FUNC_SCAN` が未設定 (`null`) のときは既定で ON とみなし、**明示的に `"0"` が入っているときだけ OFF** として扱う。 + - これにより、`tools/hakorune_emit_mir.sh` や v2 スモーク以外から Stage‑B を直接呼び出しても、defs が常に生成される。 + - 既存のテストで func_scan を無効化したいケースでは、`HAKO_STAGEB_FUNC_SCAN=0` を明示すれば従来どおり defs をスキップできる。 #### Stage‑B の安定度と使用上の注意 - 正規経路: - Stage‑B は `tools/hakorune_emit_mir.sh` / `tools/selfhost/selfhost_build.sh` 経由で呼び出すことを前提としており、これらのラッパが Stage‑3 用 ENV（`NYASH_PARSER_STAGE3=1` / `HAKO_PARSER_STAGE3=1` / `NYASH_PARSER_ALLOW_SEMICOLON=1` など）を一括でセットする。 - - Phase 25.1b では「このラッパ経由で呼ぶ限り Stage‑B 自体は安定」とみなし、主な改善対象を Program→MIR の selfhost builder 側に置く。 + - Phase 25.1b では「multi-carrier fib などの core 小ケースについては、このラッパ経由で呼ぶ限り Stage‑B 自体は十分に安定」とみなし、主な改善対象を Program→MIR の selfhost builder 側に置く。 - 手動実行時の注意: - Stage‑3 ENV を立てずに Stage‑B / VM を直接叩くと、`Undefined variable: local` のようなエラーが発生するが、これは構文/実装バグではなく「Stage‑3 キーワード（local など）を Stage‑1 と同じルールでパースしてしまっている」ため。 - 詳細な原因と対処は `docs/development/troubleshooting/stage3-local-keyword-guide.md` にまとめてあり、selfhost 開発では「まずラッパスクリプトを使う → 必要な場合のみ ENV を明示して直叩きする」方針とする。 +#### Stage‑B と selfhost CLI canary（HakoCli.run/2）の現状 + +- selfhost CLI の最小ケース（`tools/smokes/v2/profiles/quick/core/phase251/selfhost_cli_run_basic_vm.sh` が生成する HakoCli.run サンプル）に対しては、現状 Stage‑B 実行中に VM エラー: + - `❌ VM error: Invalid value: use of undefined value ValueId(N)` が発生し、Program(JSON v0) が 1 行としては出力されない（`tools/hakorune_emit_mir.sh` が Program 抽出に失敗する）。 +- `NYASH_VM_VERIFY_MIR=1` を立てて `lang/src/compiler/entry/compiler_stageb.hako` を直接叩くと、Stage‑B が生成した MIR に対して: + - `Stage1UsingResolverBox._collect_using_entries/1` + - `ParserStringUtilsBox.skip_ws/2` + - `ParserIdentScanBox.scan_ident/2` + - `ParserBox.parse_stmt2/2` + - などに `Undefined value %0 used in block ...` が多数報告されることが確認できる（詳細は `docs/private/roadmap/phases/phase-20.33/DEBUG.md` の「Invalid value: use of undefined value ValueId(N)」節を参照）。 +- 対応方針（Phase 25.1b 時点）: + - BoxTypeInspector / multi‑carrier LoopForm 経路とは独立した **Stage‑B/MIR 側の構造バグ** として扱い、selfhost CLI canary（HakoCli.run/2 lowering）はこの問題が解消されるまで「Stage‑B 側の既知の未修正バグ」として保留する。 + - `tools/hakorune_emit_mir.sh` には `diagnose_stageb_failure()` を追加し、Stage‑B の標準出力に `Invalid value: use of undefined value` が含まれている場合に: + - `[stageb/diagnose] VM reported 'use of undefined value' during Stage‑B execution.` などのタグを出しつつ、 + - `NYASH_VM_VERIFY_MIR=1`＋`compiler_stageb.hako` 直叩き、および `docs/private/roadmap/phases/phase-20.33/DEBUG.md` への導線を表示するようにした。 + ### Rust provider (`env.mirbuilder.emit`) - `program_json_to_mir_json_with_imports`: @@ -122,16 +148,18 @@ Status: Step0〜3 実装済み・Step4（Method/Extern）実装フェーズ - `lang/src/mir/builder/internal/lower_loop_multi_carrier_box.hako` - 目的: - - Fibonacci 風の「multi-carrier」ループ（`i,a,b,t` など複数のキャリアを持つループ）を selfhost builder 側で検出し、将来的に LoopFormBox に委譲できるようにする足場。 - - 現段階の挙動: - - Program(JSON v0) 内に - - `type:"Loop"` と `type:"Compare"` が存在し、 - - ループ本体に `type:"Local"` が複数存在する（=キャリア候補が複数ある） - ことを確認したら、`HAKO_MIR_BUILDER_TRACE=1` 相当（builder_config.trace_enabled）有効時に - `[mirbuilder/internal/loop:multi_carrier:detected]` タグを出す。 - - まだ LoopFormBox への `build2` 委譲は行わず、`null` を返して Rust provider 経路にフォールバックする（Fail-Fast ポリシー維持）。 + - Fibonacci 風の「multi-carrier」ループ（`i,a,b,t` など複数のキャリアを持つループ）を selfhost builder 側で検出・LoopFormBox (`mode="multi_count"`) に委譲する。 + - 現段階の挙動（2025-11-16 時点）: + - Program(JSON v0) 内で `Loop` + `Compare` を検出し、キャリア初期値（`local a = 0; local b = 1; ...`）を 2 個以上抽出。 + - `i < N` の `N` については、`Int` リテラルだけでなく `n` のようなパラメータ `Var` もサポートし、`limit_kind=const|param` として `LoopFormBox.build2` に伝達。 + - 成功時は `[mirbuilder/internal/loop:multi_carrier:detected:limit_kind=param,value=...|param_reg=...]` タグを確実に出力し、そのまま LoopForm から返ってきた MIR を `_rebind` する。 + - ループ limit が `local` 参照など selfhost で扱えない場合は `[mirbuilder/internal/loop:multi_carrier:limit:unsupported]` を出して `null` を返し、Rust provider 経路へ退避。 + - スモーク: + - `tools/smokes/v2/profiles/quick/core/phase251/selfhost_mir_loopform_multi_carrier_vm.sh` + - Stage‑B で `TestBox.fib(n)` を emit し、selfhost builder が `[funcs/basic:loop.multi_carrier]` を出したうえで `TestBox.fib/1` を含む MIR(JSON) を生成するかをチェック。 + - `carriers` 長や `limit_kind=param` ログを条件に PASS/FAIL を分岐（provider fallback 時は SKIP）。 - 今後の拡張: - - `LoopScanBox` を使ってキャリア変数群・limit などを抽出し、`LoopOptsBox.build2(opts)` に渡すロジックを追加する。 + - `LoopFormBox.build_loop_multi_carrier` の `limit_kind=param` 実装を一般化し（現在は param register コピー → `reg_limit` 初期化まで対応済み）、break/continue 付き multi-carrier も下ろせるようにする。 - 代表ケースとして `tools/smokes/v2/profiles/quick/core/vm_loop_phi_multi_carriers.sh` と同型の .hako を selfhost-first で通す canary を追加し、VM/EXE rc を Rust オラクルと比較する。 ## Next Steps（実装フェーズに入るときの TODO） @@ -196,9 +224,23 @@ Status: Step0〜3 実装済み・Step4（Method/Extern）実装フェーズ - どの関数名で `_lower_func_body` が `null` を返したかを `HAKO_SELFHOST_TRACE=1` でログ出力。 - `tools/hakorune_emit_mir.sh` - 既存の head/tail ログ出力で `[builder/selfhost-first:*]` タグがそのまま表示されることを確認済み（追加改修なし）。 + - Phase 25.1b 以降、`HAKO_SELFHOST_BUILDER_FIRST=1` で呼び出された場合は「Stage‑B → selfhost builder（＋Stage1 CLI）」経路のみを試行し、selfhost builder が失敗した場合は即座に非0で終了する。selfhost-first モードでは `env.mirbuilder.emit` / provider delegate へのフォールバックは行わず、MirBuilder の未整備を隠さない方針とする（provider 経路を使うときは `HAKO_SELFHOST_BUILDER_FIRST=0` を明示）。 - 成果物: - selfhost-first で Stage1 CLI を通したときに、どの関数/構造がまだ未サポートなのかがログで推測できる状態。 +#### 補足: Ny selfhost パイプラインとの関係（Phase 25.1b 時点） +- `.hako → Program(JSON v0) → MIR(JSON)` のメイン経路は、Stage‑B（`compiler_stageb.hako`）と MirBuilder/selfhost builder で完結させる。Ny selfhost（`src/runner/selfhost.rs`）は `.ny` 用の補助ルートとして扱い、Phase 25.1b のスコープからは外す。 +- `NYASH_USE_NY_COMPILER`: + - Phase 25.1b で「明示 opt-in」（既定=0）に変更。Runner は `NYASH_USE_NY_COMPILER=1` が立っているときだけ selfhost パイプライン（Ny→JSON v0）を試行し、それ以外では従来どおり Rust parser/JSON v0 bridge を使う。 + - `.hako` 実行や `tools/hakorune_emit_mir.sh` 経由の Stage‑B/MirBuilder/selfhost builder には影響しない（これらは `NYASH_USE_NY_COMPILER=0` / `NYASH_DISABLE_NY_COMPILER=1` で起動）。 +- Python MVP: + - `tools/ny_parser_mvp.py` は Phase 15 時点の Ny→JSON v0 実験用ハーネスであり、Phase 25.1b では `NYASH_NY_COMPILER_USE_PY=1` のときだけ有効にする。 + - 既定では Ny selfhost パイプラインから Python には落ちない（脱 Python 方針に合わせて dev 専用の補助線に格下げ）。 +- inline selfhost compiler（`inline_selfhost_emit.hako`）: + - `try_run_selfhost_pipeline` の最終手段として、`using lang.compiler.parser.box as ParserBox` / `using lang.compiler.stage1.emitter_box as EmitterBox` を含む小さな Hako を生成し、`ParserBox.parse_program2`→`EmitterBox.emit_program` で JSON v0 を得る経路が残っている。 + - 現状、この inline 経路は `.ny` の大きなソースに対して 60s タイムアウト＋ `Undefined variable: local` を伴うことがあり、ParserBox/Stage‑3/using 周りに無限ループ相当のバグが残っている疑いがある。 + - Phase 25.1b では `.hako` selfhost builder から Ny selfhost 経路を切り離すことを優先し、inline 経路のバグは `[ny-compiler] inline timeout ...` ＋ `[ny-inline:hint]`（stdout/stderr の head を添える）で可視化したうえで、後続フェーズ（25.1c 以降）の構造タスクとして扱う。 + ### Step 1 — defs injection の再設計 - Status: initial-implemented（main 必須チェックはトグル付き; multi-function への完全移行は後続 Step）。 - 目的: `FuncLoweringBox.inject_funcs` で main 関数の有無を意識し、multi-function モジュールの土台を整える。 @@ -232,8 +274,24 @@ Status: Step0〜3 実装済み・Step4（Method/Extern）実装フェーズ - LoopForm制約外は必ずタグ付きでFail-Fast（Rust providerに退避可能）。 - 成果物: - `cmd_build_exe`の`loop(i < argc)`等、Stage1 CLIの代表的なwhile/forパターンをselfhost builderで通せる基礎が整った。 + - 追加アップデート（2025-11-16）: multi-carrier ループ（`TestBox.fib(n)` など）も `LowerLoopMultiCarrierBox` → `LoopFormBox.build_loop_multi_carrier` 経由で selfhost lowering できるようになり、limit が `Int` でなく `Var(n)` でも `[mirbuilder/internal/loop:multi_carrier:detected:limit_kind=param,...]` を出して処理できる。 - 次のステップ: LoopForm対応の動作確認スモークテスト追加、Step4（MethodCall/ExternCall）へ進む。 +#### Step 3.1 — Box 型情報 API（Rust Parity）★New +- 背景: + - Stage‑3 VM では `"" + MapBox` のような「Box を文字列に暗黙変換する演算」が禁止されており、既存の `JsonEmitBox` / `BoxHelpers`（`LoopOptsBox.build2` から呼び出される）が `repr` 判定に依存しているため multi-carrier の JSON 生成が `Type error` で停止した。 + - Rust 側の MirBuilder は enum で型が決まっており `match` で分岐できる。Hakorune 側でも同等の「Box の種別を問い合わせる API」を用意して文字列ハックを撤廃する必要がある。 +- 設計方針: + 1. `lang/src/shared/common/box_type_inspector_box.hako` を追加し、`BoxTypeInspectorBox.kind(value)` / `is_map(value)` / `is_array(value)` 等の API を提供する。 + 2. 実装は Stage0 Rust 側に `env.box_introspect(kind, value)` 的な extern を追加し、`hostbridge.extern_invoke("env.box_introspect","kind",[value])` で種別名（例: `"MapBox"`, `"ArrayBox"`, `"Int"`）を返す。 + 3. `BoxHelpers` / `JsonEmitBox` / `LoopOptsBox` など、Box 種別チェックが必要な箇所はすべてこの API に置き換え、`"" + value` を一切使わない。 + 4. 返り値は最小で `Null/Bool/Int/String` と `MapBox/ArrayBox/HostHandleBox`（Stage1 で使用する型）をカバーし、将来的に `type_id` などを拡張する。 +- 追加で行うこと: + - `CURRENT_TASK.md` に Box 型 API 実装タスクを追加し、LoopForm multi-carrier の JSON 出力がこの API 依存であることを明示。 + - Stage0 側での対応（`env.box_introspect` 新規 extern）の設計も合わせて `phase-25.1b/README.md` に記述しておく（Selfhost 側で API 追加→Rust 側 stub→VM 反映の順）。 + - 現状（2025-11-16 時点）: Stage‑3 VM 経路で `BoxTypeInspectorBox.kind` / `is_map` / `is_array` が MapBox / ArrayBox を正しく認識し、小さな Hako テストで `hostbridge.extern_invoke("env.box_introspect","kind",[value])` → `env.box_introspect.kind` provider → plugin loader v2 の BoxIntrospect 実装までが end‑to‑end で動作することを確認済み。 + - fib multi‑carrier 経路と selfhost multi‑carrier smoke 用の canary ケース（`tools/smokes/v2/profiles/quick/core/phase251/selfhost_mir_loopform_multi_carrier_vm.sh`）は、2025‑11‑16 時点で `env.box_introspect.kind` provider 経路＋BoxTypeInspector 経由の multi-carrier LoopForm で PASS 済み。ログに `[mirbuilder/internal/loop:multi_carrier:detected:limit_kind=param,...]` と `[funcs/basic:loop.multi_carrier] -> TestBox.fib/1` が現れ、出力 MIR(JSON) に `"name":"TestBox.fib/1"` が含まれることを確認したため、「env.box_introspect.kind provider 経路完了 / multi‑carrier selfhost-first canary PASS」とみなす。 + ### Step 4 — MethodCall / ExternCall パリティ（設計メモ・Rust層読解込み） - Status: design-only（Rust 層の挙動を踏まえた設計まで） - 目的: `hostbridge.extern_invoke` / `FileBox` / `ArrayBox` など Stage1 CLI で多用される呼び出しを selfhost builder でも再現し、Rust 側の `build_method_call` / extern handler と意味論を揃える（ただしスコープは Stage1 必要最小限に限定）。 @@ -319,6 +377,80 @@ Status: Step0〜3 実装済み・Step4（Method/Extern）実装フェーズ が見つかった場合は、`[builder/funcs:unsupported:call]` タグを出して `null` で戻る。 - これにより、「知らない形をなんとなく MIR にする」ことを避け、Rust provider や legacy CLI delegate に退避できるようにする。 +#### Step 4.1 — Rust 層 Call/ExternCall 契約の整理（移植元 SSOT） + +- 目的: + - Stage1 側の MethodCall/ExternCall lowering を「Rust 実装の振る舞い」に正確に揃えるため、Rust 層の Call/ExternCall/hostbridge 経路を SSOT として整理しておく。 + - ここでの整理は構造レベルに留め、意味論の“拡張”は行わない（Hako 側はこの契約に従うだけ）。 + +- Rust 側のコア断面（ざっくり構造）: + - **MIR ビルダ（呼び出し生成）**: + - `src/mir/builder/builder_calls.rs` + - `emit_unified_call(dst, CallTarget, args)`: + - `CallTarget::Method { box_type, method, receiver }` → `Callee::Method` を作り、`MirInstruction::Call { callee: Some(Callee::Method{..}), ... }` を emit。 + - `CallTarget::Extern(name)` → 文字列 `"env.codegen.emit_object"` などを `ExternCall` に変換（`iface_name="env.codegen"`, `method_name="emit_object"`）。 + - `CallTarget::Global(name)` → `Callee::Global(name)` 付き `Call` を emit（`execute_global_function` へ）。 + - **VM 側 Call ハンドラ**: + - `src/backend/mir_interpreter/handlers/calls/global.rs`: + - `execute_global_function(func_name, args)`: + - まず `functions` テーブルにあれば module 内関数として実行。 + - そうでない場合、`normalize_arity_suffix("name/1")` した base 名に対して: + - `"print"` → `execute_extern_function("print", args)`。 + - `"hostbridge.extern_invoke"` → `execute_extern_function("hostbridge.extern_invoke", args)`（SSOT: hostbridge 経由の extern は必ずここを通る）。 + - `"env.mirbuilder.emit"` / `"env.codegen.emit_object"` / `"env.codegen.link_object"`: + - それぞれ `crate::host_providers::{mir_builder,llvm_codegen}` を直接呼ぶ「グローバル関数版」ルート。 + - `src/backend/mir_interpreter/handlers/calls/externs.rs`: + - `execute_extern_function(iface, method, args)`: + - `("env.mirbuilder","emit")` / `("env.codegen","emit_object")` / `("env.codegen","link_object")` などを `extern_provider_dispatch` に委譲。 + - `"hostbridge.extern_invoke"` base 名もここから `extern_provider_dispatch("hostbridge.extern_invoke", args)` に流す。 + - **ExternCall / hostbridge.extern_invoke の provider**: + - `src/backend/mir_interpreter/handlers/externals.rs`: + - ExternCall 形（`MirInstruction::ExternCall`) を `iface_name`,`method_name` ごとに振り分け: + - `("env.mirbuilder","emit")` → `extern_provider_dispatch("env.mirbuilder.emit", args)`。 + - `("env.codegen","emit_object")` → `extern_provider_dispatch("env.codegen.emit_object", args)`。 + - `("env.codegen","link_object")` → 第3引数 ArrayBox `[obj_path, exe_out?]` を取り出して C-API ルートへ。 + - `("hostbridge","extern_invoke")` → `extern_provider_dispatch("hostbridge.extern_invoke", args)`（なければ Invalid）。 + - `src/backend/mir_interpreter/handlers/extern_provider.rs`: + - `extern_provider_dispatch(key, args)`: + - `"env.mirbuilder.emit"`: + - `args[0]` を `program_json` にし、`HAKO_MIRBUILDER_IMPORTS` から imports マップを読む。 + - `host_providers::mir_builder::program_json_to_mir_json_with_imports` を呼んで MIR(JSON) 文字列を返す。 + - `"env.codegen.emit_object"`: + - `args[0]` を MIR(JSON) 文字列にして v1 へ normalize → `llvm_codegen::mir_json_to_object`。 + - `"env.codegen.link_object"`: + - `args[0]`=obj_path, `args[1]`=exe_out を文字列化し、C-API ルート（`NYASH_LLVM_USE_CAPI=1` + `HAKO_V1_EXTERN_PROVIDER_C_ABI=1`）で `link_object_capi`。 + - `"env.get"` / `"env.box_introspect.kind"` / `"hostbridge.extern_invoke"` もここで扱う（BoxIntrospect は plugin_loader_v2 に委譲）。 + +- plugin_loader v2 側の env.*: + - `src/runtime/plugin_loader_v2/enabled/extern_functions.rs`: + - `extern_call(iface_name, method_name, args)` で `env.*` を一括処理。 + - `handle_mirbuilder("emit", args)`: + - `args[0]` の Program(JSON v0) 文字列を受け取り、`host_providers::mir_builder::program_json_to_mir_json` で MIR(JSON v0) を返す。 + - `handle_codegen("emit_object", args)`: + - `args[0]` の MIR(JSON v0) 文字列を受け取り、ny-llvmc ラッパ (`llvm_codegen::mir_json_to_object`) で object (.o) のパスを返す。 + +- Bridge（JSON v0 → MIR）の特別扱い: + - `src/runner/json_v0_bridge/lowering/expr.rs`: + - `MapVars::resolve`: + - `hostbridge` / `env` を特殊変数として扱い、それぞれ Const(String) `"hostbridge"` / `"env"` を生成する（Method チェーンを降ろすためのプレースホルダ）。 + - `lower_expr_with_scope`: + - `ExprV0::Extern { iface, method, args }` → `MirInstruction::ExternCall { iface_name, method_name, ... }`。 + - `ExprV0::Method` の特別ケース: + - `ConsoleBox` の `print/println/log` → `ExternCall env.console.log`。 + - `env.box_introspect.kind(value)` パターン → `ExternCall env.box_introspect.kind` に正規化。 + +- Selfhost への移植指針（Rust SSOT に沿った箱設計）: + - `MethodCall`: + - Hako 側では「どの Box のどのメソッドを MIR の `mir_call(Method)` に落とすか」を Box 単位の helper で管理する（`LoopOptsBox` や `Cli*Box` と同様に）。 + - Rust 側の `CallTarget::Method` → `Callee::Method` の変換ルール（receiver レジスタの扱い、box_name/method 名）を Step 4 の設計メモと揃える。 + - `ExternCall`: + - `hostbridge.extern_invoke("env.codegen","emit_object"/"link_object", args)` や `env.mirbuilder.emit` などは、 + - Rust では最終的に `ExternCall` → `extern_provider_dispatch("env.*", args)` → `plugin_loader_v2::extern_call("env.*", method, args)` / `host_providers::*` という構造になっている。 + - Hako 側では「env 名＋メソッド名の組（= key）」を列挙した薄い `*BridgeBox` でラップし、そのうえで `ExternCallLowerBox` が `externcall func="env.codegen.emit_object"` を emit する。 + - 未対応の name/method 組は必ず Fail-Fast（タグ付き）で provider に回す。 + +この Step 4.1 を「Rust 側の SSOT」として固定しておき、Phase 25.1c 以降ではこの契約に沿って Hako 側の MethodCall/ExternCall lowering 箱を実装・整理していく（Rust 側に新ルールは追加しない）方針とする。 + - 実装イメージ（Phase 25.1b 中にやるときの TODO）: 1. `FuncLoweringBox` に小さな helper を追加: - `_lower_method_call(body_json, func_name, box_name, params_arr)` → MethodCall パターン検出＋`mir_call Method` 生成。 diff --git a/docs/development/roadmap/phases/phase-25.1c/README.md b/docs/development/roadmap/phases/phase-25.1c/README.md new file mode 100644 index 00000000..50287078 --- /dev/null +++ b/docs/development/roadmap/phases/phase-25.1c/README.md @@ -0,0 +1,48 @@ +# Phase 25.1c — Env / Extern / BoxIntrospect Structural Cleanup + +Status: planning（構造整理フェーズ・挙動は変えない） + +## ゴール + +- `env.*` / `hostbridge.*` / `env.box_introspect.*` の責務と経路を整理し、型システムまわりの「正しい入口」を 1 箇所に揃える。 +- Box 型情報 API（`env.box_introspect.kind` + `BoxTypeInspectorBox`）を **コア型システム**として扱えるようにする（plugins の有無に依存しない）。 +- i64 / MapBox / ArrayBox の unwrap ロジックを SSOT に寄せ、MirBuilder / JsonEmit / LoopOpts / BoxHelpers が同じ前提で動くようにする。 + +## スコープ（何をここで扱うか） + +- 対象: + - Rust 側: `extern_registry.rs` / `handlers/externals.rs` / `handlers/extern_provider.rs` / `runtime/plugin_loader_v2/*` + - Hako 側: `BoxTypeInspectorBox` / `BoxHelpers` / `JsonEmitBox` / `MirSchemaBox` / `LoopOptsBox` + - ドキュメント: `docs/specs`（env externs / box_introspect / numeric view の設計メモ） +- 非対象: + - 新しい言語機能や VM 命令の追加（Phase 25 ポリシーに従い、仕様拡張はしない）。 + - MirBuilder の意味論変更（multi‑carrier や LoopForm の設計は Phase 25.1b の範囲に留める）。 + +## やりたい整理（タスクリスト） + +1. **env.* extern の SSOT を決める** + - `env.get` / `env.mirbuilder.emit` / `env.codegen.emit_object` / `env.codegen.link_object` / `env.box_introspect.kind` を一覧化し、仕様（引数・戻り値・MIR 形）を `docs/specs/env_externs.md`（仮）に明文化する。 + - JSON v0 → MIR ブリッジ（`MapVars::resolve` / lowering）で、上記が必ず `ExternCall("env.*", ..)` に落ちることを確認・修正する。 + +2. **hostbridge.extern_invoke を「互換レイヤ」に押し込める** + - 方針: 「`env.*` で表現できるものは ExternCall を正義とし、`hostbridge.extern_invoke` は互換用ラッパに限定する」。 + - Hako 側: `hostbridge.extern_invoke("env.*", ..)` は内部で `env.*` を呼ぶだけにする（新規コードは直接 `env.*` を使う）。 + - Rust 側: `"hostbridge.extern_invoke"` の実装は、`extern_provider_dispatch("env.*", ..)` に委譲する薄いブリッジに整理する。 + +3. **BoxIntrospect をコア型システムに昇格させる** + - `env.box_introspect.kind` の実装を plugin loader v2 直下ではなく、コア runtime（例: `runtime/box_introspect.rs`）に寄せる。 + - コア型（MapBox / ArrayBox / StringBox / IntegerBox / BoolBox / NullBox）は runtime 側で `build_box_info` を定義し、plugin loader は「ユーザー Box の拡張」だけを担当する。 + - `BoxTypeInspectorBox` は `env.box_introspect.kind(value)` を唯一の情報源として扱い、repr ベースの fallback は「plugins も env.* も使えないデバッグ環境のみ」で使うことをコメントで明示する。 + +4. **Numeric view（i64 unwrap）の SSOT 化** + - Hako 側: `string_helpers` / `BoxHelpers` / `MirSchemaBox` / `JsonEmitBox` / `LoopOptsBox` に散っている i64 unwrap ロジックを、小さなユーティリティ（仮: `box_numeric_view.hako`）に寄せる。 + - Rust 側: `NyashBox` から i64 を取り出す `as_i64` 的な関数を 1 箇所に置き、extern / BoxIntrospect 経路からはそれを使う。 + +## 進め方メモ + +- 先にドキュメントを書く（env extern / BoxIntrospect / numeric view の仕様を `docs/specs` 配下に整理）→ そのあとで Bridge / VM / Hako を小さく揃える。 +- 既存フェーズとの関係: + - Phase 25.1b: selfhost builder / multi‑carrier / BoxTypeInspector 実装フェーズ（機能側）。 + - Phase 25.1c: そのうち「env.* / hostbridge.* / BoxIntrospect の構造と責務」を整理するメタフェーズ（構造側）。 + - 挙動を変えないこと（Fail‑Fast / default path は現状維持）を前提に、小さな差分で進める。 + diff --git a/lang/src/compiler/entry/compiler_stageb.hako b/lang/src/compiler/entry/compiler_stageb.hako index d53da47e..cbfa19f7 100644 --- a/lang/src/compiler/entry/compiler_stageb.hako +++ b/lang/src/compiler/entry/compiler_stageb.hako @@ -535,14 +535,19 @@ static box Main { local ast_json = p.parse_program2(body_src) // 6.5) Dev-toggle: scan for function definitions (static box { method (...) {...} }) - // Toggle: HAKO_STAGEB_FUNC_SCAN=1 - // Policy: conservative minimal scanner for Phase 21.6 call canary (no nesting, basic only) + // Toggle: HAKO_STAGEB_FUNC_SCAN + // Policy: + // - 未設定(null) のときは既定で ON（defs を常に埋める）。 + // - 明示的に "0" が入っているときだけ OFF。 // Scope: method (params) { ... } outside of main (same box Main) // Output: inject "defs":[{"name":"","params":[...],"body":[...], "box":"Main"}] to Program JSON local defs_json = "" { - local func_scan = env.get("HAKO_STAGEB_FUNC_SCAN") - if func_scan != null && ("" + func_scan) == "1" { + local func_scan_env = env.get("HAKO_STAGEB_FUNC_SCAN") + local func_scan_on = 1 + // 明示的に "0" のときだけ OFF 扱い。それ以外（null/1/true/on）は ON。 + if func_scan_env != null && ("" + func_scan_env) == "0" { func_scan_on = 0 } + if func_scan_on == 1 { // Use FuncScannerBox to extract method definitions from all boxes local methods = FuncScannerBox.scan_all_boxes(src) diff --git a/lang/src/compiler/parser/parser_box.hako b/lang/src/compiler/parser/parser_box.hako index cdafe1f7..9cd1f64b 100644 --- a/lang/src/compiler/parser/parser_box.hako +++ b/lang/src/compiler/parser/parser_box.hako @@ -37,6 +37,14 @@ box ParserBox { return 0 } + // Dev-only: enable coarse-grained parser trace when NYASH_PARSER_TRACE=1. + trace_enabled() { + local v = env.get("NYASH_PARSER_TRACE") + if v == null { return 0 } + if ("" + v) == "1" { return 1 } + return 0 + } + // === State management === gpos_set(i) { me.gpos = i return 0 } gpos_get() { return me.gpos } @@ -227,9 +235,14 @@ box ParserBox { // === Top-level program parser === parse_program2(src) { + local trace = me.trace_enabled() + // Inline skip_ws to avoid VM bug: method-with-loop called from within loop local i = 0 local n = src.length() + if trace == 1 { + print("[parser/trace:program2] start len=" + ("" + n) + " stage3=" + ("" + me.stage3)) + } if i < n { local ws_cont_init = 1 loop(ws_cont_init == 1) { @@ -246,6 +259,21 @@ box ParserBox { local cont_prog = 1 loop(cont_prog == 1) { + if trace == 1 { + local kind = "Stmt" + if i >= n { + kind = "EOF" + } else { + if me.starts_with(src, i, "static box") == 1 { kind = "StaticBox" } + else { + if me.starts_with(src, i, "box ") == 1 { kind = "BoxDecl" } + else { + if me.starts_with(src, i, "method ") == 1 { kind = "Method" } + } + } + } + print("[parser/trace:program2] pos=" + ("" + i) + " kind=" + kind + " stage3=" + ("" + me.stage3)) + } // Inline skip_ws instead of calling me.skip_ws(src, i) if i < n { local ws_cont_1 = 1 @@ -267,6 +295,9 @@ box ParserBox { // Progress guard if i <= start_i { + if trace == 1 { + print("[parser/trace:program2] progress-guard bump i from " + ("" + start_i) + " to " + ("" + (start_i + 1))) + } if i < src.length() { i = i + 1 } else { i = src.length() } me.gpos_set(i) @@ -305,9 +336,15 @@ box ParserBox { if s.length() > 0 { if first == 1 { + if trace == 1 { + print("[parser/trace:program2] emit-first stmt_len=" + ("" + s.length())) + } body = body + s first = 0 } else { + if trace == 1 { + print("[parser/trace:program2] emit stmt_len=" + ("" + s.length())) + } body = body + "," + s } } @@ -315,6 +352,9 @@ box ParserBox { } body = body + "]" + if trace == 1 { + print("[parser/trace:program2] done pos=" + ("" + i) + " len=" + ("" + n)) + } return "{\"version\":0,\"kind\":\"Program\",\"body\":" + body + "}" } } diff --git a/lang/src/compiler/pipeline_v2/map_helpers_box.hako b/lang/src/compiler/pipeline_v2/map_helpers_box.hako index 6ddc6fe9..63784012 100644 --- a/lang/src/compiler/pipeline_v2/map_helpers_box.hako +++ b/lang/src/compiler/pipeline_v2/map_helpers_box.hako @@ -12,7 +12,7 @@ static box MapHelpersBox { get_str(m, key) { local v = me._raw_get(m, key) if v == null { return "" } - if BoxHelpers.is_map(v) == 1 { + if BoxHelpers.is_map(v) { local inner = BoxHelpers.map_get(v, "value") if inner != null { return "" + inner } } diff --git a/lang/src/compiler/pipeline_v2/normalizer_box.hako b/lang/src/compiler/pipeline_v2/normalizer_box.hako index ecd12cd4..ec467d94 100644 --- a/lang/src/compiler/pipeline_v2/normalizer_box.hako +++ b/lang/src/compiler/pipeline_v2/normalizer_box.hako @@ -7,7 +7,7 @@ static box NormalizerBox { normalize_cmp(raw) { if raw == null { return null } // TEMP debug - if BoxHelpers.is_map(raw) == 1 && BoxHelpers.map_get(raw, "cmp") != null { print("DBG:N.cmp_in=1") } else { print("DBG:N.cmp_in=0") } + if BoxHelpers.is_map(raw) && BoxHelpers.map_get(raw, "cmp") != null { print("DBG:N.cmp_in=1") } else { print("DBG:N.cmp_in=0") } local out = new MapBox() // cmp local cmp = "" + BoxHelpers.map_get(raw, "cmp") diff --git a/lang/src/llvm_ir/emit/LLVMEmitBox.hako b/lang/src/llvm_ir/emit/LLVMEmitBox.hako index cdd4c04a..6bcb51dc 100644 --- a/lang/src/llvm_ir/emit/LLVMEmitBox.hako +++ b/lang/src/llvm_ir/emit/LLVMEmitBox.hako @@ -11,6 +11,8 @@ // - Provider examples: ny-llvmc wrapper or llvmlite harness via a Plugin box `LLVMCodegenBox.emit_object/2`. // - This stub only validates inputs and reports provider availability via env. +using selfhost.shared.host_bridge.codegen_bridge as CodegenBridgeBox + static box LLVMEmitProviderBox { // Availability probe (for canaries) is_available() { @@ -39,11 +41,10 @@ static box LLVMEmitProviderBox { } local pv = "" + p if pv == "ny-llvmc" { - local args = new ArrayBox(); args.push(mir_json) // env.codegen.emit_object(mir_json) - local ret = hostbridge.extern_invoke("env.codegen", "emit_object", args) + local ret = CodegenBridgeBox.emit_object(mir_json) return ret - } + } if pv == "llvmlite" { // Not wired yet for llvmlite provider print("[llvmemit/skip] provider stub; implement llvmlite Plugin v2 call") diff --git a/lang/src/mir/builder/MirBuilderBox.hako b/lang/src/mir/builder/MirBuilderBox.hako index 946fb0cb..4e5b5141 100644 --- a/lang/src/mir/builder/MirBuilderBox.hako +++ b/lang/src/mir/builder/MirBuilderBox.hako @@ -11,6 +11,7 @@ // - HAKO_MIR_BUILDER_DELEGATE=1 — delegate to Runner (--program-json-to-mir) // - HAKO_MIR_BUILDER_INTERNAL=0/1 — internal lowers gate（既定=1） // - HAKO_MIR_BUILDER_REGISTRY=0/1 — pattern registry gate（既定=1） +// - HAKO_SELFHOST_NO_DELEGATE=1 — selfhost-first internal 専用プロファイル（delegate を完全に無効化） // // Phase 22.0: Hako‑first（registry）を既定ONにする。必要なら 0 を明示して無効化する。 @@ -432,6 +433,17 @@ static box MirBuilderBox { return null } } + // Selfhost-first profile: when explicitly disabled, do not delegate even if + // HAKO_MIR_BUILDER_DELEGATE=1 が立っていても env.mirbuilder.emit には逃げない。 + { + local no_delegate = env.get("HAKO_SELFHOST_NO_DELEGATE") + if no_delegate != null && ("" + no_delegate) == "1" { + if env.get("HAKO_SELFHOST_TRACE") == "1" { + print("[mirbuilder/delegate/disabled] HAKO_SELFHOST_NO_DELEGATE=1; internal-only mode") + } + return null + } + } // Delegate-first policy (Phase 20.34 Milestone A) local d = env.get("HAKO_MIR_BUILDER_DELEGATE") if d != null && ("" + d) == "1" { diff --git a/lang/src/mir/builder/README.md b/lang/src/mir/builder/README.md index ba262806..3d2ace96 100644 --- a/lang/src/mir/builder/README.md +++ b/lang/src/mir/builder/README.md @@ -23,6 +23,7 @@ Toggles - `HAKO_MIR_BUILDER_INTERNAL=0/1` — internal lowers gate（既定=1） - `HAKO_MIR_BUILDER_REGISTRY=0/1` — pattern registry gate（既定=1） - `HAKO_MIR_BUILDER_DELEGATE=1` — use Runner/extern provider (`env.mirbuilder.emit`) 経由で Program→MIR +- `HAKO_SELFHOST_NO_DELEGATE=1` — selfhost-first 時に delegate 経路を完全無効化し、internal lowers のみで成否を判定する - `HAKO_MIR_BUILDER_FUNCS=1` — enable defs lowering via `FuncLoweringBox.lower_func_defs` - `HAKO_MIR_BUILDER_METHODIZE=1` — enable call→mir_call(Method) rewrite after MIR 生成 - `HAKO_MIR_BUILDER_JSONFRAG_NORMALIZE=1` — apply JsonFrag normalizer to selfhost/provider output diff --git a/lang/src/mir/builder/func_body/basic_lower_box.hako b/lang/src/mir/builder/func_body/basic_lower_box.hako index 4690c8aa..90fde3f8 100644 --- a/lang/src/mir/builder/func_body/basic_lower_box.hako +++ b/lang/src/mir/builder/func_body/basic_lower_box.hako @@ -94,7 +94,17 @@ static box FuncBodyBasicLowerBox { method _build_func_name(box_name, func_name, params_arr) { if box_name == null || func_name == null { return null } local arity = 0 - if params_arr != null { arity = JsonFragBox._str_to_int("" + params_arr.length()) } + if params_arr != null { + local n = JsonFragBox._str_to_int("" + params_arr.length()) + // Stage‑B defs for static box methods include implicit "me" 先頭引数。 + // MIR 側の関数名は「ユーザー引数の個数」で表現したいので、先頭が "me" の場合は引数数から 1 を引く。 + if n > 0 && ("" + params_arr.get(0)) == "me" { + arity = n - 1 + } else { + arity = n + } + if arity < 0 { arity = 0 } + } local suffix = "/" + arity return ("" + box_name) + "." + ("" + func_name) + suffix } @@ -509,10 +519,10 @@ static box FuncBodyBasicLowerBox { local result_reg = next_reg next_reg = next_reg + 1 - // Box type 判定（現段階では ArrayBox.size/get と StringBox.length のみ） + // Box type 判定（現段階では ArrayBox.size/get/push と StringBox.length のみ） local box_type = null local kind = "" - if mname == "size" || mname == "get" { + if mname == "size" || mname == "get" || mname == "push" { box_type = "ArrayBox" kind = "array" } else if mname == "length" { @@ -549,7 +559,7 @@ static box FuncBodyBasicLowerBox { if out != null { return me._rebind(out, func_name, box_name, params_arr, "[funcs/basic:loop.sum_bc]") } } // 3) 次に multi_carrier 用 lower を試す（fibonacci風） - { local out_mc = LowerLoopMultiCarrierBox.try_lower(body_json) + { local out_mc = LowerLoopMultiCarrierBox.try_lower(body_json, params_arr) if out_mc != null { return me._rebind(out_mc, func_name, box_name, params_arr, "[funcs/basic:loop.multi_carrier]") } } // 4) 最後に simple loop 用 lower を試す（単純カウンタ） diff --git a/lang/src/mir/builder/func_body/cli_run_lower_box.hako b/lang/src/mir/builder/func_body/cli_run_lower_box.hako index fb4ee02a..deccec0c 100644 --- a/lang/src/mir/builder/func_body/cli_run_lower_box.hako +++ b/lang/src/mir/builder/func_body/cli_run_lower_box.hako @@ -31,6 +31,14 @@ static box CliRunLowerBox { return null } + // Shape が既知パターンと一致した時点で、入口検出タグと粗い形状タグを出しておく。 + if env.get("HAKO_SELFHOST_TRACE") == "1" { + // Stage1 CLI entry: Main.main → HakoCli.run/2（argv 引数付き） + print("[builder/cli:entry_detected] main=Main.main run=" + box_name + "." + func_name + "/2") + // run/build/emit/check の 4 分岐を想定した形状タグ（将来は CliRunShapeScannerBox からの情報に揃える）。 + print("[builder/cli:run_shape] has_run=1 branches=4") + } + // 既定では MIR 生成はトグルで有効化（freeze ポリシーに従い既定OFF）。 local flag = env.get("HAKO_MIR_BUILDER_CLI_RUN") if flag == null { flag = "0" } diff --git a/lang/src/mir/builder/func_body/extern_call_box.hako b/lang/src/mir/builder/func_body/extern_call_box.hako index 021dd79d..a2e65e89 100644 --- a/lang/src/mir/builder/func_body/extern_call_box.hako +++ b/lang/src/mir/builder/func_body/extern_call_box.hako @@ -120,7 +120,17 @@ static box ExternCallLowerBox { method _build_func_name(box_name, func_name, params_arr) { if box_name == null || func_name == null { return null } local arity = 0 - if params_arr != null { arity = JsonFragBox._str_to_int("" + params_arr.length()) } + if params_arr != null { + local n = JsonFragBox._str_to_int("" + params_arr.length()) + // HakoCli.* など static box メソッドの defs では先頭に暗黙の "me" が入る。 + // 関数名はユーザー引数の個数で表現したいので、先頭が "me" の場合は 1 引いておく。 + if n > 0 && ("" + params_arr.get(0)) == "me" { + arity = n - 1 + } else { + arity = n + } + if arity < 0 { arity = 0 } + } return ("" + box_name) + "." + ("" + func_name) + "/" + arity } @@ -138,4 +148,3 @@ static box ExternCallLowerBox { return params_json } } - diff --git a/lang/src/mir/builder/internal/loop_opts_adapter_box.hako b/lang/src/mir/builder/internal/loop_opts_adapter_box.hako index 7909b5e1..324aa854 100644 --- a/lang/src/mir/builder/internal/loop_opts_adapter_box.hako +++ b/lang/src/mir/builder/internal/loop_opts_adapter_box.hako @@ -3,6 +3,9 @@ // construction without touching all callers. using "hako.mir.builder.internal.builder_config" as BuilderConfigBox +using selfhost.shared.common.string_helpers as StringHelpers +using selfhost.shared.common.box_helpers as BoxHelpers +using selfhost.shared.mir.json_emit as JsonEmitBox static box LoopOptsBox { new_map() { @@ -15,7 +18,6 @@ static box LoopOptsBox { // build2: envでJsonFrag直組立を選択（既定は LoopFormBox.build2 に委譲） build2(opts) { using selfhost.shared.mir.loopform as LoopFormBox - using selfhost.shared.common.string_helpers as StringHelpers using "hako.mir.builder.internal.jsonfrag_normalizer" as JsonFragNormalizerBox // Force toggle: always return JsonFrag (dev/test override) if BuilderConfigBox.loop_force_jsonfrag_on() == 1 { @@ -80,7 +82,219 @@ static box LoopOptsBox { } return mir } - // Default: delegate - return LoopFormBox.build2(opts) + // Default: delegate to LoopForm and emit canonical JSON via shared JsonEmitBox + local module = LoopFormBox.build2(opts) + if module == null { return null } + local json = JsonEmitBox.to_json(module) + if BuilderConfigBox.jsonfrag_normalize_on() == 1 { json = JsonFragNormalizerBox.normalize_all(json) } + local mode2 = BuilderConfigBox.loop_adapter_return_mode() + if mode2 == "map" { + local m2 = me.new_map() + m2 = me.put(m2, "mir", json) + return m2 + } + return json + } + + method _module_to_json(module) { + if module == null { return "{}" } + local kind = module.get("kind") + if kind == null { kind = "MIR" } + local schema = module.get("schema_version") + if schema == null { schema = "1.0" } + local funcs = module.get("functions") + local body = me._emit_functions(funcs) + return "{\"kind\":" + me._quote(kind) + ",\"schema_version\":" + me._quote(schema) + ",\"functions\":[" + body + "]}" + } + + method _emit_functions(funcs) { + if funcs == null { return "" } + local len = me._array_len(funcs) + local out = "" + local i = 0 + loop(i < len) { + local func = funcs.get(i) + if func != null { + if out != "" { out = out + "," } + out = out + me._emit_function(func) + } + i = i + 1 + } + return out + } + + method _emit_function(func) { + if func == null { return "{\"name\":\"main\",\"blocks\":[]}" } + local name = func.get("name") + if name == null { name = "main" } + local params = func.get("params") + local blocks = func.get("blocks") + local out = "{\"name\":" + me._quote(name) + if params != null && BoxHelpers.is_array(params) { + out = out + ",\"params\":" + me._emit_params(params) + } + if blocks != null { + out = out + ",\"blocks\":[" + me._emit_blocks(blocks) + "]" + } else { + out = out + ",\"blocks\":[]" + } + out = out + "}" + return out + } + + method _emit_params(arr) { + if arr == null { return "[]" } + local len = me._array_len(arr) + local out = "" + local i = 0 + loop(i < len) { + if out != "" { out = out + "," } + out = out + me._quote(arr.get(i)) + i = i + 1 + } + return "[" + out + "]" + } + + method _emit_blocks(blocks) { + local len = me._array_len(blocks) + local out = "" + local i = 0 + loop(i < len) { + local block = blocks.get(i) + if block != null { + if out != "" { out = out + "," } + out = out + me._emit_block(block) + } + i = i + 1 + } + return out + } + + method _emit_block(block) { + local id = block.get("id") + local insts = block.get("instructions") + local body = me._emit_insts(insts) + return "{\"id\":" + me._i64(id) + ",\"instructions\":[" + body + "]}" + } + + method _emit_insts(insts) { + if insts == null { return "" } + local len = me._array_len(insts) + local out = "" + local i = 0 + loop(i < len) { + local inst = insts.get(i) + if inst != null { + if out != "" { out = out + "," } + out = out + me._emit_inst(inst) + } + i = i + 1 + } + return out + } + + method _emit_inst(inst) { + local op = "" + inst.get("op") + if op == "const" { + return "{\"op\":\"const\",\"dst\":" + me._i64(inst.get("dst")) + ",\"value\":" + me._emit_box_value(inst.get("value")) + "}" + } + if op == "ret" { + return "{\"op\":\"ret\",\"value\":" + me._i64(inst.get("value")) + "}" + } + if op == "jump" { + return "{\"op\":\"jump\",\"target\":" + me._i64(inst.get("target")) + "}" + } + if op == "compare" { + local cmp = inst.get("cmp") + if cmp == null { cmp = inst.get("operation") } + return "{\"op\":\"compare\",\"operation\":" + me._quote(cmp) + ",\"lhs\":" + me._i64(inst.get("lhs")) + ",\"rhs\":" + me._i64(inst.get("rhs")) + ",\"dst\":" + me._i64(inst.get("dst")) + "}" + } + if op == "branch" { + return "{\"op\":\"branch\",\"cond\":" + me._i64(inst.get("cond")) + ",\"then\":" + me._i64(inst.get("then")) + ",\"else\":" + me._i64(inst.get("else")) + "}" + } + if op == "phi" { + return "{\"op\":\"phi\",\"dst\":" + me._i64(inst.get("dst")) + ",\"incoming\":" + me._emit_phi(inst.get("incoming")) + "}" + } + if op == "binop" { + local kind = inst.get("op_kind") + if kind == null { kind = inst.get("operation") } + return "{\"op\":\"binop\",\"operation\":" + me._quote(kind) + ",\"lhs\":" + me._i64(inst.get("lhs")) + ",\"rhs\":" + me._i64(inst.get("rhs")) + ",\"dst\":" + me._i64(inst.get("dst")) + "}" + } + if op == "mir_call" { + local payload = inst.get("mir_call") + local callee = payload.get("callee") + local callee_json = "{\"type\":\"Method\",\"box_name\":" + me._quote(callee.get("box_name")) + ",\"method\":" + me._quote(callee.get("method")) + ",\"receiver\":" + me._i64(callee.get("receiver")) + "}" + local args_json = me._emit_args(payload.get("args")) + return "{\"op\":\"mir_call\",\"dst\":" + me._i64(inst.get("dst")) + ",\"mir_call\":{\"callee\":" + callee_json + ",\"args\":" + args_json + ",\"effects\":[]}}" + } + if op == "copy" { + return "{\"op\":\"copy\",\"src\":" + me._i64(inst.get("src")) + ",\"dst\":" + me._i64(inst.get("dst")) + "}" + } + return "{\"op\":" + me._quote(op) + "}" + } + + method _emit_phi(values) { + if values == null { return "[]" } + local len = me._array_len(values) + local out = "" + local i = 0 + loop(i < len) { + local item = values.get(i) + if item != null { + if out != "" { out = out + "," } + out = out + "{\"block\":" + me._i64(item.get("block")) + ",\"value\":" + me._i64(item.get("value")) + "}" + } + i = i + 1 + } + return "[" + out + "]" + } + + method _emit_args(args) { + if args == null { return "[]" } + local len = me._array_len(args) + local out = "" + local i = 0 + loop(i < len) { + if out != "" { out = out + "," } + out = out + me._i64(args.get(i)) + i = i + 1 + } + return "[" + out + "]" + } + + method _emit_box_value(val) { + if val == null { return "{\"type\":\"i64\",\"value\":0}" } + local ty = "i64" + if BoxHelpers.is_map(val) { + local ty_box = BoxHelpers.map_get(val, "type") + if ty_box != null { ty = "" + ty_box } + local inner = BoxHelpers.value_i64(val) + return "{\"type\":" + me._quote(ty) + ",\"value\":" + me._i64(inner) + "}" + } + // Non-MapBox: treat as plain numeric value + local inner2 = BoxHelpers.value_i64(val) + return "{\"type\":" + me._quote(ty) + ",\"value\":" + me._i64(inner2) + "}" + } + + method _array_len(arr) { + // Delegate to shared helper to support both builtin ArrayBox.length (IntegerBox) + // and MapBox-wrapped length from plugins. + return BoxHelpers.array_len(arr) + } + + method _i64(val) { + if val == null { return "0" } + // Prefer MapBox-wrapped integers when available, otherwise fall back to direct value. + if BoxHelpers.is_map(val) { + local inner = BoxHelpers.map_get(val, "value") + if inner != null { return "" + inner } + return "0" + } + return "" + val + } + + method _quote(val) { + if val == null { return "\"\"" } + return StringHelpers.json_quote("" + val) } } diff --git a/lang/src/mir/builder/internal/loop_scan_box.hako b/lang/src/mir/builder/internal/loop_scan_box.hako index 5c9e1d9a..f8f46b52 100644 --- a/lang/src/mir/builder/internal/loop_scan_box.hako +++ b/lang/src/mir/builder/internal/loop_scan_box.hako @@ -10,11 +10,11 @@ static box LoopScanBox { local kr = JsonFragBox.index_of_from(s, "\"rhs\":{", k_cmp) if kl >= 0 && JsonFragBox.index_of_from(s, "\"type\":\"Var\"", kl) >= 0 { local kn = JsonFragBox.index_of_from(s, "\"name\":\"", kl) - if kn >= 0 { varname = JsonFragBox.read_string_after(s, kn) } + if kn >= 0 { varname = JsonFragBox.read_string_after(s, kn + 7) } } if varname == null && kr >= 0 && JsonFragBox.index_of_from(s, "\"type\":\"Var\"", kr) >= 0 { local kn2 = JsonFragBox.index_of_from(s, "\"name\":\"", kr) - if kn2 >= 0 { varname = JsonFragBox.read_string_after(s, kn2) } + if kn2 >= 0 { varname = JsonFragBox.read_string_after(s, kn2 + 7) } } return varname } diff --git a/lang/src/mir/builder/internal/lower_loop_multi_carrier_box.hako b/lang/src/mir/builder/internal/lower_loop_multi_carrier_box.hako index 26ee3c1d..23c72efd 100644 --- a/lang/src/mir/builder/internal/lower_loop_multi_carrier_box.hako +++ b/lang/src/mir/builder/internal/lower_loop_multi_carrier_box.hako @@ -16,7 +16,7 @@ using "hako.mir.builder.internal.builder_config" as BuilderConfigBox static box LowerLoopMultiCarrierBox { // Try to recognize and lower a multi-carrier loop in Program(JSON v0). // Pattern: loop with multiple Local/Assign indicating carried state (fibonacci-style) - method try_lower(program_json) { + method try_lower(program_json, params_arr) { if program_json == null { return null } local s = "" + program_json @@ -31,69 +31,183 @@ static box LowerLoopMultiCarrierBox { local varname = LoopScanBox.find_loop_var_name(s, k_cmp) if varname == null { return null } - // 3) Extract limit from Compare (i < limit pattern) - local k_op = JsonFragBox.index_of_from(s, "\"op\":", k_cmp) - if k_op < 0 { return null } - local op = JsonFragBox.read_string_after(s, k_op + 5) - if op == null { return null } - - // Check for lhs Var pattern (i on left side) - local has_lhs_i = JsonFragBox.index_of_from(s, "\"lhs\":{\"type\":\"Var\",\"name\":\"" + varname + "\"}", k_cmp) >= 0 - if !has_lhs_i { return null } - - // Extract limit from rhs Int - local k_rhs = JsonFragBox.index_of_from(s, "\"rhs\":{", k_cmp) - if k_rhs < 0 { return null } - local k_ti = JsonFragBox.index_of_from(s, "\"type\":\"Int\"", k_rhs) - if k_ti < 0 { return null } - local k_v = JsonFragBox.index_of_from(s, "\"value\":", k_ti) - if k_v < 0 { return null } - local limit = JsonFragBox.read_int_after(s, k_v + 8) - if limit == null { return null } - - // 4) Check for multiple Local/Assign in Loop body (multi-carrier indicator) - local k_body = JsonFragBox.index_of_from(s, "\"body\":[", k_loop) - if k_body < 0 { return null } - - // Count Local declarations within this Loop's body - local local_count = 0 - local search_pos = k_body - loop(local_count < 5) { - local k_local = JsonFragBox.index_of_from(s, "\"type\":\"Local\"", search_pos) - if k_local < 0 { break } - // Ensure it's within the current Loop body (not a nested Loop) - local next_loop = JsonFragBox.index_of_from(s, "\"type\":\"Loop\"", k_local) - if next_loop >= 0 && next_loop < k_local + 200 { break } - local_count = local_count + 1 - search_pos = k_local + 1 - } - - // Multi-carrier requires at least 2 additional variables (besides loop var) - // e.g. fibonacci: a, b (+ implicit i) - if local_count < 2 { + // 3) Extract limit information (accept Int literal or param Var) + local limit_info = me._extract_limit_info(s, k_cmp, varname, params_arr) + if limit_info == null { if BuilderConfigBox.trace_enabled() == 1 { - print("[mirbuilder/internal/loop:multi_carrier:insufficient_carriers:count=" + local_count + "]") + print("[mirbuilder/internal/loop:multi_carrier:limit:unsupported]") } return null } + local limit_kind = "" + limit_info.get("kind") + local limit_value = limit_info.get("value") + local limit_param_reg = JsonFragBox._str_to_int("" + limit_info.get("param_reg")) + if limit_kind != "const" && limit_kind != "param" { return null } - // 5) Build opts for multi_count mode + // 4) Collect initial carrier values (Local Int assignments before the Loop) + local carrier_vals = me._collect_carrier_initials(s, k_loop, varname) + if carrier_vals == null || carrier_vals.length() < 2 { + local count = 0 + if carrier_vals != null { count = carrier_vals.length() } + print("[mirbuilder/internal/loop:multi_carrier:insufficient_carriers:count=" + count + "]") + return null + } + + // 5) Build opts for multi_count mode with detected carriers local opts = LoopOptsBox.new_map() opts = LoopOptsBox.put(opts, "mode", "multi_count") - opts = LoopOptsBox.put(opts, "limit", limit) - - // Carriers: default to [0, 1] for fibonacci pattern - // TODO: extract initial values from JSON (future enhancement) - local carriers = new ArrayBox() - carriers.push(0) - carriers.push(1) - opts = LoopOptsBox.put(opts, "carriers", carriers) - - if BuilderConfigBox.trace_enabled() == 1 { - print("[mirbuilder/internal/loop:multi_carrier:detected:limit=" + limit + ",carriers=2]") + opts = LoopOptsBox.put(opts, "limit_kind", limit_kind) + if limit_kind == "const" { + opts = LoopOptsBox.put(opts, "limit", limit_value) + } else { + opts = LoopOptsBox.put(opts, "limit_param_reg", limit_param_reg) } + opts = LoopOptsBox.put(opts, "carriers", carrier_vals) + + local tag = "[mirbuilder/internal/loop:multi_carrier:detected:limit_kind=" + limit_kind + if limit_kind == "const" { + tag = tag + ",value=" + limit_value + } else { + tag = tag + ",param_reg=" + limit_param_reg + } + tag = tag + ",carriers=" + carrier_vals.length() + "]" + print(tag) // 6) Delegate to LoopFormBox.build2 via LoopOptsBox return LoopOptsBox.build2(opts) } + + // Extract initial carrier values (Local Int assignments before Loop body) + method _collect_carrier_initials(body_json, loop_idx, loop_var) { + local vals = new ArrayBox() + if body_json == null { return vals } + local search = 0 + loop(true) { + local k_local = JsonFragBox.index_of_from(body_json, "\"type\":\"Local\"", search) + if k_local < 0 || (loop_idx >= 0 && k_local >= loop_idx) { break } + local name_idx = JsonFragBox.index_of_from(body_json, "\"name\":", k_local) + if name_idx < 0 { break } + local name = JsonFragBox.read_string_after(body_json, name_idx + 7) + if name == null { break } + if loop_var != null && name == loop_var { + search = k_local + 1 + continue + } + local expr_idx = JsonFragBox.index_of_from(body_json, "\"expr\":{", k_local) + if expr_idx < 0 || (loop_idx >= 0 && expr_idx >= loop_idx) { + search = k_local + 1 + continue + } + local int_idx = JsonFragBox.index_of_from(body_json, "\"type\":\"Int\"", expr_idx) + if int_idx < 0 || (loop_idx >= 0 && int_idx >= loop_idx) { + search = k_local + 1 + continue + } + local val_idx = JsonFragBox.index_of_from(body_json, "\"value\":", int_idx) + if val_idx < 0 { search = k_local + 1 continue } + local val = JsonFragBox.read_int_after(body_json, val_idx + 8) + if val != null { + vals.push(JsonFragBox._str_to_int("" + val)) + } + search = k_local + 1 + } + return vals + } + + method _extract_limit_info(body_json, cmp_idx, loop_var, params_arr) { + local s = "" + body_json + local has_lhs = JsonFragBox.index_of_from(s, "\"lhs\":{\"type\":\"Var\",\"name\":\"" + loop_var + "\"}", cmp_idx) >= 0 + local has_rhs = JsonFragBox.index_of_from(s, "\"rhs\":{\"type\":\"Var\",\"name\":\"" + loop_var + "\"}", cmp_idx) >= 0 + local trace_on = BuilderConfigBox.trace_enabled() + if !has_lhs && !has_rhs { + if trace_on == 1 { + print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=no-loop-var var=" + loop_var) + } + return null + } + local target_idx = -1 + if has_lhs { + target_idx = JsonFragBox.index_of_from(s, "\"rhs\":{", cmp_idx) + } else { + target_idx = JsonFragBox.index_of_from(s, "\"lhs\":{", cmp_idx) + } + if target_idx < 0 { + if trace_on == 1 { + print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=no-target") + } + return null + } + local type_idx = JsonFragBox.index_of_from(s, "\"type\":\"", target_idx) + if type_idx < 0 { + if trace_on == 1 { + print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=no-type") + } + return null + } + local typ = JsonFragBox.read_string_after(s, type_idx + 7) + if typ == null { + if trace_on == 1 { print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=type-null") } + return null + } + if typ == "Int" { + local val_idx = JsonFragBox.index_of_from(s, "\"value\":", type_idx) + if val_idx < 0 { + if trace_on == 1 { print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=no-int-value") } + return null + } + local val = JsonFragBox.read_int_after(s, val_idx + 8) + if val == null { + if trace_on == 1 { print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=int-parse") } + return null + } + local info = new MapBox() + info.set("kind", "const") + info.set("value", JsonFragBox._str_to_int("" + val)) + return info + } + if typ == "Var" { + local name_idx = JsonFragBox.index_of_from(s, "\"name\":\"", type_idx) + if name_idx < 0 { + if trace_on == 1 { print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=no-var-name") } + return null + } + local name = JsonFragBox.read_string_after(s, name_idx + 7) + if name == null { + if trace_on == 1 { print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=var-name-null") } + return null + } + local param_reg = me._resolve_param_reg(params_arr, name) + if trace_on == 1 { + print("[mirbuilder/internal/loop:multi_carrier:limit:param] name=" + name + ",reg=" + param_reg) + } + if param_reg <= 0 { + if trace_on == 1 { + print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=param-unresolved") + } + return null + } + local info2 = new MapBox() + info2.set("kind", "param") + info2.set("param_reg", param_reg) + return info2 + } + if trace_on == 1 { + print("[mirbuilder/internal/loop:multi_carrier:limit:scan:fail] reason=type-unsupported typ=" + typ) + } + return null + } + + method _resolve_param_reg(params_arr, name) { + if params_arr == null || name == null { return 0 } + local idx = 0 + local total = params_arr.length() + loop(idx < total) { + local pname = "" + params_arr.get(idx) + if pname == name { + return JsonFragBox._str_to_int("" + (idx + 1)) + } + idx = idx + 1 + } + return 0 + } } diff --git a/lang/src/runner/launcher.hako b/lang/src/runner/launcher.hako index ea55a1c3..6590858f 100644 --- a/lang/src/runner/launcher.hako +++ b/lang/src/runner/launcher.hako @@ -13,6 +13,7 @@ using lang.mir.builder.MirBuilderBox using lang.compiler.build.build_box as BuildBox +using selfhost.shared.host_bridge.codegen_bridge as CodegenBridgeBox static box HakoCli { // Entry from Main.main(args) @@ -138,21 +139,14 @@ static box HakoCli { } local ms = "" + mir - local emit_args = new ArrayBox() - emit_args.push(ms) - local obj = hostbridge.extern_invoke("env.codegen", "emit_object", emit_args) + local obj = CodegenBridgeBox.emit_object(ms) if obj == null || ("" + obj) == "" { print("[hakorune] build exe: env.codegen.emit_object failed") return 91 } local obj_path = "" + obj - local link_args = new ArrayBox() - link_args.push(obj_path) - if out_path != null && out_path != "" { - link_args.push(out_path) - } - local exe = hostbridge.extern_invoke("env.codegen", "link_object", link_args) + local exe = CodegenBridgeBox.link_object(obj_path, out_path) if exe == null || ("" + exe) == "" { print("[hakorune] build exe: env.codegen.link_object failed") return 91 diff --git a/lang/src/shared/common/box_helpers.hako b/lang/src/shared/common/box_helpers.hako index 5f629f5b..57d8353b 100644 --- a/lang/src/shared/common/box_helpers.hako +++ b/lang/src/shared/common/box_helpers.hako @@ -3,14 +3,14 @@ // 削減: 7ファイル × 2パターン = 14重複 → 1箇所に集約 using selfhost.shared.common.string_helpers as StringHelpers +using selfhost.shared.common.box_type_inspector as BoxTypeInspectorBox static box BoxHelpers { // ArrayBox.size/1 の結果unwrap (MapBox-wrapped integer対応) array_len(arr) { if arr == null { return 0 } local size_val = arr.length() - local repr = "" + size_val - if repr.indexOf("MapBox(") == 0 { + if BoxTypeInspectorBox.is_map(size_val) { local inner = size_val.get("value") if inner != null { return inner } } @@ -39,8 +39,7 @@ static box BoxHelpers { // MapBox-wrapped integer の unwrap (汎用版) value_i64(val) { if val == null { return 0 } - local repr = "" + val - if repr.indexOf("MapBox(") == 0 { + if BoxTypeInspectorBox.is_map(val) { local inner = val.get("value") if inner != null { return inner } } @@ -49,71 +48,56 @@ static box BoxHelpers { // MapBox型判定 is_map(val) { - if val == null { return 0 } - local repr = "" + val - if repr.indexOf("MapBox(") == 0 { return 1 } - return 0 + return BoxTypeInspectorBox.is_map(val) } // ArrayBox型判定 is_array(val) { - if val == null { return 0 } - local repr = "" + val - if repr.indexOf("ArrayBox(") == 0 { return 1 } - return 0 + return BoxTypeInspectorBox.is_array(val) } // Fail-fast helpers (Phase 31.3+) expect_map(val, context) { if val == null { print("[BoxHelpers] expected MapBox for " + context + " but got null") - val.get("__box_helpers_expect_map_null") return val } - if me.is_map(val) == 1 { return val } + if BoxHelpers.is_map(val) { return val } print("[BoxHelpers] dev assert failed: expected MapBox for " + context) - val.get("__box_helpers_expect_map") return val } expect_array(val, context) { if val == null { print("[BoxHelpers] expected ArrayBox for " + context + " but got null") - val.get(0) return val } - if me.is_array(val) == 1 { return val } + if BoxHelpers.is_array(val) { return val } print("[BoxHelpers] dev assert failed: expected ArrayBox for " + context) - val.get(0) return val } expect_i64(val, context) { if val == null { print("[BoxHelpers] dev assert failed: expected i64 (non-null) for " + context) - val.get("__box_helpers_expect_i64_null") return 0 } - local repr = "" + val - if repr.indexOf("MapBox(") == 0 { + if BoxTypeInspectorBox.is_map(val) { local ty = val.get("type") if ty != null { local ty_str = "" + ty if ty_str != "i64" && ty_str != "int" && ty_str != "integer" { print("[BoxHelpers] dev assert failed: unexpected type " + ty_str + " in " + context) - val.get("__box_helpers_expect_i64_type") return 0 } } local inner = val.get("value") if inner != null { return StringHelpers.to_i64(inner) } print("[BoxHelpers] dev assert failed: missing value in " + context) - val.get("__box_helpers_expect_i64_value") return 0 } if StringHelpers.is_numeric_str("" + val) == 1 { return StringHelpers.to_i64(val) } print("[BoxHelpers] dev assert failed: expected numeric value for " + context) - val.get("__box_helpers_expect_i64_direct") return 0 } } diff --git a/lang/src/shared/hako_module.toml b/lang/src/shared/hako_module.toml index 0361014c..942c2d15 100644 --- a/lang/src/shared/hako_module.toml +++ b/lang/src/shared/hako_module.toml @@ -11,6 +11,7 @@ common.mini_vm_compare = "common/mini_vm_compare.hako" common.string_helpers = "common/string_helpers.hako" common.string_ops = "common/string_ops.hako" common.box_helpers = "common/box_helpers.hako" +common.box_type_inspector = "common/box_type_inspector_box.hako" common.entry_point_base = "common/entry_point_base.hako" common.common_imports = "common/common_imports.hako" @@ -26,6 +27,7 @@ json.utils.json_number_canonical = "json/utils/json_number_canonical_box.hako" # Host bridge & adapters host_bridge.host_bridge = "host_bridge/host_bridge_box.hako" +host_bridge.codegen_bridge = "host_bridge/codegen_bridge_box.hako" adapters.map_kv_string_to_array = "adapters/map_kv_string_to_array.hako" # MIR helpers (exported as stable module names) diff --git a/lang/src/shared/host_bridge/codegen_bridge_box.hako b/lang/src/shared/host_bridge/codegen_bridge_box.hako new file mode 100644 index 00000000..5772e747 --- /dev/null +++ b/lang/src/shared/host_bridge/codegen_bridge_box.hako @@ -0,0 +1,42 @@ +// codegen_bridge_box.hako — Thin wrapper for env.codegen extern calls +// Responsibility: +// - Provide emit_object/link_object helpers instead of duplicating +// hostbridge.extern_invoke("env.codegen", ...) everywhere. + +using selfhost.shared.common.box_type_inspector as BoxTypeInspectorBox + +static box CodegenBridgeBox { + method emit_object(mir_json) { + local args = new ArrayBox() + if mir_json != null { args.push("" + mir_json) } + return hostbridge.extern_invoke("env.codegen", "emit_object", args) + } + + method emit_object_args(args) { + local arr = me._ensure_array(args) + return hostbridge.extern_invoke("env.codegen", "emit_object", arr) + } + + method link_object(obj_path, out_path) { + local args = new ArrayBox() + if obj_path != null { args.push("" + obj_path) } + if out_path != null && ("" + out_path) != "" { + args.push("" + out_path) + } + return hostbridge.extern_invoke("env.codegen", "link_object", args) + } + + method link_object_args(args) { + local arr = me._ensure_array(args) + return hostbridge.extern_invoke("env.codegen", "link_object", arr) + } + + method _ensure_array(value) { + if value != null && BoxTypeInspectorBox.is_array(value) { + return value + } + local arr = new ArrayBox() + if value != null { arr.push(value) } + return arr + } +} diff --git a/lang/src/shared/mir/json_emit_box.hako b/lang/src/shared/mir/json_emit_box.hako index b817daad..c3b809fe 100644 --- a/lang/src/shared/mir/json_emit_box.hako +++ b/lang/src/shared/mir/json_emit_box.hako @@ -6,33 +6,26 @@ using selfhost.shared.common.box_helpers as BoxHelpers static box JsonEmitBox { _expect_map(val, context) { - if BoxHelpers.is_map(val) == 1 { return val } + if BoxHelpers.is_map(val) { return val } print("[JsonEmitBox] dev assert failed: expected MapBox for " + context) - val.get("__json_emit_expect_map") return val } _expect_array(val, context) { - if BoxHelpers.is_array(val) == 1 { return val } + if BoxHelpers.is_array(val) { return val } print("[JsonEmitBox] dev assert failed: expected ArrayBox for " + context) - val.get(0) return val } _expect_i64(val, context) { if val == null { print("[JsonEmitBox] dev assert failed: expected i64 (non-null) for " + context) - val.get("__json_emit_expect_i64_null") return 0 } - local repr = "" + val - if repr.indexOf("MapBox(") == 0 { - local inner = val.get("value") - if inner != null { return inner } - print("[JsonEmitBox] dev assert failed: missing value in " + context) - val.get("__json_emit_expect_i64_value") - return 0 + if BoxHelpers.is_map(val) { + // MapBox-wrapped integer (possibly nested); delegate unwrapping. + return BoxHelpers.value_i64(val) } - # Assume numeric immediate; avoid module function coercion for safety - return val + // Non-MapBox: treat as numeric immediate and normalize via helper. + return BoxHelpers.value_i64(val) } // ---- helpers ------------------------------------------------------------ @@ -109,8 +102,7 @@ static box JsonEmitBox { if val == null { return "{\"type\":\"i64\",\"value\":0}" } local ty = "i64" local inner = val - local repr = "" + val - if repr.indexOf("MapBox(") == 0 { + if BoxHelpers.is_map(val) { local ty_box = val.get("type") if ty_box != null { ty = "" + ty_box } local inner_box = val.get("value") @@ -235,8 +227,8 @@ static box JsonEmitBox { if blocks == null { if params != null || flags != null { local head = "{\"name\":" + me._quote(name) - if params != null { head = head + ",\"params\":" + JSON.stringify(params) } - if flags != null { head = head + ",\"flags\":" + JSON.stringify(flags) } + if params != null { head = head + ",\"params\":" + me._emit_params(params) } + if flags != null { head = head + ",\"flags\":" + me._emit_flags(flags) } return head + ",\"blocks\":[]}" } return "{\"name\":" + me._quote(name) + ",\"blocks\":[]}" @@ -244,8 +236,8 @@ static box JsonEmitBox { local n = BoxHelpers.array_len(blocks) local body = me._emit_function_rec(blocks, 0, n) local head2 = "{\"name\":" + me._quote(name) - if params != null { head2 = head2 + ",\"params\":" + JSON.stringify(params) } - if flags != null { head2 = head2 + ",\"flags\":" + JSON.stringify(flags) } + if params != null { head2 = head2 + ",\"params\":" + me._emit_params(params) } + if flags != null { head2 = head2 + ",\"flags\":" + me._emit_flags(flags) } return head2 + ",\"blocks\":[" + body + "]}" } _emit_function_rec(blocks, idx, len) { @@ -256,16 +248,48 @@ static box JsonEmitBox { return head + "," + tail } + _emit_params(params) { + if params == null { return "[]" } + if !BoxHelpers.is_array(params) { return "[]" } + local n = BoxHelpers.array_len(params) + if n == 0 { return "[]" } + return "[" + me._emit_params_rec(params, 0, n) + "]" + } + _emit_params_rec(params, idx, len) { + if idx >= len { return "" } + local head = me._int_str(params.get(idx)) + local tail = me._emit_params_rec(params, idx + 1, len) + if tail == "" { return head } + return head + "," + tail + } + + _emit_flags(flags) { + if flags == null { return "null" } + if !BoxHelpers.is_map(flags) { return "null" } + local keys = flags.keys() + if keys == null { return "{}" } + local n = BoxHelpers.array_len(keys) + if n == 0 { return "{}" } + local body = me._emit_flags_rec(flags, keys, 0, n) + return "{" + body + "}" + } + _emit_flags_rec(flags, keys, idx, len) { + if idx >= len { return "" } + local k = keys.get(idx) + local v = flags.get(k) + local head = me._quote(k) + ":" + me._quote(v) + local tail = me._emit_flags_rec(flags, keys, idx + 1, len) + if tail == "" { return head } + return head + "," + tail + } + to_json(module) { if module == null { return "" } // Prefer single-function fallbackを強化: has() 未実装環境でも repr チェックで検出 local f0 = module.get("functions_0") if f0 != null { - local repr = "" + f0 - if repr.indexOf("MapBox(") == 0 || repr.indexOf("HostHandleBox(") == 0 { - local one = me._emit_function(f0) - return "{\"kind\":\"MIR\",\"schema_version\":\"1.0\",\"functions\":[" + one + "]}" - } + local one = me._emit_function(f0) + return "{\"kind\":\"MIR\",\"schema_version\":\"1.0\",\"functions\":[" + one + "]}" } // Legacy path: try functions array if available local funcs = module.get("functions") diff --git a/lang/src/shared/mir/loop_form_box.hako b/lang/src/shared/mir/loop_form_box.hako index 12af9f96..a557947d 100644 --- a/lang/src/shared/mir/loop_form_box.hako +++ b/lang/src/shared/mir/loop_form_box.hako @@ -2,6 +2,7 @@ // LoopFormBox — minimal loop structure builder (P2: continue/break snapshots + Exit PHI) using selfhost.shared.mir.schema as MirSchemaBox +using selfhost.shared.common.string_helpers as StringHelpers static box LoopFormBox { @@ -277,63 +278,132 @@ static box LoopFormBox { // Shape: i from 0 to limit, with 2 additional carried variables (a, b) // carriers param: [init_a, init_b] (e.g. [0, 1] for fibonacci) method build_loop_multi_carrier(opts) { - local limit = opts.get("limit") - if limit == null { limit = 10 } - local carriers = opts.get("carriers") - local init_a = 0 - local init_b = 1 - if carriers != null && carriers.length() >= 2 { - init_a = carriers.get(0) - init_b = carriers.get(1) + local limit_kind = "const" + { + local lim_any = opts.get("limit_kind") + if lim_any != null { limit_kind = "" + lim_any } + } + local limit_val = opts.get("limit") + local limit_param_reg = opts.get("limit_param_reg") + if limit_kind == "param" { + if limit_param_reg == null { return null } + limit_param_reg = StringHelpers.to_i64(limit_param_reg) + if limit_param_reg <= 0 { return null } + } else { + if limit_val == null { limit_val = 10 } + limit_val = StringHelpers.to_i64(limit_val) + limit_kind = "const" } - // Preheader (block 0): init i=0, limit, a=init_a, b=init_b + local carriers_any = opts.get("carriers") + local carrier_vals = new ArrayBox() + if carriers_any != null { + local ci = 0 + local cn = carriers_any.length() + loop(ci < cn) { + carrier_vals.push(StringHelpers.to_i64(carriers_any.get(ci))) + ci = ci + 1 + } + } + if carrier_vals.length() < 2 { + return null + } + local carrier_count = carrier_vals.length() + + // Register layout + local reg_i_init = 1 + local reg_limit = 2 + local reg_carrier_init = new ArrayBox() + local idx = 0 + loop(idx < carrier_count) { + reg_carrier_init.push(3 + idx) + idx = idx + 1 + } + local reg_step = 3 + carrier_count + local reg_i_curr = reg_step + 1 + local reg_carrier_curr = new ArrayBox() + idx = 0 + loop(idx < carrier_count) { + reg_carrier_curr.push(reg_i_curr + idx + 1) + idx = idx + 1 + } + local reg_cmp = reg_i_curr + carrier_count + 1 + local reg_i_next = reg_cmp + 1 + local reg_carrier_next = new ArrayBox() + idx = 0 + loop(idx < carrier_count) { + reg_carrier_next.push(reg_i_next + idx + 1) + idx = idx + 1 + } + local next_reg = reg_carrier_next.get(carrier_count - 1) + 1 + + // Preheader local pre = new ArrayBox() - pre.push(MirSchemaBox.inst_const(1, 0)) // r1 = 0 (i) - pre.push(MirSchemaBox.inst_const(2, limit)) // r2 = limit - pre.push(MirSchemaBox.inst_const(3, init_a)) // r3 = init_a - pre.push(MirSchemaBox.inst_const(4, init_b)) // r4 = init_b + pre.push(MirSchemaBox.inst_const(reg_i_init, 0)) + if limit_kind == "const" { + pre.push(MirSchemaBox.inst_const(reg_limit, limit_val)) + } else { + pre.push(MirSchemaBox.inst_copy(limit_param_reg, reg_limit)) + } + idx = 0 + loop(idx < carrier_count) { + pre.push(MirSchemaBox.inst_const(reg_carrier_init.get(idx), carrier_vals.get(idx))) + idx = idx + 1 + } + pre.push(MirSchemaBox.inst_const(reg_step, 1)) pre.push(MirSchemaBox.inst_jump(1)) - // Header (block 1): PHI(i), PHI(a), PHI(b), compare, branch + // Header with PHIs local header = new ArrayBox() - local phi_i_inc = new ArrayBox() - phi_i_inc.push(MirSchemaBox.phi_incoming(0, 1)) // from preheader - phi_i_inc.push(MirSchemaBox.phi_incoming(3, 17)) // from latch - header.push(MirSchemaBox.inst_phi(10, phi_i_inc)) // r10 = i + local phi_i = new ArrayBox() + phi_i.push(MirSchemaBox.phi_incoming(0, reg_i_init)) + phi_i.push(MirSchemaBox.phi_incoming(3, reg_i_next)) + header.push(MirSchemaBox.inst_phi(reg_i_curr, phi_i)) - local phi_a_inc = new ArrayBox() - phi_a_inc.push(MirSchemaBox.phi_incoming(0, 3)) // from preheader - phi_a_inc.push(MirSchemaBox.phi_incoming(3, 18)) // from latch - header.push(MirSchemaBox.inst_phi(11, phi_a_inc)) // r11 = a + idx = 0 + loop(idx < carrier_count) { + local phi_car = new ArrayBox() + phi_car.push(MirSchemaBox.phi_incoming(0, reg_carrier_init.get(idx))) + phi_car.push(MirSchemaBox.phi_incoming(3, reg_carrier_next.get(idx))) + header.push(MirSchemaBox.inst_phi(reg_carrier_curr.get(idx), phi_car)) + idx = idx + 1 + } - local phi_b_inc = new ArrayBox() - phi_b_inc.push(MirSchemaBox.phi_incoming(0, 4)) // from preheader - phi_b_inc.push(MirSchemaBox.phi_incoming(3, 19)) // from latch - header.push(MirSchemaBox.inst_phi(12, phi_b_inc)) // r12 = b + header.push(MirSchemaBox.inst_compare("Lt", reg_i_curr, reg_limit, reg_cmp)) + header.push(MirSchemaBox.inst_branch(reg_cmp, 2, 4)) - header.push(MirSchemaBox.inst_compare("Lt", 10, 2, 13)) // r13 = (i < limit) - header.push(MirSchemaBox.inst_branch(13, 2, 4)) // body or exit - - // Body (block 2): t = a + b; a' = b; b' = t; i' = i + 1 + // Body: compute new value = sum of carriers local body = new ArrayBox() - body.push(MirSchemaBox.inst_binop("Add", 11, 12, 14)) // r14 = a + b (t) - body.push(MirSchemaBox.inst_const(20, 1)) // r20 = step (1) - body.push(MirSchemaBox.inst_binop("Add", 10, 20, 15)) // r15 = i + 1 + local reg_sum = next_reg + next_reg = next_reg + 1 + body.push(MirSchemaBox.inst_copy(reg_carrier_curr.get(0), reg_sum)) + local current_sum = reg_sum + idx = 1 + loop(idx < carrier_count) { + local reg_tmp = next_reg + next_reg = next_reg + 1 + body.push(MirSchemaBox.inst_binop("Add", current_sum, reg_carrier_curr.get(idx), reg_tmp)) + current_sum = reg_tmp + idx = idx + 1 + } + local reg_new_value = current_sum body.push(MirSchemaBox.inst_jump(3)) - // Latch (block 3): pass updated values (i', a'=b, b'=t) back to header + // Latch: i' and carrier shifts local latch = new ArrayBox() - latch.push(MirSchemaBox.inst_copy(15, 17)) // r17 = i' - latch.push(MirSchemaBox.inst_copy(12, 18)) // r18 = a' (=b) - latch.push(MirSchemaBox.inst_copy(14, 19)) // r19 = b' (=t) + latch.push(MirSchemaBox.inst_binop("Add", reg_i_curr, reg_step, reg_i_next)) + idx = 0 + loop(idx < carrier_count - 1) { + latch.push(MirSchemaBox.inst_copy(reg_carrier_curr.get(idx + 1), reg_carrier_next.get(idx))) + idx = idx + 1 + } + latch.push(MirSchemaBox.inst_copy(reg_new_value, reg_carrier_next.get(carrier_count - 1))) latch.push(MirSchemaBox.inst_jump(1)) - // Exit (block 4): return final b value + // Exit: return last carrier local exit = new ArrayBox() - exit.push(MirSchemaBox.inst_ret(12)) + exit.push(MirSchemaBox.inst_ret(reg_carrier_curr.get(carrier_count - 1))) - // Assemble blocks local blocks = new ArrayBox() blocks.push(MirSchemaBox.block(0, pre)) blocks.push(MirSchemaBox.block(1, header)) diff --git a/lang/src/shared/mir/mir_schema_box.hako b/lang/src/shared/mir/mir_schema_box.hako index fd0478ac..66ba8d34 100644 --- a/lang/src/shared/mir/mir_schema_box.hako +++ b/lang/src/shared/mir/mir_schema_box.hako @@ -2,66 +2,55 @@ // MirSchemaBox — minimal MIR(JSON v0) constructors (P1 scope) using selfhost.shared.common.string_helpers as StringHelpers +using selfhost.shared.common.box_type_inspector as BoxTypeInspectorBox static box MirSchemaBox { _expect_map(val, context) { if val == null { print("[MirSchemaBox] dev assert failed: expected MapBox (non-null) for " + context) - val.get("__mir_schema_expect_map_null") return val } - local repr = "" + val - if repr.indexOf("MapBox(") == 0 { return val } + if BoxTypeInspectorBox.is_map(val) { return val } print("[MirSchemaBox] dev assert failed: expected MapBox for " + context) - val.get("__mir_schema_expect_map") return val } _expect_array(val, context) { if val == null { print("[MirSchemaBox] dev assert failed: expected ArrayBox (non-null) for " + context) - val.get(0) return val } - local repr = "" + val - if repr.indexOf("ArrayBox(") == 0 { return val } + if BoxTypeInspectorBox.is_array(val) { return val } print("[MirSchemaBox] dev assert failed: expected ArrayBox for " + context) - val.get(0) return val } _expect_i64(val, context) { if val == null { print("[MirSchemaBox] dev assert failed: expected i64 (non-null) for " + context) - val.get("__mir_schema_expect_i64_null") return 0 } - local repr = "" + val - if repr.indexOf("MapBox(") == 0 { + if BoxTypeInspectorBox.is_map(val) { local ty = val.get("type") if ty != null { local ty_str = "" + ty if ty_str != "i64" && ty_str != "int" && ty_str != "integer" { print("[MirSchemaBox] dev assert failed: unexpected type " + ty_str + " in " + context) - val.get("__mir_schema_expect_i64_type") return 0 } } local inner = val.get("value") if inner != null { return StringHelpers.to_i64(inner) } print("[MirSchemaBox] dev assert failed: missing value in " + context) - val.get("__mir_schema_expect_i64_value") return 0 } if StringHelpers.is_numeric_str("" + val) == 1 { return StringHelpers.to_i64(val) } print("[MirSchemaBox] dev assert failed: expected numeric value for " + context) - val.get("__mir_schema_expect_i64_direct") return 0 } _len(arr) { if arr == null { return 0 } // ArrayBox.size/1 は MapBox-wrapped integer を返すので、unwrap する local size_val = arr.length() - local repr = "" + size_val - if repr.indexOf("MapBox(") == 0 { + if BoxTypeInspectorBox.is_map(size_val) { local inner = size_val.get("value") if inner != null { return inner } } @@ -124,6 +113,13 @@ static box MirSchemaBox { m.set("dst", this.i(dst)) return m } + inst_copy(src, dst) { + local m = new MapBox() + m.set("op", "copy") + m.set("src", this.i(src)) + m.set("dst", this.i(dst)) + return m + } inst_branch(cond, then_id, else_id) { local m = new MapBox() m.set("op", "branch") diff --git a/lang/src/vm/boxes/mir_call_v1_handler.hako b/lang/src/vm/boxes/mir_call_v1_handler.hako index 12deb0ad..1f092986 100644 --- a/lang/src/vm/boxes/mir_call_v1_handler.hako +++ b/lang/src/vm/boxes/mir_call_v1_handler.hako @@ -322,6 +322,13 @@ static box MirCallV1HandlerBox { if dstp != null { regs.setField(StringHelpers.int_to_str(dstp), "") } return } + if name == "env.box_introspect.kind" { + local dstp = JsonFragBox.get_int(seg, "dst") + local aval = null; if arg0id >= 0 { aval = regs.getField(StringHelpers.int_to_str(arg0id)) } + HakoruneExternProviderBox.get(name, aval) + if dstp != null { regs.setField(StringHelpers.int_to_str(dstp), "") } + return + } } if name == "env.console.log" || name == "nyash.console.log" || name == "env.console.warn" || name == "nyash.console.warn" || diff --git a/lang/src/vm/hakorune-vm/extern_provider.hako b/lang/src/vm/hakorune-vm/extern_provider.hako index aa16c10f..7b81c8dd 100644 --- a/lang/src/vm/hakorune-vm/extern_provider.hako +++ b/lang/src/vm/hakorune-vm/extern_provider.hako @@ -3,6 +3,7 @@ // Scope (20.38準備): env.get / console.log のみ（C‑ABI導線は後段で接続）。 using selfhost.vm.hakorune-vm.str_cast as StrCast +using selfhost.shared.host_bridge.codegen_bridge as CodegenBridgeBox static box HakoruneExternProviderBox { get(name, args) { @@ -31,11 +32,11 @@ static box HakoruneExternProviderBox { } if name == "env.mirbuilder.emit" { // Optional C‑ABI bridge（既定OFF）: タグを出力しつつ、Rust 側 extern_provider に最小接続 - if env.get("HAKO_V1_EXTERN_PROVIDER_C_ABI") == "1" { - print("[extern/c-abi:mirbuilder.emit]") - // Call through to Core extern dispatcher and return the produced JSON (v1) - local out = hostbridge.extern_invoke("env.mirbuilder", "emit", args) - return "" + out + if env.get("HAKO_V1_EXTERN_PROVIDER_C_ABI") == "1" { + print("[extern/c-abi:mirbuilder.emit]") + // Call through to Core extern dispatcher and return the produced JSON (v1) + local out = hostbridge.extern_invoke("env.mirbuilder", "emit", args) + return "" + out } // Default: return empty string (verify/dev stub keeps rc=0) return "" @@ -48,12 +49,20 @@ static box HakoruneExternProviderBox { // Call through to Core extern dispatcher and return produced object path // 現段階では Core 側で C-API/llvmlite の切替を行う。 // 互換のため *_ny も最終的に emit_object へ委譲する。 - local out = hostbridge.extern_invoke("env.codegen", "emit_object", args) + local out = CodegenBridgeBox.emit_object_args(args) return "" + out } // Default: return empty string (verify/dev stub keeps rc=0) return "" } + if name == "env.box_introspect.kind" { + if env.get("HAKO_V1_EXTERN_PROVIDER_C_ABI") == "1" { + if env.get("HAKO_CABI_TRACE") == "1" { print("[extern/c-abi:box_introspect.kind]") } + local out = hostbridge.extern_invoke("env.box_introspect", "kind", args) + return "" + out + } + return "" + } // Unknown: return null for now (caller decides Fail‑Fast) return null } diff --git a/nyash.toml b/nyash.toml index fae60b12..48639dee 100644 --- a/nyash.toml +++ b/nyash.toml @@ -150,6 +150,10 @@ path = "lang/src/shared/common/string_helpers.hako" "lang.mir.builder.MirBuilderMinBox" = "lang/src/mir/builder/MirBuilderMinBox.hako" "lang.mir.builder.pattern_registry" = "lang/src/mir/builder/pattern_registry.hako" "lang.mir.builder.func_body.basic_lower_box" = "lang/src/mir/builder/func_body/basic_lower_box.hako" +"lang.mir.builder.func_body.extern_call_box" = "lang/src/mir/builder/func_body/extern_call_box.hako" +"lang.mir.builder.func_body.cli_entry_box" = "lang/src/mir/builder/func_body/cli_entry_box.hako" +"lang.mir.builder.func_body.cli_run_shape_box" = "lang/src/mir/builder/func_body/cli_run_shape_box.hako" +"lang.mir.builder.func_body.cli_run_lower_box" = "lang/src/mir/builder/func_body/cli_run_lower_box.hako" "lang.mir.builder.internal.prog_scan_box" = "lang/src/mir/builder/internal/prog_scan_box.hako" "lang.mir.builder.internal.lower_load_store_local_box" = "lang/src/mir/builder/internal/lower_load_store_local_box.hako" "lang.mir.builder.internal.lower_typeop_cast_box" = "lang/src/mir/builder/internal/lower_typeop_cast_box.hako" @@ -169,6 +173,7 @@ path = "lang/src/shared/common/string_helpers.hako" "selfhost.shared.common.mini_vm_compare" = "lang/src/shared/common/mini_vm_compare.hako" "selfhost.shared.common.string_helpers" = "lang/src/shared/common/string_helpers.hako" "selfhost.shared.common.box_helpers" = "lang/src/shared/common/box_helpers.hako" +"selfhost.shared.common.box_type_inspector" = "lang/src/shared/common/box_type_inspector_box.hako" "selfhost.shared.json.mir_builder_min" = "lang/src/shared/json/mir_builder_min.hako" "selfhost.shared.json.mir_v1_adapter" = "lang/src/shared/json/mir_v1_adapter.hako" "selfhost.shared.json.core.json_cursor" = "lang/src/shared/json/json_cursor.hako" @@ -181,6 +186,7 @@ path = "lang/src/shared/common/string_helpers.hako" "selfhost.shared.mir.builder" = "lang/src/shared/mir/block_builder_box.hako" "selfhost.shared.mir.io" = "lang/src/shared/mir/mir_io_box.hako" "selfhost.shared.mir.json_emit" = "lang/src/shared/mir/json_emit_box.hako" +"selfhost.shared.host_bridge.codegen_bridge" = "lang/src/shared/host_bridge/codegen_bridge_box.hako" "selfhost.llvm.ir.normalize.print" = "lang/src/llvm_ir/boxes/normalize/normalize_print.hako" "selfhost.llvm.ir.normalize.ref" = "lang/src/llvm_ir/boxes/normalize/normalize_ref.hako" "selfhost.llvm.ir.normalize.array_legacy" = "lang/src/llvm_ir/boxes/normalize/normalize_array_legacy.hako" @@ -247,6 +253,9 @@ path = "lang/src/shared/common/string_helpers.hako" "hako.mir.builder.internal.lower_if_compare_varint" = "lang/src/mir/builder/internal/lower_if_compare_varint_box.hako" "hako.mir.builder.internal.lower_if_compare_varvar" = "lang/src/mir/builder/internal/lower_if_compare_varvar_box.hako" "hako.mir.builder.internal.lower_loop_sum_bc" = "lang/src/mir/builder/internal/lower_loop_sum_bc_box.hako" +"hako.mir.builder.internal.lower_loop_sum_bc_box" = "lang/src/mir/builder/internal/lower_loop_sum_bc_box.hako" +"hako.mir.builder.internal.lower_loop_simple_box" = "lang/src/mir/builder/internal/lower_loop_simple_box.hako" +"hako.mir.builder.internal.lower_loop_multi_carrier_box" = "lang/src/mir/builder/internal/lower_loop_multi_carrier_box.hako" "hako.mir.builder.internal.sentinel_extractor" = "lang/src/mir/builder/internal/sentinel_extractor_box.hako" "hako.mir.builder.internal.lower_loop_count_param" = "lang/src/mir/builder/internal/lower_loop_count_param_box.hako" "hako.mir.builder.internal.lower_loop_simple" = "lang/src/mir/builder/internal/lower_loop_simple_box.hako" diff --git a/src/backend/mir_interpreter/handlers/externals.rs b/src/backend/mir_interpreter/handlers/externals.rs index d8122fd8..b02f144f 100644 --- a/src/backend/mir_interpreter/handlers/externals.rs +++ b/src/backend/mir_interpreter/handlers/externals.rs @@ -188,6 +188,14 @@ impl MirInterpreter { self.write_result(dst, VMValue::String(exe.to_string_lossy().into_owned())); Ok(()) } + ("env.box_introspect", "kind") => { + // Route env.box_introspect.kind to extern provider (plugin_loader_v2) + let ret = self + .extern_provider_dispatch("env.box_introspect.kind", args) + .unwrap_or(Ok(VMValue::Void))?; + self.write_result(dst, ret); + Ok(()) + } ("hostbridge", "extern_invoke") => { if let Some(res) = self.extern_provider_dispatch("hostbridge.extern_invoke", args) { match res { diff --git a/src/config/env.rs b/src/config/env.rs index 57d95aea..5a7b77ad 100644 --- a/src/config/env.rs +++ b/src/config/env.rs @@ -661,7 +661,7 @@ pub fn gate_c_core() -> bool { } /// Consolidated toggle for selfhost NY compiler pipeline. -/// Primary: NYASH_USE_NY_COMPILER=0|1. Legacy disables accepted (with warning): +/// Primary: NYASH_USE_NY_COMPILER=0|1（明示指定のみ有効）。Legacy disables accepted (with warning): /// NYASH_DISABLE_NY_COMPILER/HAKO_DISABLE_NY_COMPILER (any true value disables). pub fn use_ny_compiler() -> bool { // Primary knob takes precedence when explicitly set @@ -678,6 +678,6 @@ pub fn use_ny_compiler() -> bool { warn_alias_once("HAKO_DISABLE_NY_COMPILER", "NYASH_USE_NY_COMPILER=0"); return false; } - // Default: ON (MVP selfhost path) - true + // Phase 25.1b: Default OFF（selfhost NY compiler は明示 opt-in のみ） + false } diff --git a/src/mir/builder/builder_calls.rs b/src/mir/builder/builder_calls.rs index 5086dfd2..b05b2acd 100644 --- a/src/mir/builder/builder_calls.rs +++ b/src/mir/builder/builder_calls.rs @@ -93,7 +93,7 @@ impl super::MirBuilder { if let CallTarget::Global(ref name) = target { // 0) Dev-only safety: treat condition_fn as always-true predicate when missing if name == "condition_fn" { - let dstv = dst.unwrap_or_else(|| self.value_gen.next()); + let dstv = dst.unwrap_or_else(|| self.next_value_id()); // Emit integer constant via ConstantEmissionBox let one = crate::mir::builder::emission::constant::emit_integer(self, 1); if dst.is_none() { @@ -110,7 +110,7 @@ impl super::MirBuilder { // 1) Direct module function fallback: call by name if present if let Some(ref module) = self.current_module { if module.functions.contains_key(name) { - let dstv = dst.unwrap_or_else(|| self.value_gen.next()); + let dstv = dst.unwrap_or_else(|| self.next_value_id()); let name_const = match crate::mir::builder::name_const::make_name_const_result(self, name) { Ok(v) => v, Err(e) => return Err(e), @@ -137,7 +137,7 @@ impl super::MirBuilder { let (bx, _arity) = matches.remove(0); let func_name = format!("{}.{}{}", bx, name, format!("/{}", arity_for_try)); // Emit legacy call directly to preserve behavior - let dstv = dst.unwrap_or_else(|| self.value_gen.next()); + let dstv = dst.unwrap_or_else(|| self.next_value_id()); let name_const = match crate::mir::builder::name_const::make_name_const_result(self, &func_name) { Ok(v) => v, Err(e) => return Err(e), @@ -314,7 +314,7 @@ impl super::MirBuilder { // Create a string constant for the function name via NameConstBox let name_const = crate::mir::builder::name_const::make_name_const_result(self, &name)?; // Allocate a destination if not provided so we can annotate it - let actual_dst = if let Some(d) = dst { d } else { self.value_gen.next() }; + let actual_dst = if let Some(d) = dst { d } else { self.next_value_id() }; let mut args = args; crate::mir::builder::ssa::local::finalize_args(self, &mut args); self.emit_instruction(MirInstruction::Call { @@ -416,7 +416,7 @@ impl super::MirBuilder { } ASTNode::New { class, arguments, .. } if class == "IntegerBox" && arguments.len() == 1 => { let iv = match self.build_expression(arguments[0].clone()) { Ok(v) => v, Err(e) => return Some(Err(e)) }; - let fv = self.value_gen.next(); + let fv = self.next_value_id(); if let Err(e) = self.emit_instruction(MirInstruction::TypeOp { dst: fv, op: TypeOpKind::Cast, value: iv, ty: MirType::Float }) { return Some(Err(e)); } math_args.push(fv); } @@ -429,13 +429,13 @@ impl super::MirBuilder { } } // new MathBox() - let math_recv = self.value_gen.next(); + let math_recv = self.next_value_id(); if let Err(e) = self.emit_constructor_call(math_recv, "MathBox".to_string(), vec![]) { return Some(Err(e)); } self.value_origin_newbox.insert(math_recv, "MathBox".to_string()); // birth() if let Err(e) = self.emit_method_call(None, math_recv, "birth".to_string(), vec![]) { return Some(Err(e)); } // call method - let dst = self.value_gen.next(); + let dst = self.next_value_id(); if let Err(e) = self.emit_method_call(Some(dst), math_recv, name.to_string(), math_args) { return Some(Err(e)); } Some(Ok(dst)) } @@ -458,7 +458,7 @@ impl super::MirBuilder { let iface = env_field.as_str(); let m = method; let mut extern_call = |iface_name: &str, method_name: &str, effects: EffectMask, returns: bool| -> Result { - let result_id = self.value_gen.next(); + let result_id = self.next_value_id(); self.emit_instruction(MirInstruction::ExternCall { dst: if returns { Some(result_id) } else { None }, iface_name: iface_name.to_string(), method_name: method_name.to_string(), args: arg_values.clone(), effects })?; if returns { Ok(result_id) @@ -490,7 +490,7 @@ impl super::MirBuilder { for a in arguments { match self.build_expression(a.clone()) { Ok(v) => arg_values.push(v), Err(e) => return Some(Err(e)) } } - let result_id = self.value_gen.next(); + let result_id = self.next_value_id(); let fun_name = format!("{}.{}{}", cls_name, method, format!("/{}", arg_values.len())); let fun_val = match crate::mir::builder::name_const::make_name_const_result(self, &fun_name) { Ok(v) => v, @@ -541,7 +541,7 @@ impl super::MirBuilder { if let Some(type_name) = special_handlers::extract_string_literal(&args[1]) { let val = self.build_expression(args[0].clone())?; let ty = special_handlers::parse_type_name_to_mir(&type_name); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let op = if name == "isType" { TypeOpKind::Check } else { @@ -569,7 +569,7 @@ impl super::MirBuilder { // Special-case: global str(x) → x.str() に正規化（内部は関数へ統一される） if name == "str" && arg_values.len() == 1 { - let dst = self.value_gen.next(); + let dst = self.next_value_id(); // Use unified method emission; downstream rewrite will functionize as needed self.emit_method_call(Some(dst), arg_values[0], "str".to_string(), vec![])?; return Ok(dst); @@ -582,7 +582,7 @@ impl super::MirBuilder { if !use_unified { // Legacy path - let dst = self.value_gen.next(); + let dst = self.next_value_id(); // === ChatGPT5 Pro Design: Type-safe function call resolution === // Resolve call target using new type-safe system; if it fails, try static-method fallback @@ -599,7 +599,7 @@ impl super::MirBuilder { .collect(); if matches.len() == 1 { let (bx, _arity) = matches.remove(0); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let func_name = format!("{}.{}{}", bx, name, format!("/{}", arg_values.len())); // Emit unified global call to the lowered static method function self.emit_unified_call(Some(dst), CallTarget::Global(func_name), arg_values)?; @@ -619,7 +619,7 @@ impl super::MirBuilder { .collect(); if cands.len() == 1 { let func_name = cands.remove(0); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_legacy_call(Some(dst), CallTarget::Global(func_name), arg_values)?; return Ok(dst); } @@ -644,7 +644,7 @@ impl super::MirBuilder { Ok(dst) } else { // Unified path for builtins/externs - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_unified_call( Some(dst), CallTarget::Global(name), @@ -713,7 +713,7 @@ impl super::MirBuilder { let mut call_args = Vec::with_capacity(arity + 1); call_args.push(me_id); call_args.extend(arg_values.into_iter()); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); // Emit as unified global call to lowered function self.emit_unified_call( Some(dst), @@ -762,7 +762,7 @@ impl super::MirBuilder { arg_values.push(self.build_expression(arg)?); } let parent_value = crate::mir::builder::emission::constant::emit_string(self, parent); - let result_id = self.value_gen.next(); + let result_id = self.next_value_id(); self.emit_box_or_plugin_call( Some(result_id), parent_value, diff --git a/src/mir/builder/control_flow.rs b/src/mir/builder/control_flow.rs index 2f105178..6a4d9eeb 100644 --- a/src/mir/builder/control_flow.rs +++ b/src/mir/builder/control_flow.rs @@ -69,7 +69,7 @@ impl super::MirBuilder { let saved_allow_ret = self.cleanup_allow_return; let saved_allow_throw = self.cleanup_allow_throw; - let ret_slot = self.value_gen.next(); + let ret_slot = self.next_value_id(); self.return_defer_active = true; self.return_defer_slot = Some(ret_slot); self.return_deferred_emitted = false; @@ -82,7 +82,7 @@ impl super::MirBuilder { catch_clause.exception_type ); } - let exception_value = self.value_gen.next(); + let exception_value = self.next_value_id(); self.emit_instruction(MirInstruction::Catch { exception_type: catch_clause.exception_type.clone(), exception_value, diff --git a/src/mir/builder/decls.rs b/src/mir/builder/decls.rs index 6d6bbdd6..19b61672 100644 --- a/src/mir/builder/decls.rs +++ b/src/mir/builder/decls.rs @@ -51,11 +51,7 @@ impl super::MirBuilder { for p in params.iter() { // Allocate a value ID using the current function's value generator // This creates a local variable, not a parameter - let pid = if let Some(ref mut f) = self.current_function { - f.next_value_id() - } else { - self.value_gen.next() - }; + let pid = self.next_value_id(); if p == "args" { // new ArrayBox() with no args self.emit_instruction(MirInstruction::NewBox { diff --git a/src/mir/builder/emission/constant.rs b/src/mir/builder/emission/constant.rs index 14c9b7e0..3947d915 100644 --- a/src/mir/builder/emission/constant.rs +++ b/src/mir/builder/emission/constant.rs @@ -6,54 +6,44 @@ use crate::mir::{ConstValue, MirInstruction, ValueId}; use crate::mir::builder::MirBuilder; -/// Helper to allocate value ID from correct generator (function-local or global) -#[inline] -fn next_value_id(b: &mut MirBuilder) -> ValueId { - if let Some(ref mut f) = b.current_function { - f.next_value_id() - } else { - b.value_gen.next() - } -} - #[inline] pub fn emit_integer(b: &mut MirBuilder, val: i64) -> ValueId { - let dst = next_value_id(b); + let dst = b.next_value_id(); let _ = b.emit_instruction(MirInstruction::Const { dst, value: ConstValue::Integer(val) }); dst } #[inline] pub fn emit_bool(b: &mut MirBuilder, val: bool) -> ValueId { - let dst = next_value_id(b); + let dst = b.next_value_id(); let _ = b.emit_instruction(MirInstruction::Const { dst, value: ConstValue::Bool(val) }); dst } #[inline] pub fn emit_float(b: &mut MirBuilder, val: f64) -> ValueId { - let dst = next_value_id(b); + let dst = b.next_value_id(); let _ = b.emit_instruction(MirInstruction::Const { dst, value: ConstValue::Float(val) }); dst } #[inline] pub fn emit_string>(b: &mut MirBuilder, s: S) -> ValueId { - let dst = next_value_id(b); + let dst = b.next_value_id(); let _ = b.emit_instruction(MirInstruction::Const { dst, value: ConstValue::String(s.into()) }); dst } #[inline] pub fn emit_null(b: &mut MirBuilder) -> ValueId { - let dst = next_value_id(b); + let dst = b.next_value_id(); let _ = b.emit_instruction(MirInstruction::Const { dst, value: ConstValue::Null }); dst } #[inline] pub fn emit_void(b: &mut MirBuilder) -> ValueId { - let dst = next_value_id(b); + let dst = b.next_value_id(); let _ = b.emit_instruction(MirInstruction::Const { dst, value: ConstValue::Void }); dst } diff --git a/src/mir/builder/exprs.rs b/src/mir/builder/exprs.rs index 133230f5..feebec2d 100644 --- a/src/mir/builder/exprs.rs +++ b/src/mir/builder/exprs.rs @@ -76,7 +76,7 @@ impl super::MirBuilder { if let Some(type_name) = Self::extract_string_literal(&m.arguments[0]) { let obj_val = self.build_expression_impl(*m.object.clone())?; let ty = Self::parse_type_name_to_mir(&type_name); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let op = if m.method == "is" { crate::mir::TypeOpKind::Check } else { crate::mir::TypeOpKind::Cast }; self.emit_instruction(MirInstruction::TypeOp { dst, op, value: obj_val, ty })?; return Ok(dst); @@ -244,7 +244,7 @@ impl super::MirBuilder { } => self.build_new_expression(class.clone(), arguments.clone()), ASTNode::ArrayLiteral { elements, .. } => { - let arr_id = self.value_gen.next(); + let arr_id = self.next_value_id(); self.emit_instruction(MirInstruction::NewBox { dst: arr_id, box_type: "ArrayBox".to_string(), @@ -278,7 +278,7 @@ impl super::MirBuilder { Ok(arr_id) } ASTNode::MapLiteral { entries, .. } => { - let map_id = self.value_gen.next(); + let map_id = self.next_value_id(); self.emit_instruction(MirInstruction::NewBox { dst: map_id, box_type: "MapBox".to_string(), @@ -409,7 +409,7 @@ impl super::MirBuilder { match class_hint.as_deref() { Some("ArrayBox") => { let index_val = self.build_expression(index)?; - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_box_or_plugin_call( Some(dst), target_val, @@ -422,7 +422,7 @@ impl super::MirBuilder { } Some("MapBox") => { let index_val = self.build_expression(index)?; - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_box_or_plugin_call( Some(dst), target_val, diff --git a/src/mir/builder/exprs_call.rs b/src/mir/builder/exprs_call.rs index 0da3f646..68e020ec 100644 --- a/src/mir/builder/exprs_call.rs +++ b/src/mir/builder/exprs_call.rs @@ -19,7 +19,7 @@ impl super::MirBuilder { if use_unified { // New unified path - use emit_unified_call with Value target - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_unified_call( Some(dst), super::builder_calls::CallTarget::Value(callee_id), @@ -28,7 +28,7 @@ impl super::MirBuilder { Ok(dst) } else { // Unified-off path: still encode callee as Value to avoid by-name resolution - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(super::MirInstruction::Call { dst: Some(dst), func: callee_id, diff --git a/src/mir/builder/exprs_lambda.rs b/src/mir/builder/exprs_lambda.rs index 5abcc434..fed0ba66 100644 --- a/src/mir/builder/exprs_lambda.rs +++ b/src/mir/builder/exprs_lambda.rs @@ -162,7 +162,7 @@ impl super::MirBuilder { } } let me = self.variable_map.get("me").copied(); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(super::MirInstruction::NewClosure { dst, params: params.clone(), diff --git a/src/mir/builder/exprs_peek.rs b/src/mir/builder/exprs_peek.rs index 5142fe28..26f45fe1 100644 --- a/src/mir/builder/exprs_peek.rs +++ b/src/mir/builder/exprs_peek.rs @@ -14,7 +14,7 @@ impl super::MirBuilder { // Prepare merge and result let merge_block: BasicBlockId = self.block_gen.next(); - let result_val = self.value_gen.next(); + let result_val = self.next_value_id(); let mut phi_inputs: Vec<(BasicBlockId, ValueId)> = Vec::new(); // Create dispatch block where we start comparing arms @@ -76,7 +76,7 @@ impl super::MirBuilder { LiteralValue::Null => crate::mir::builder::emission::constant::emit_null(self), LiteralValue::Void => crate::mir::builder::emission::constant::emit_void(self), }; - let cond_id = self.value_gen.next(); + let cond_id = self.next_value_id(); crate::mir::builder::emission::compare::emit_to(self, cond_id, super::CompareOp::Eq, scr_val, lit_id)?; crate::mir::builder::emission::branch::emit_conditional(self, cond_id, then_block, else_target)?; diff --git a/src/mir/builder/exprs_qmark.rs b/src/mir/builder/exprs_qmark.rs index 2c29b87f..250eeaab 100644 --- a/src/mir/builder/exprs_qmark.rs +++ b/src/mir/builder/exprs_qmark.rs @@ -9,7 +9,7 @@ impl super::MirBuilder { ) -> Result { let res_val = self.build_expression_impl(expression)?; let res_local = self.local_ssa_ensure(res_val, 0); - let ok_id = self.value_gen.next(); + let ok_id = self.next_value_id(); self.emit_instruction(super::MirInstruction::BoxCall { dst: Some(ok_id), box_val: res_local, @@ -27,7 +27,7 @@ impl super::MirBuilder { value: Some(res_local), })?; self.start_new_block(else_block)?; - let val_id = self.value_gen.next(); + let val_id = self.next_value_id(); self.emit_instruction(super::MirInstruction::BoxCall { dst: Some(val_id), box_val: res_local, diff --git a/src/mir/builder/fields.rs b/src/mir/builder/fields.rs index ab814236..4a7b214c 100644 --- a/src/mir/builder/fields.rs +++ b/src/mir/builder/fields.rs @@ -36,7 +36,7 @@ impl super::MirBuilder { let mut args_vec = vec![field_name_id]; crate::mir::builder::ssa::local::finalize_field_base_and_args(self, &mut base, &mut args_vec); // BoxCall: getField(name) - let field_val = self.value_gen.next(); + let field_val = self.next_value_id(); self.emit_instruction(MirInstruction::BoxCall { dst: Some(field_val), box_val: base, diff --git a/src/mir/builder/method_call_handlers.rs b/src/mir/builder/method_call_handlers.rs index 6ac408fb..b2af575e 100644 --- a/src/mir/builder/method_call_handlers.rs +++ b/src/mir/builder/method_call_handlers.rs @@ -24,7 +24,7 @@ impl MirBuilder { // Compose lowered function name: BoxName.method/N let func_name = format!("{}.{}/{}", box_name, method, arg_values.len()); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); if std::env::var("NYASH_STATIC_CALL_TRACE").ok().as_deref() == Some("1") { eprintln!("[builder] static-call {}", func_name); @@ -43,7 +43,7 @@ impl MirBuilder { type_name: &str, ) -> Result { let mir_ty = Self::parse_type_name_to_mir(type_name); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let op = if method == "is" { TypeOpKind::Check } else { @@ -99,7 +99,7 @@ impl MirBuilder { // Receiver class hintは emit_unified_call 側で起源/型から判断する（重複回避） // 統一経路: emit_unified_call に委譲（RouterPolicy と rewrite::* で安定化） - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_unified_call( Some(dst), CallTarget::Method { box_type: None, method, receiver: object_value }, diff --git a/src/mir/builder/ops.rs b/src/mir/builder/ops.rs index c992552c..6e4c0b96 100644 --- a/src/mir/builder/ops.rs +++ b/src/mir/builder/ops.rs @@ -34,7 +34,7 @@ impl super::MirBuilder { let rhs = self .ensure_slotified_for_use(rhs_raw, "@binop_rhs") .unwrap_or(rhs_raw); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let mir_op = self.convert_binary_operator(operator)?; @@ -193,8 +193,8 @@ impl super::MirBuilder { .map(|s| s == "IntegerBox") .unwrap_or(false) { - let li = self.value_gen.next(); - let ri = self.value_gen.next(); + let li = self.next_value_id(); + let ri = self.next_value_id(); self.emit_instruction(MirInstruction::TypeOp { dst: li, op: TypeOpKind::Cast, @@ -404,7 +404,7 @@ impl super::MirBuilder { }; if !name.is_empty() { let in_guard = self.current_function.as_ref().map(|f| f.signature.name.starts_with(guard_prefix)).unwrap_or(false); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); if !in_guard { self.emit_legacy_call(Some(dst), super::builder_calls::CallTarget::Global(name.to_string()), vec![operand_val])?; self.value_types.insert(dst, rett); @@ -417,7 +417,7 @@ impl super::MirBuilder { match operator.as_str() { "-" => { let zero = crate::mir::builder::emission::constant::emit_integer(self, 0); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(MirInstruction::BinOp { dst, op: crate::mir::BinaryOp::Sub, @@ -428,7 +428,7 @@ impl super::MirBuilder { } "!" | "not" => { let f = crate::mir::builder::emission::constant::emit_bool(self, false); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); crate::mir::builder::emission::compare::emit_to( self, dst, @@ -440,7 +440,7 @@ impl super::MirBuilder { } "~" => { let all1 = crate::mir::builder::emission::constant::emit_integer(self, -1); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(MirInstruction::BinOp { dst, op: crate::mir::BinaryOp::BitXor, @@ -452,7 +452,7 @@ impl super::MirBuilder { _ => {} } } - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let mir_op = self.convert_unary_operator(operator)?; self.emit_instruction(MirInstruction::UnaryOp { dst, diff --git a/src/mir/builder/phi.rs b/src/mir/builder/phi.rs index cb235903..8ed303c7 100644 --- a/src/mir/builder/phi.rs +++ b/src/mir/builder/phi.rs @@ -88,7 +88,7 @@ impl MirBuilder { if let (Some(func), Some(cur_bb)) = (&self.current_function, self.current_block) { crate::mir::phi_core::common::debug_verify_phi_inputs(func, cur_bb, &inputs); } - let merged = self.value_gen.next(); + let merged = self.next_value_id(); if let (Some(func), Some(cur_bb)) = (self.current_function.as_mut(), self.current_block) { crate::mir::ssot::cf_common::insert_phi_at_head(func, cur_bb, merged, inputs); } else { @@ -123,7 +123,7 @@ impl MirBuilder { let assigned_var_else = else_ast_for_analysis .as_ref() .and_then(|a| crate::mir::phi_core::if_phi::extract_assigned_var(a)); - let result_val = self.value_gen.next(); + let result_val = self.next_value_id(); // フェーズM: no_phi_mode分岐削除（常にPHI命令を使用） diff --git a/src/mir/builder/rewrite/known.rs b/src/mir/builder/rewrite/known.rs index 2071805d..28526ec5 100644 --- a/src/mir/builder/rewrite/known.rs +++ b/src/mir/builder/rewrite/known.rs @@ -53,7 +53,7 @@ pub(crate) fn try_known_rewrite( call_args.push(object_value); call_args.append(&mut arg_values); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let dst = builder.value_gen.next(); + let dst = builder.next_value_id(); if let Err(e) = builder.emit_unified_call( Some(dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), @@ -98,7 +98,7 @@ pub(crate) fn try_known_rewrite_to_dst( call_args.push(object_value); call_args.append(&mut arg_values); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let actual_dst = want_dst.unwrap_or_else(|| builder.value_gen.next()); + let actual_dst = want_dst.unwrap_or_else(|| builder.next_value_id()); if let Err(e) = builder.emit_unified_call( Some(actual_dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), @@ -150,7 +150,7 @@ pub(crate) fn try_unique_suffix_rewrite( let arity_us = arg_values.len(); call_args.append(&mut arg_values); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let dst = builder.value_gen.next(); + let dst = builder.next_value_id(); if let Err(e) = builder.emit_unified_call( Some(dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), @@ -192,7 +192,7 @@ pub(crate) fn try_unique_suffix_rewrite_to_dst( let arity_us = arg_values.len(); call_args.append(&mut arg_values); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let actual_dst = want_dst.unwrap_or_else(|| builder.value_gen.next()); + let actual_dst = want_dst.unwrap_or_else(|| builder.next_value_id()); if let Err(e) = builder.emit_unified_call( Some(actual_dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), diff --git a/src/mir/builder/rewrite/special.rs b/src/mir/builder/rewrite/special.rs index 1e950f14..bce6ba50 100644 --- a/src/mir/builder/rewrite/special.rs +++ b/src/mir/builder/rewrite/special.rs @@ -35,7 +35,7 @@ pub(crate) fn try_early_str_like( let mut call_args = Vec::with_capacity(1); call_args.push(object_value); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let dst = builder.value_gen.next(); + let dst = builder.next_value_id(); if let Err(e) = builder.emit_unified_call( Some(dst), crate::mir::builder::builder_calls::CallTarget::Global(chosen.clone()), @@ -65,7 +65,7 @@ pub(crate) fn try_early_str_like( let mut call_args = Vec::with_capacity(1); call_args.push(object_value); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let dst = builder.value_gen.next(); + let dst = builder.next_value_id(); if let Err(e) = builder.emit_unified_call( Some(dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), @@ -89,7 +89,7 @@ pub(crate) fn try_early_str_like( let mut call_args = Vec::with_capacity(1); call_args.push(object_value); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let dst = builder.value_gen.next(); + let dst = builder.next_value_id(); if let Err(e) = builder.emit_unified_call( Some(dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), @@ -158,7 +158,7 @@ pub(crate) fn try_early_str_like_to_dst( let mut call_args = Vec::with_capacity(1); call_args.push(object_value); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let actual_dst = want_dst.unwrap_or_else(|| builder.value_gen.next()); + let actual_dst = want_dst.unwrap_or_else(|| builder.next_value_id()); if let Err(e) = builder.emit_unified_call( Some(actual_dst), crate::mir::builder::builder_calls::CallTarget::Global(chosen.clone()), @@ -189,7 +189,7 @@ pub(crate) fn try_early_str_like_to_dst( let mut call_args = Vec::with_capacity(1); call_args.push(object_value); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let actual_dst = want_dst.unwrap_or_else(|| builder.value_gen.next()); + let actual_dst = want_dst.unwrap_or_else(|| builder.next_value_id()); if let Err(e) = builder.emit_unified_call( Some(actual_dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), @@ -216,7 +216,7 @@ pub(crate) fn try_early_str_like_to_dst( let mut call_args = Vec::with_capacity(1); call_args.push(object_value); crate::mir::builder::ssa::local::finalize_args(builder, &mut call_args); - let actual_dst = want_dst.unwrap_or_else(|| builder.value_gen.next()); + let actual_dst = want_dst.unwrap_or_else(|| builder.next_value_id()); if let Err(e) = builder.emit_unified_call( Some(actual_dst), crate::mir::builder::builder_calls::CallTarget::Global(fname.clone()), diff --git a/src/mir/builder/schedule/block.rs b/src/mir/builder/schedule/block.rs index a9ee2248..801fccb5 100644 --- a/src/mir/builder/schedule/block.rs +++ b/src/mir/builder/schedule/block.rs @@ -12,7 +12,7 @@ impl BlockScheduleBox { if let Some(&cached) = builder.schedule_mat_map.get(&(bb, src)) { return Ok(cached); } - let dst = builder.value_gen.next(); + let dst = builder.next_value_id(); builder.insert_copy_after_phis(dst, src)?; builder.schedule_mat_map.insert((bb, src), dst); return Ok(dst); @@ -25,7 +25,7 @@ impl BlockScheduleBox { pub fn emit_before_call_copy(builder: &mut MirBuilder, src: ValueId) -> Result { // Prefer to reuse the after-phis materialized id for this src in this block let base = Self::ensure_after_phis_copy(builder, src)?; - let dst = builder.value_gen.next(); + let dst = builder.next_value_id(); builder.emit_instruction(MirInstruction::Copy { dst, src: base })?; // Propagate metadata to keep dst consistent with base crate::mir::builder::metadata::propagate::propagate(builder, base, dst); diff --git a/src/mir/builder/ssa/local.rs b/src/mir/builder/ssa/local.rs index b6a03a2b..1ef32a99 100644 --- a/src/mir/builder/ssa/local.rs +++ b/src/mir/builder/ssa/local.rs @@ -37,7 +37,7 @@ pub fn ensure(builder: &mut MirBuilder, v: ValueId, kind: LocalKind) -> ValueId if let Some(&loc) = builder.local_ssa_map.get(&key) { return loc; } - let loc = builder.value_gen.next(); + let loc = builder.next_value_id(); // Best-effort: errors are propagated by caller; we ignore here to keep helper infallible let _ = builder.emit_instruction(crate::mir::MirInstruction::Copy { dst: loc, src: v }); if std::env::var("NYASH_LOCAL_SSA_TRACE").ok().as_deref() == Some("1") { diff --git a/src/mir/builder/stmts.rs b/src/mir/builder/stmts.rs index deff9661..30c6e75a 100644 --- a/src/mir/builder/stmts.rs +++ b/src/mir/builder/stmts.rs @@ -15,7 +15,7 @@ impl super::MirBuilder { super::utils::builder_debug_log(&format!("extract_string_literal OK: {}", type_name)); let val = self.build_expression(call.arguments[0].clone())?; let ty = super::MirBuilder::parse_type_name_to_mir(&type_name); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let op = if call.name == "isType" { TypeOpKind::Check } else { TypeOpKind::Cast }; super::utils::builder_debug_log(&format!("emit TypeOp {:?} value={} dst= {}", op, val, dst)); self.emit_instruction(MirInstruction::TypeOp { dst, op, value: val, ty })?; @@ -46,7 +46,7 @@ impl super::MirBuilder { )); let val = self.build_expression(arguments[0].clone())?; let ty = super::MirBuilder::parse_type_name_to_mir(&type_name); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let op = if name == "isType" { TypeOpKind::Check } else { @@ -89,7 +89,7 @@ impl super::MirBuilder { )); let obj_val = self.build_expression(*object.clone())?; let ty = super::MirBuilder::parse_type_name_to_mir(&type_name); - let dst = self.value_gen.next(); + let dst = self.next_value_id(); let op = if method == "is" { TypeOpKind::Check } else { @@ -204,7 +204,7 @@ impl super::MirBuilder { self.variable_map.insert(var_name.clone(), var_id); last_value = Some(var_id); } - Ok(last_value.unwrap_or_else(|| self.value_gen.next())) + Ok(last_value.unwrap_or_else(|| self.next_value_id())) } // Return statement @@ -266,7 +266,7 @@ impl super::MirBuilder { for a in arguments.into_iter() { arg_vals.push(self.build_expression(a)?); } - let future_id = self.value_gen.next(); + let future_id = self.next_value_id(); self.emit_instruction(MirInstruction::ExternCall { dst: Some(future_id), iface_name: "env.future".to_string(), @@ -278,7 +278,7 @@ impl super::MirBuilder { return Ok(future_id); } let expression_value = self.build_expression(expression)?; - let future_id = self.value_gen.next(); + let future_id = self.next_value_id(); self.emit_instruction(MirInstruction::FutureNew { dst: future_id, value: expression_value, @@ -294,7 +294,7 @@ impl super::MirBuilder { ) -> Result { let future_value = self.build_expression(expression)?; self.emit_instruction(MirInstruction::Safepoint)?; - let result_id = self.value_gen.next(); + let result_id = self.next_value_id(); self.emit_instruction(MirInstruction::Await { dst: result_id, future: future_value, diff --git a/src/mir/builder/utils.rs b/src/mir/builder/utils.rs index c4bfe1f7..b71626d5 100644 --- a/src/mir/builder/utils.rs +++ b/src/mir/builder/utils.rs @@ -25,6 +25,19 @@ pub(super) fn builder_debug_log(msg: &str) { } impl super::MirBuilder { + // ---- Value ID allocation (function-local or module-global) ---- + /// Allocate a new ValueId in the appropriate context + /// - Inside function: uses function-local allocator + /// - Outside function: uses module-global allocator + #[inline] + pub(super) fn next_value_id(&mut self) -> super::ValueId { + if let Some(ref mut f) = self.current_function { + f.next_value_id() // Function context + } else { + self.value_gen.next() // Module context + } + } + // ---- LocalSSA convenience (readability helpers) ---- #[allow(dead_code)] #[inline] @@ -72,7 +85,7 @@ impl super::MirBuilder { for name in names.iter() { if !name.starts_with("__pin$") { continue; } if let Some(&src) = self.variable_map.get(name) { - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(super::MirInstruction::Copy { dst, src })?; crate::mir::builder::metadata::propagate::propagate(self, src, dst); self.variable_map.insert(name.clone(), dst); @@ -201,7 +214,7 @@ impl super::MirBuilder { value: super::ValueId, expected_type: String, ) -> Result { - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(super::MirInstruction::TypeOp { dst, op: TypeOpKind::Check, @@ -217,7 +230,7 @@ impl super::MirBuilder { value: super::ValueId, target_type: super::MirType, ) -> Result { - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(super::MirInstruction::TypeOp { dst, op: TypeOpKind::Cast, @@ -235,7 +248,7 @@ impl super::MirBuilder { if crate::config::env::mir_core13_pure() { return Ok(box_val); } - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(super::MirInstruction::WeakRef { dst, op: WeakRefOp::New, @@ -252,7 +265,7 @@ impl super::MirBuilder { if crate::config::env::mir_core13_pure() { return Ok(weak_ref); } - let dst = self.value_gen.next(); + let dst = self.next_value_id(); self.emit_instruction(super::MirInstruction::WeakRef { dst, op: WeakRefOp::Load, @@ -282,7 +295,12 @@ impl super::MirBuilder { pub(crate) fn pin_to_slot(&mut self, v: super::ValueId, hint: &str) -> Result { self.temp_slot_counter = self.temp_slot_counter.wrapping_add(1); let slot_name = format!("__pin${}${}", self.temp_slot_counter, hint); - let dst = self.value_gen.next(); + // Phase 25.1b: Use function-local ID allocator to avoid SSA verification failures + let dst = if let Some(ref mut f) = self.current_function { + f.next_value_id() // Function context: use local ID + } else { + self.value_gen.next() // Module context: use global ID + }; self.emit_instruction(super::MirInstruction::Copy { dst, src: v })?; if super::utils::builder_debug_enabled() || std::env::var("NYASH_PIN_TRACE").ok().as_deref() == Some("1") { super::utils::builder_debug_log(&format!("pin slot={} src={} dst={}", slot_name, v.0, dst.0)); @@ -295,7 +313,12 @@ impl super::MirBuilder { /// Ensure a value has a local definition in the current block by inserting a Copy. pub(crate) fn materialize_local(&mut self, v: super::ValueId) -> Result { - let dst = self.value_gen.next(); + // Phase 25.1b: Use function-local ID allocator to avoid SSA verification failures + let dst = if let Some(ref mut f) = self.current_function { + f.next_value_id() // Function context: use local ID + } else { + self.value_gen.next() // Module context: use global ID + }; self.emit_instruction(super::MirInstruction::Copy { dst, src: v })?; // Propagate metadata (type/origin) from source to the new local copy crate::mir::builder::metadata::propagate::propagate(self, v, dst); diff --git a/src/runner/child_env.rs b/src/runner/child_env.rs index e216f72d..b0cc2185 100644 --- a/src/runner/child_env.rs +++ b/src/runner/child_env.rs @@ -52,3 +52,20 @@ pub fn apply_core_wrapper_env(cmd: &mut std::process::Command) { cmd.env("NYASH_PARSER_ALLOW_SEMICOLON", val); } } + +/// Apply environment for selfhost/Ny compiler processes (ParserBox/EmitterBox/MirBuilderBox). +/// - Inherits core restrictions from apply_core_wrapper_env() +/// - Re-enables `using` file resolution for module loading (lang.compiler.parser.box, etc.) +/// - Keeps plugin/toml restrictions to avoid side effects +pub fn apply_selfhost_compiler_env(cmd: &mut std::process::Command) { + // Phase 25.1b: Start with core wrapper restrictions + apply_core_wrapper_env(cmd); + + // Phase 25.1b: Re-enable file-based using for selfhost compiler module resolution + // Selfhost compiler uses `using lang.compiler.parser.box`, which requires file resolution + // (nyash.toml [modules] mapping is primary, but file fallback ensures robustness) + cmd.env("HAKO_ALLOW_USING_FILE", "1"); + + // Note: NYASH_USING_AST stays 0 (AST-based using not needed for basic module resolution) + // Note: NYASH_DISABLE_PLUGINS stays 1 (avoid plugin side effects in nested compilation) +} diff --git a/src/runner/modes/common_util/selfhost/child.rs b/src/runner/modes/common_util/selfhost/child.rs index 2c6b48f8..e171126f 100644 --- a/src/runner/modes/common_util/selfhost/child.rs +++ b/src/runner/modes/common_util/selfhost/child.rs @@ -17,8 +17,8 @@ pub fn run_ny_program_capture_json( ) -> Option { use std::process::Command; let mut cmd = Command::new(exe); - // Apply consistent child env to avoid plugin/using drift - crate::runner::child_env::apply_core_wrapper_env(&mut cmd); + // Phase 25.1b: Use selfhost compiler env (enables using/file resolution for compiler.hako) + crate::runner::child_env::apply_selfhost_compiler_env(&mut cmd); cmd.arg("--backend").arg("vm").arg(program); for a in extra_args { cmd.arg(a); diff --git a/src/runner/selfhost.rs b/src/runner/selfhost.rs index 1a0b334a..088b0dd6 100644 --- a/src/runner/selfhost.rs +++ b/src/runner/selfhost.rs @@ -14,6 +14,32 @@ impl NyashRunner { /// Selfhost (Ny -> JSON v0) pipeline: EXE/VM/Python フォールバック含む pub(crate) fn try_run_selfhost_pipeline(&self, filename: &str) -> bool { use std::io::Write; + + // Phase 25.1b: guard selfhost pipeline to Ny-only sources. + // `.hako` / other extensionsは Stage‑B / JSON v0 bridge 側の責務なので、 + // ここでは Ny/Nyash 拡張子以外は即座にスキップする。 + let path = std::path::Path::new(filename); + if let Some(ext) = path.extension().and_then(|s| s.to_str()) { + match ext { + "ny" | "nyash" => { /* continue */ } + _ => { + crate::cli_v!( + "[ny-compiler] skip selfhost pipeline for non-Ny source: {} (ext={})", + filename, + ext + ); + return false; + } + } + } else { + // No extension: treat as non-Ny for safety + crate::cli_v!( + "[ny-compiler] skip selfhost pipeline for source without extension: {}", + filename + ); + return false; + } + // Read input source let code = match fs::read_to_string(filename) { Ok(c) => c, @@ -220,18 +246,20 @@ impl NyashRunner { } } - // Python MVP-first: prefer the lightweight harness to produce JSON v0 (unless skipped) - if std::env::var("NYASH_NY_COMPILER_SKIP_PY").ok().as_deref() != Some("1") { + // Python MVP (optional): lightweight harness to produce JSON v0. + // Phase 25.1b: default OFF（NYASH_NY_COMPILER_USE_PY=1 のときだけ有効）。 + if std::env::var("NYASH_NY_COMPILER_USE_PY").ok().as_deref() == Some("1") { if let Ok(py3) = which::which("python3") { let py = std::path::Path::new("tools/ny_parser_mvp.py"); if py.exists() { let mut cmd = std::process::Command::new(&py3); - crate::runner::child_env::apply_core_wrapper_env(&mut cmd); + // Phase 25.1b: Use selfhost compiler env for consistency + crate::runner::child_env::apply_selfhost_compiler_env(&mut cmd); cmd.arg(py).arg(&tmp_path); let timeout_ms: u64 = std::env::var("NYASH_NY_COMPILER_TIMEOUT_MS") .ok() .and_then(|s| s.parse().ok()) - .unwrap_or(2000); + .unwrap_or(60000); // Phase 25.1b: Increased to 60000ms (60s) for consistency let out = match super::modes::common_util::io::spawn_with_timeout(cmd, timeout_ms) { Ok(o) => o, Err(e) => { eprintln!("[ny-compiler] python harness failed: {}", e); return false; } @@ -370,55 +398,14 @@ impl NyashRunner { } // Fallback: inline VM run (embed source into a tiny wrapper that prints JSON) - // This avoids CLI arg forwarding complexity and does not require FileBox. - let mut json_line = String::new(); - { - // Escape source for embedding as string literal - let mut esc = String::with_capacity(code_ref.len()); - for ch in code_ref.chars() { - match ch { - '\\' => esc.push_str("\\\\"), - '"' => esc.push_str("\\\""), - '\n' => esc.push_str("\n"), - '\r' => esc.push_str(""), - _ => esc.push(ch), - } - } - let inline_path = std::path::Path::new("tmp").join("inline_selfhost_emit.hako"); - let inline_code = format!( - "include \"apps/selfhost/compiler/boxes/parser_box.hako\"\ninclude \"apps/selfhost/compiler/boxes/emitter_box.hako\"\nstatic box Main {{\n main(args) {{\n local s = \"{}\"\n local p = new ParserBox()\n p.stage3_enable(1)\n local json = p.parse_program2(s)\n local e = new EmitterBox()\n json = e.emit_program(json, \"[]\")\n print(json)\n return 0\n }}\n}}\n", - esc - ); - if let Err(e) = std::fs::write(&inline_path, inline_code) { - eprintln!("[ny-compiler] write inline failed: {}", e); - return false; - } - let exe = std::env::current_exe() - .unwrap_or_else(|_| std::path::PathBuf::from("target/release/nyash")); - let mut cmd = std::process::Command::new(exe); - cmd.arg("--backend").arg("vm").arg(&inline_path); - crate::runner::child_env::apply_core_wrapper_env(&mut cmd); - let timeout_ms: u64 = std::env::var("NYASH_NY_COMPILER_TIMEOUT_MS") - .ok() - .and_then(|s| s.parse().ok()) - .unwrap_or(2000); - let out = match super::modes::common_util::io::spawn_with_timeout(cmd, timeout_ms) { - Ok(o) => o, - Err(e) => { eprintln!("[ny-compiler] spawn inline vm failed: {}", e); return false; } - }; - if out.timed_out { - let head = String::from_utf8_lossy(&out.stdout).chars().take(200).collect::(); - eprintln!("[ny-compiler] inline timeout after {} ms; stdout(head)='{}'", timeout_ms, head.replace('\n', "\\n")); - } - let stdout = String::from_utf8_lossy(&out.stdout).to_string(); - if let Some(line) = crate::runner::modes::common_util::selfhost::json::first_json_v0_line(&stdout) { - json_line = line; - } - } - if json_line.is_empty() { - return false; - } - match super::json_v0_bridge::parse_json_v0_to_module(&json_line) { + // Phase 25.1b: この経路は Ny selfhost 実験用だったが、現在は不安定かつ .hako 側 selfhost builder の + // デバッグを阻害するため、既定で無効化する。Ny selfhost が必要な場合は別の .sh ベースの + // パイプライン（tools/ny_selfhost_inline.sh など）を使う想定とし、ここでは常に Rust 既定 + // パスへフォールバックする。 + crate::cli_v!("[ny-compiler] inline selfhost pipeline disabled (Phase 25.1b); falling back to default path"); + return false; + + match super::json_v0_bridge::parse_json_v0_to_module("") { Ok(module) => { if crate::config::env::cli_verbose() { if crate::config::env::cli_verbose() { diff --git a/src/runtime/extern_registry.rs b/src/runtime/extern_registry.rs index edf3369d..c9bc9d64 100644 --- a/src/runtime/extern_registry.rs +++ b/src/runtime/extern_registry.rs @@ -147,6 +147,13 @@ static EXTERNS: Lazy> = Lazy::new(|| { max_arity: 255, slot: Some(50), }, + ExternSpec { + iface: "env.box_introspect", + method: "kind", + min_arity: 1, + max_arity: 1, + slot: Some(51), + }, // basic env access ExternSpec { iface: "env", diff --git a/src/runtime/plugin_loader_v2/enabled/mod.rs b/src/runtime/plugin_loader_v2/enabled/mod.rs index effdbcfe..2614c499 100644 --- a/src/runtime/plugin_loader_v2/enabled/mod.rs +++ b/src/runtime/plugin_loader_v2/enabled/mod.rs @@ -14,6 +14,7 @@ pub use types::{ construct_plugin_box, make_plugin_box_v2, NyashTypeBoxFfi, PluginBoxMetadata, PluginBoxV2, PluginHandleInner, }; +pub use extern_functions::handle_box_introspect; pub fn metadata_for_type_id(type_id: u32) -> Option { let loader = get_global_loader_v2(); diff --git a/tools/hakorune_emit_mir.sh b/tools/hakorune_emit_mir.sh index 61744bb7..0a50145f 100644 --- a/tools/hakorune_emit_mir.sh +++ b/tools/hakorune_emit_mir.sh @@ -39,6 +39,11 @@ if [ -z "${NYASH_BIN:-}" ]; then fi fi +# Allow legacy 'nyash' binary when invoked via this helper (Stage0 bootstrap). +# This keeps Stage‑B / MirBuilder scripts working while the main CLI migrates to 'hakorune'. +export HAKO_ALLOW_NYASH="${HAKO_ALLOW_NYASH:-1}" +export NYASH_ALLOW_NYASH="${NYASH_ALLOW_NYASH:-1}" + # Store CODE in temp file to avoid subshell expansion issues CODE_TMP=$(mktemp --suffix=.hako) trap 'rm -f "$CODE_TMP" || true' EXIT @@ -296,6 +301,37 @@ extract_program_json() { return 1 } +# Helper: surface common Stage‑B / parser / using errors in a concise, friendly way. +diagnose_stageb_failure() { + local raw="$1" + # Stage‑3 local keyword misconfig + if printf '%s\n' "$raw" | grep -q "Undefined variable: local"; then + echo "[stageb/diagnose] Undefined variable: local" >&2 + echo "[stageb/hint] 'local' は Stage‑3 キーワードだよ。" >&2 + echo "[stageb/hint] NYASH_PARSER_STAGE3=1 HAKO_PARSER_STAGE3=1 を有効にするか、tools/hakorune_emit_mir.sh 経由で実行してね。" >&2 + fi + # Generic parse error + if printf '%s\n' "$raw" | grep -q "Parse error"; then + echo "[stageb/diagnose] Parse error detected in Stage‑B output." >&2 + echo "[stageb/hint] HAKO_SELFHOST_TRACE=1 を立ててもう一度実行すると、最初の 200 文字が表示されるよ。" >&2 + fi + # VM execution errors from Stage‑B itself (MIR builder / verifier side) + if printf '%s\n' "$raw" | grep -q "Invalid value: use of undefined value"; then + echo "[stageb/diagnose] VM reported 'use of undefined value' during Stage‑B execution." >&2 + echo "[stageb/hint] Stage‑B が生成した MIR に未定義レジスタ (%0 など) が含まれている可能性があるよ。" >&2 + echo "[stageb/hint] 詳細を確認するには NYASH_VM_VERIFY_MIR=1 を立てて compiler_stageb.hako を直接実行してね。" >&2 + echo "[stageb/hint] 代表的な原因と掘り先は docs/private/roadmap/phases/phase-20.33/DEBUG.md を参照してね (Stage1UsingResolverBox / FuncScannerBox 周り)。" >&2 + fi + # Using resolver issues (Stage‑B side) + local using_lines + using_lines=$(printf '%s\n' "$raw" | grep -E "\[using\] not found: " | sort -u || true) + if [ -n "$using_lines" ]; then + echo "[stageb/diagnose] Missing using modules detected (Stage‑B):" >&2 + echo "$using_lines" >&2 + echo "[stageb/hint] nyash.toml の [modules] に該当 Box を追加するか、HAKO_STAGEB_MODULES_LIST / HAKO_STAGEB_APPLY_USINGS を確認してね。" >&2 + fi +} + set +e if [ "${HAKO_SELFHOST_TRACE:-0}" = "1" ]; then code_len=$(wc -c < "$CODE_TMP" | tr -d ' ') @@ -343,6 +379,8 @@ set -e # If Stage-B fails, skip to direct MIR emit paths (provider/legacy) if [ $rc -ne 0 ] || [ -z "$PROG_JSON_OUT" ]; then + # Diagnose common Stage‑B errors before falling back + diagnose_stageb_failure "$PROG_JSON_RAW" # Stage-B not available - fall back to legacy CLI path directly # Skip the intermediate Program(JSON) step and emit MIR directly if HAKO_STAGEB_FUNC_SCAN="${HAKO_STAGEB_FUNC_SCAN:-1}" \ @@ -360,7 +398,8 @@ fi # Quick validation for Program(JSON v0) if ! printf '%s' "$PROG_JSON_OUT" | grep -q '"kind"\s*:\s*"Program"'; then - # Invalid Program JSON - fall back to direct emit + # Invalid Program JSON - fall back to direct emit（事前に簡単な診断を出す） + diagnose_stageb_failure "$PROG_JSON_RAW" if HAKO_STAGEB_FUNC_SCAN="${HAKO_STAGEB_FUNC_SCAN:-1}" \ HAKO_MIR_BUILDER_FUNCS="${HAKO_MIR_BUILDER_FUNCS:-}" \ HAKO_MIR_BUILDER_CALL_RESOLVE="${HAKO_MIR_BUILDER_CALL_RESOLVE:-}" \ @@ -629,6 +668,7 @@ HCODE fi (cd "$ROOT" && \ + HAKO_SELFHOST_NO_DELEGATE=1 \ HAKO_MIR_BUILDER_INTERNAL=1 HAKO_MIR_BUILDER_REGISTRY=1 \ HAKO_MIR_BUILDER_TRACE="${HAKO_SELFHOST_TRACE:-}" \ HAKO_MIR_BUILDER_LOOP_JSONFRAG="${HAKO_MIR_BUILDER_LOOP_JSONFRAG:-}" \ @@ -643,6 +683,9 @@ HCODE NYASH_PARSER_STAGE3=1 HAKO_PARSER_STAGE3=1 NYASH_PARSER_ALLOW_SEMICOLON=1 \ NYASH_USE_NY_COMPILER=0 HAKO_USE_NY_COMPILER=0 NYASH_DISABLE_NY_COMPILER=1 HAKO_DISABLE_NY_COMPILER=1 \ NYASH_MACRO_DISABLE=1 HAKO_MACRO_DISABLE=1 \ + # Builder 実行時は Step budget を既定で「無制限（0）」にしておく（大きな Program(JSON) でも上限で落とさない）。 + # 無限ループ疑いの診断時は HAKO_VM_MAX_STEPS/NYASH_VM_MAX_STEPS を明示上書きして使う想定。 + HAKO_VM_MAX_STEPS="${HAKO_VM_MAX_STEPS:-0}" NYASH_VM_MAX_STEPS="${NYASH_VM_MAX_STEPS:-0}" \ HAKO_BUILDER_PROGRAM_JSON="$prog_json" \ NYASH_VM_DUMP_MERGED_HAKO="${NYASH_VM_DUMP_MERGED_HAKO:-${HAKO_SELFHOST_DUMP_MERGED_HAKO:-0}}" \ NYASH_VM_DUMP_MERGED_HAKO_PATH="${NYASH_VM_DUMP_MERGED_HAKO_PATH:-${HAKO_SELFHOST_DUMP_MERGED_HAKO_PATH:-}}" \ @@ -716,6 +759,18 @@ HCODE local mir mir=$(awk '/\[MIR_OUT_BEGIN\]/{flag=1;next}/\[MIR_OUT_END\]/{flag=0}flag' "$tmp_stdout") if [ -z "$mir" ]; then return 1; fi + # Surface key builder tags (multi-carrier detectionなど) when trace is enabled, + # so that v2 smokes can reliably grep them without生 stdout 全量を流す必要がない。 + if [ "${HAKO_SELFHOST_TRACE:-0}" = "1" ]; then + if grep -q "\[mirbuilder/internal/loop:multi_carrier:" "$tmp_stdout" 2>/dev/null; then + echo "[builder/selfhost-first:trace:multi_carrier] detected" >&2 + grep "\[mirbuilder/internal/loop:multi_carrier:" "$tmp_stdout" >&2 || true + fi + if grep -q "\[funcs/basic:loop.multi_carrier\]" "$tmp_stdout" 2>/dev/null; then + echo "[builder/selfhost-first:trace:funcs:loop.multi_carrier]" >&2 + grep "\[funcs/basic:loop.multi_carrier\]" "$tmp_stdout" >&2 || true + fi + fi printf '%s' "$mir" > "$out_path" echo "[OK] MIR JSON written (selfhost-first): $out_path" return 0 @@ -883,10 +938,10 @@ if [ "${HAKO_SELFHOST_BUILDER_FIRST:-0}" = "1" ]; then if try_selfhost_builder "$PROG_JSON_OUT" "$OUT"; then exit 0 fi - if [ "${HAKO_SELFHOST_NO_DELEGATE:-0}" = "1" ]; then - echo "[FAIL] selfhost-first failed and delegate disabled" >&2 - exit 1 - fi + # Phase 25.1b: selfhost-first モードでは MirBuilder のフォールバックは禁止。 + # selfhost builder が失敗した時点で非0終了とし、provider 経路には委譲しない。 + echo "[FAIL] selfhost-first failed (MirBuilder) and delegate is disabled in HAKO_SELFHOST_BUILDER_FIRST=1 mode" >&2 + exit 1 fi # Dev: force JsonFrag minimal loop even on provider-first path diff --git a/tools/ny_selfhost_inline.sh b/tools/ny_selfhost_inline.sh new file mode 100644 index 00000000..8b37a490 --- /dev/null +++ b/tools/ny_selfhost_inline.sh @@ -0,0 +1,86 @@ +#!/usr/bin/env bash +# ny_selfhost_inline.sh — Ny selfhost inline parser/JSON v0 debug helper +# +# Purpose: +# - Minimal, shell-based equivalent of the inline Ny selfhost pipeline used in src/runner/selfhost.rs. +# - Reads a Nyash/Ny source file, runs ParserBox.parse_program2 + EmitterBox.emit_program +# via a tiny Hako harness, and prints Program(JSON v0) to stdout. +# - Intended for debugging only; not wired into the main CLI or build scripts. +# +# Usage: +# tools/ny_selfhost_inline.sh [nyash_binary] +# - : Nyash/Ny source file to parse. +# - nyash_binary: optional path to hakorune/nyash binary (default: target/release/hakorune or nyash). +# +# Notes: +# - Forces Stage-3 parser ON for the child (NYASH_PARSER_STAGE3=1/HAKO_PARSER_STAGE3=1). +# - Enables using resolver with file-based using (dev profile) so that lang.compiler.* modules can be found. +# - Does NOT perform Stage-0 prelude text merge or preexpand_at_local; it feeds the raw source to ParserBox. + +set -euo pipefail + +if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then + echo "Usage: $0 [nyash_binary]" >&2 + exit 2 +fi + +SRC="$1" +BIN="${2:-}" + +if [ ! -f "$SRC" ]; then + echo "[ny-selfhost-inline] source not found: $SRC" >&2 + exit 1 +fi + +ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" + +if [ -z "$BIN" ]; then + if [ -x "$ROOT/target/release/hakorune" ]; then + BIN="$ROOT/target/release/hakorune" + else + BIN="$ROOT/target/release/nyash" + fi +fi + +if [ ! -x "$BIN" ]; then + echo "[ny-selfhost-inline] nyash/hakorune binary not found: $BIN" >&2 + exit 1 +fi + +HARNESS="$(mktemp --suffix=.hako)" +trap 'rm -f "$HARNESS" || true' EXIT + +cat >"$HARNESS" <<'HAKO' +using lang.compiler.parser.box as ParserBox +using lang.compiler.stage1.emitter_box as EmitterBox + +static box Main { + method main(args){ + local src = env.get("NYASH_INLINE_SRC") + if src == null { + print("[ny-selfhost-inline] NYASH_INLINE_SRC is null") + return 1 + } + local s = "" + src + local p = new ParserBox() + p.stage3_enable(1) + print("[ny-selfhost-inline] entry len=" + ("" + s.length())) + local json = p.parse_program2(s) + local e = new EmitterBox() + json = e.emit_program(json, "[]") + print(json) + return 0 + } +} +HAKO + +# Feed raw source via env to avoid huge string literal escaping on the shell side. +SRC_CONTENT="$(cat "$SRC")" + +NYASH_INLINE_SRC="$SRC_CONTENT" \ +NYASH_JSON_ONLY=1 \ +NYASH_PARSER_STAGE3=1 HAKO_PARSER_STAGE3=1 NYASH_PARSER_ALLOW_SEMICOLON=1 \ +NYASH_ENABLE_USING=1 HAKO_ENABLE_USING=1 \ +NYASH_ALLOW_USING_FILE=1 HAKO_ALLOW_USING_FILE=1 \ +"$BIN" --backend vm "$HARNESS" + diff --git a/tools/selfhost/examples/hako_llvm_selfhost_driver.hako b/tools/selfhost/examples/hako_llvm_selfhost_driver.hako index e45f6807..02eaac76 100644 --- a/tools/selfhost/examples/hako_llvm_selfhost_driver.hako +++ b/tools/selfhost/examples/hako_llvm_selfhost_driver.hako @@ -5,6 +5,7 @@ // Prints the exe path to stdout. using selfhost.vm.helpers.mir_call_v1_handler as MirCallV1HandlerBox // not required but keeps linker alive +using selfhost.shared.host_bridge.codegen_bridge as CodegenBridgeBox static box Main { method main(args) { @@ -14,11 +15,11 @@ static box Main { if exe_out == null { exe_out = "/tmp/hako_selfhost_exe" } // emit object local a = new ArrayBox(); a.push(j) - local obj = hostbridge.extern_invoke("env.codegen", "emit_object", a) + local obj = CodegenBridgeBox.emit_object_args(a) if obj == null { print("[ERR] emit_object failed"); return 2 } // link exe local b = new ArrayBox(); b.push(obj); b.push(exe_out) - local exe = hostbridge.extern_invoke("env.codegen", "link_object", b) + local exe = CodegenBridgeBox.link_object_args(b) if exe == null { print("[ERR] link_object failed"); return 3 } print("" + exe) return 0 diff --git a/tools/smokes/v2/profiles/quick/core/phase251/selfhost_mir_loopform_multi_carrier_vm.sh b/tools/smokes/v2/profiles/quick/core/phase251/selfhost_mir_loopform_multi_carrier_vm.sh new file mode 100644 index 00000000..b5a3f333 --- /dev/null +++ b/tools/smokes/v2/profiles/quick/core/phase251/selfhost_mir_loopform_multi_carrier_vm.sh @@ -0,0 +1,102 @@ +#!/usr/bin/env bash +# selfhost_mir_loopform_multi_carrier_vm.sh +# - Canary for Phase 25.1b multi-carrier LoopForm (fibonacci-style). +# - Ensures LowerLoopMultiCarrierBox + LoopFormBox.build2(mode="multi_count") +# can emit MIR(JSON) for a simple fibonacci-like loop via selfhost builder. + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +ROOT_DIR="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || (cd "$SCRIPT_DIR/../../../../../../.." && pwd))" + +TEST_HAKO="$(mktemp --suffix .hako)" +OUT_MIR="$(mktemp --suffix .json)" +LOG_OUT="$(mktemp --suffix .log)" +trap 'rm -f "$TEST_HAKO" "$OUT_MIR" "$LOG_OUT" || true' EXIT + +# Fibonacci-style loop: i=0; a=0; b=1; loop(i"$TEST_HAKO" <<'HAKO' +static box TestBox { + method fib(n) { + local i = 0 + local a = 0 + local b = 1 + loop(i < n) { + local t = a + b + a = b + b = t + i = i + 1 + } + return b + } +} + +static box Main { + method main(args) { + local t = new TestBox() + return t.fib(6) + } +} +HAKO + +set +e +HAKO_SELFHOST_BUILDER_FIRST=1 \ +HAKO_MIR_BUILDER_FUNCS=1 \ +HAKO_SELFHOST_TRACE=1 \ +HAKO_MIR_BUILDER_TRACE=1 \ +HAKO_SILENT_TAGS=0 \ +NYASH_JSON_ONLY=1 \ +bash "$ROOT_DIR/tools/hakorune_emit_mir.sh" "$TEST_HAKO" "$OUT_MIR" >"$LOG_OUT" 2>&1 +rc=$? +set -e + +# If selfhost builder failed due to missing using modules and provider delegate +# wrote MIR instead, treat as SKIP（環境が揃ってから本格確認する）。 +if [ $rc -ne 0 ] || [ ! -s "$OUT_MIR" ]; then + if grep -q "[builder/selfhost-first:diagnose] Missing using modules detected" "$LOG_OUT" 2>/dev/null; then + echo "[SKIP] selfhost_mir_loopform_multi_carrier_vm (selfhost builder missing using modules; provider delegate used)" >&2 + exit 0 + fi + echo "[FAIL] selfhost_mir_loopform_multi_carrier_vm (MIR generation failed rc=$rc)" >&2 + echo "=== LOG OUTPUT ===" >&2 + sed -n '1,120p' "$LOG_OUT" >&2 || true + exit 1 +fi + +# If builder は失敗し、provider delegate が MIR を書いただけなら、まだ本命経路が +# 有効になっていないので SKIP 扱いにする。 +if grep -q "[builder/selfhost-first:diagnose] Missing using modules detected" "$LOG_OUT" 2>/dev/null \ + || grep -q "delegate:provider" "$LOG_OUT" 2>/dev/null; then + echo "[SKIP] selfhost_mir_loopform_multi_carrier_vm (selfhost builder not active yet; provider delegate in use)" >&2 + exit 0 +fi + +# Check that multi-carrier lower was actually used +# If Stage‑B がまだ loop を含まない Program(JSON) しか出していない場合は、 +# multi-carrier lower が動けないので SKIP 扱いにする（将来 Stage‑B 側が +# defs/loop を含むようになったときに PASS へ昇格させる）。 +if ! grep -q "\[mirbuilder/internal/loop:multi_carrier:detected" "$LOG_OUT"; then + if grep -q "tokens=Loop:0,Compare:0" "$LOG_OUT" 2>/dev/null; then + echo "[SKIP] selfhost_mir_loopform_multi_carrier_vm (Stage-B Program JSON has no Loop yet)" >&2 + exit 0 + fi + echo "[FAIL] selfhost_mir_loopform_multi_carrier_vm (no multi_carrier detection tag)" >&2 + sed -n '1,120p' "$LOG_OUT" >&2 || true + exit 1 +fi + +if ! grep -q "\[funcs/basic:loop.multi_carrier\]" "$LOG_OUT"; then + echo "[FAIL] selfhost_mir_loopform_multi_carrier_vm (no [funcs/basic:loop.multi_carrier] tag)" >&2 + sed -n '1,120p' "$LOG_OUT" >&2 || true + exit 1 +fi + +# Ensure TestBox.fib/1 function exists in MIR +if ! grep -q '"name":"TestBox.fib/1"' "$OUT_MIR"; then + echo "[FAIL] selfhost_mir_loopform_multi_carrier_vm (TestBox.fib/1 not present in MIR)" >&2 + cat "$OUT_MIR" >&2 + exit 1 +fi + +echo "[PASS] selfhost_mir_loopform_multi_carrier_vm (multi-carrier LoopForm used for TestBox.fib/1)" +exit 0 diff --git a/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_canary_vm.sh b/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_canary_vm.sh index f7678a53..24ad58e9 100644 --- a/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_canary_vm.sh +++ b/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_canary_vm.sh @@ -6,7 +6,7 @@ set -euo pipefail SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" -ROOT_DIR="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || cd "$SCRIPT_DIR/../../../../../../.." && pwd)" +ROOT_DIR="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || (cd "$SCRIPT_DIR/../../../../../../.." && pwd))" if [ ! -f "$ROOT_DIR/lang/src/runner/launcher.hako" ]; then echo "[SKIP] stage1_launcher_program_to_mir_canary_vm (launcher.hako missing)" @@ -36,4 +36,3 @@ fi echo "[PASS] stage1_launcher_program_to_mir_canary_vm" exit 0 - diff --git a/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_selfhost_vm.sh b/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_selfhost_vm.sh index 60917030..2e94882e 100644 --- a/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_selfhost_vm.sh +++ b/tools/smokes/v2/profiles/quick/core/phase251/stage1_launcher_program_to_mir_selfhost_vm.sh @@ -7,7 +7,7 @@ set -euo pipefail SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" -ROOT_DIR="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || cd "$SCRIPT_DIR/../../../../../../.." && pwd)" +ROOT_DIR="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || (cd "$SCRIPT_DIR/../../../../../../.." && pwd))" if [ ! -f "$ROOT_DIR/lang/src/runner/launcher.hako" ]; then echo "[SKIP] stage1_launcher_program_to_mir_selfhost_vm (launcher.hako missing)" @@ -52,4 +52,3 @@ fi echo "[PASS] stage1_launcher_program_to_mir_selfhost_vm" exit 0 - diff --git a/tools/smokes/v2/profiles/quick/core/phase251/stageb_fib_program_defs_canary_vm.sh b/tools/smokes/v2/profiles/quick/core/phase251/stageb_fib_program_defs_canary_vm.sh new file mode 100644 index 00000000..e99ec4b3 --- /dev/null +++ b/tools/smokes/v2/profiles/quick/core/phase251/stageb_fib_program_defs_canary_vm.sh @@ -0,0 +1,189 @@ +#!/usr/bin/env bash +# stageb_fib_program_defs_canary_vm.sh +# - Canary for Stage‑B defs + Loop 出力確認（fib 風 multi-carrier 用の下準備）。 +# - 目的: +# - compiler_stageb.hako が FuncScannerBox を通じて TestBox.fib を defs に載せているか。 +# - defs 内の body に Loop ノードが含まれているか（後続の LoopForm lower の前提確認）。 + +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +ROOT_DIR="$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null || (cd "$SCRIPT_DIR/../../../../../../.." && pwd))" + +source "$ROOT_DIR/tools/smokes/v2/lib/test_runner.sh" || true +require_env || { echo "[SKIP] env not ready"; exit 0; } + +if ! command -v jq >/dev/null 2>&1; then + echo "[SKIP] stageb_fib_program_defs_canary_vm.sh (jq not available)" >&2 + exit 0 +fi + +TMP_HAKO="$(mktemp --suffix .hako)" +OUT_JSON="$(mktemp --suffix .json)" +trap 'rm -f "$TMP_HAKO" "$OUT_JSON" || true' EXIT + +cat >"$TMP_HAKO" <<'HAKO' +static box TestBox { + method fib(n) { + local i = 0 + local a = 0 + local b = 1 + loop(i < n) { + local t = a + b + a = b + b = t + i = i + 1 + } + return b + } +} + +static box Main { + method main(args) { + local t = new TestBox() + return t.fib(6) + } +} +HAKO + +# Stage‑B: emit Program(JSON v0) with defs +set +e +OUT_RAW=$( + cd "$ROOT_DIR" && \ + NYASH_JSON_ONLY=1 NYASH_DISABLE_NY_COMPILER=1 HAKO_DISABLE_NY_COMPILER=1 \ + NYASH_PARSER_STAGE3=1 HAKO_PARSER_STAGE3=1 NYASH_PARSER_ALLOW_SEMICOLON=1 \ + NYASH_ENABLE_USING=1 HAKO_ENABLE_USING=1 HAKO_STAGEB_FUNC_SCAN=1 \ + HAKO_STAGEB_APPLY_USINGS=0 \ + "$NYASH_BIN" --backend vm "$ROOT_DIR/lang/src/compiler/entry/compiler_stageb.hako" -- --source "$(cat "$TMP_HAKO")" 2>&1 +) +rc=$? +set -e + +if [ $rc -ne 0 ]; then + echo "[FAIL] stageb_fib_program_defs_canary_vm (Stage‑B rc=$rc)" >&2 + printf '%s\n' "$OUT_RAW" | head -n 40 >&2 || true + exit 1 +fi + +# 抽出: Program(JSON) 部分だけを抽出（emit_mir.sh と同じ Python ロジックを簡略化） +extract_prog() { + python3 - <<'PYEOF' +import sys +text = sys.stdin.read() +start = text.find('"kind":"Program"') +if start < 0: + sys.exit(1) +pos = start +depth = 0 +while pos >= 0: + if text[pos] == '{': + depth += 1 + if depth == 1: + break + elif text[pos] == '}': + depth -= 1 + pos -= 1 +if pos < 0: + sys.exit(1) +obj_start = pos +depth = 0 +in_str = False +esc = False +i = obj_start +while i < len(text): + ch = text[i] + if esc: + esc = False + elif in_str: + if ch == '\\\\': + esc = True + elif ch == '"': + in_str = False + else: + if ch == '"': + in_str = True + elif ch == '{': + depth += 1 + elif ch == '}': + depth -= 1 + if depth == 0: + print(text[obj_start:i+1]) + sys.exit(0) + i += 1 +sys.exit(1) +PYEOF +} + +RAW_DUMP=$(mktemp --suffix .stageb.raw) +printf '%s\n' "$OUT_RAW" > "$RAW_DUMP" +if ! python3 - "$RAW_DUMP" <<'PYEOF' >"$OUT_JSON" 2>/dev/null; then +import sys +from pathlib import Path +dump_path = Path(sys.argv[1]) +text = dump_path.read_text() +start = text.find('"kind":"Program"') +if start < 0: + sys.exit(1) +pos = start +while pos >= 0 and text[pos] != '{': + pos -= 1 +if pos < 0: + sys.exit(1) +depth = 0 +in_str = False +esc = False +i = pos +while i < len(text): + ch = text[i] + if esc: + esc = False + elif in_str: + if ch == '\\\\': + esc = True + elif ch == '"': + in_str = False + else: + if ch == '"': + in_str = True + elif ch == '{': + depth += 1 + elif ch == '}': + depth -= 1 + if depth == 0: + print(text[pos:i+1]) + sys.exit(0) + i += 1 +sys.exit(1) +PYEOF + echo "[FAIL] stageb_fib_program_defs_canary_vm (failed to extract Program JSON)" >&2 + printf '%s\n' "$OUT_RAW" | head -n 40 >&2 || true + rm -f "$RAW_DUMP" || true + exit 1 +fi +rm -f "$RAW_DUMP" || true + +# 1) Program.kind == "Program" +if ! jq -e '.kind == "Program"' "$OUT_JSON" >/dev/null 2>&1; then + echo "[FAIL] stageb_fib_program_defs_canary_vm (kind != Program)" >&2 + cat "$OUT_JSON" >&2 + exit 1 +fi + +# 2) defs に TestBox.fib が含まれているか +has_fib=$(jq '.defs // [] | any(.box=="TestBox" and .name=="fib")' "$OUT_JSON") +if [ "$has_fib" != "true" ]; then + echo "[FAIL] stageb_fib_program_defs_canary_vm (defs に TestBox.fib が存在しない)" >&2 + jq '.defs // []' "$OUT_JSON" >&2 || true + exit 1 +fi + +# 3) fib の body 内に Loop ノードがあるか +has_loop=$(jq '.defs // [] | map(select(.box=="TestBox" and .name=="fib")) | any(.body | .body? | any(.type=="Loop"))' "$OUT_JSON") +if [ "$has_loop" != "true" ]; then + echo "[FAIL] stageb_fib_program_defs_canary_vm (TestBox.fib body に Loop が無い)" >&2 + jq '.defs // [] | map(select(.box=="TestBox" and .name=="fib"))' "$OUT_JSON" >&2 || true + exit 1 +fi + +echo "[PASS] stageb_fib_program_defs_canary_vm" +exit 0