hakorune/tools/hakorune_emit_mir.sh

#!/usr/bin/env bash
# hakorune_emit_mir.sh — Emit MIR(JSON) using Hakorune Stage‑B + MirBuilder (Hako‑first)
#
# Usage: tools/hakorune_emit_mir.sh <input.hako> <out.json>
# Notes:
#  - Runs the Stage‑B compiler (Hako) to emit Program(JSON v0), then feeds it to MirBuilderBox.emit_from_program_json_v0.
#  - Defaults to the Hakorune VM path; no inline Ny compiler; Stage‑3 enabled.
#  - Keeps defaults conservative: no global flips; this is a helper for dev/CI scripts.

set -euo pipefail

if [ "$#" -ne 2 ]; then
  echo "Usage: $0 <input.hako> <out.json>" >&2
  exit 2
fi

IN="$1"
OUT="$2"

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
if ROOT_GIT=$(git -C "$SCRIPT_DIR" rev-parse --show-toplevel 2>/dev/null); then
  ROOT="$ROOT_GIT"
else
  ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
fi

# Resolve nyash/hakorune binary via test_runner helper (ensures consistent env)
if [ ! -f "$IN" ]; then
  echo "[FAIL] input not found: $IN" >&2
  exit 1
fi

# Resolve nyash/hakorune binary (simple detection; test_runner will override later if sourced)
if [ -z "${NYASH_BIN:-}" ]; then
  if [ -x "$ROOT/target/release/hakorune" ]; then
    export NYASH_BIN="$ROOT/target/release/hakorune"
  else
    export NYASH_BIN="$ROOT/target/release/nyash"
  fi
fi

CODE="$(cat "$IN")"

# 1) Stage‑B: Hako parser emits Program(JSON v0) to stdout
set +e
PROG_JSON_OUT=$(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=${NYASH_ENABLE_USING:-1} HAKO_ENABLE_USING=${HAKO_ENABLE_USING:-1} \
                "$NYASH_BIN" --backend vm "$ROOT/lang/src/compiler/entry/compiler_stageb.hako" -- --source "$CODE" 2>/dev/null | awk '/^{/,/^}$/')
rc=$?
set -e
if [ $rc -ne 0 ] || [ -z "$PROG_JSON_OUT" ]; then
  echo "[FAIL] Stage-B parse failed (rc=$rc)" >&2
  exit 1
fi

# Quick validation for Program(JSON v0)
if ! printf '%s' "$PROG_JSON_OUT" | grep -q '"kind"\s*:\s*"Program"'; then
  echo "[FAIL] Stage‑B output is not Program(JSON)" >&2
  printf '%s\n' "$PROG_JSON_OUT" | sed -n '1,80p' >&2 || true
  exit 1
fi

# 2) Convert Program(JSON v0) → MIR(JSON)
#    Prefer selfhost builder first when explicitly requested; otherwise use delegate (Gate‑C) for stability.

try_selfhost_builder() {
  local prog_json="$1" out_path="$2"
  local tmp_hako; tmp_hako=$(mktemp --suffix .hako)
  cat >"$tmp_hako" <<'HCODE'
using "hako.mir.builder" as MirBuilderBox
static box Main { method main(args) {
  local prog_json = env.get("HAKO_BUILDER_PROGRAM_JSON")
  if prog_json == null { print("[builder/selfhost-first:fail:nojson]"); return 1 }
  local mir_out = MirBuilderBox.emit_from_program_json_v0(prog_json, null)
  if mir_out == null { print("[builder/selfhost-first:fail:emit]"); return 1 }
  print("[builder/selfhost-first:ok]")
  print("[MIR_OUT_BEGIN]")
  print("" + mir_out)
  print("[MIR_OUT_END]")
  return 0
} }
HCODE
  local tmp_stdout; tmp_stdout=$(mktemp)
  trap 'rm -f "$tmp_hako" "$tmp_stdout" || true' RETURN

  # Trace mode: analyze Program(JSON) before passing to builder
  if [ "${HAKO_SELFHOST_TRACE:-0}" = "1" ]; then
    local prog_len=${#prog_json}
    local loop_count=$(printf '%s' "$prog_json" | grep -o '"type":"Loop"' 2>/dev/null | wc -l | tr -d ' \n')
    local cmp_count=$(printf '%s' "$prog_json" | grep -o '"type":"Compare"' 2>/dev/null | wc -l | tr -d ' \n')
    loop_count=${loop_count:-0}
    cmp_count=${cmp_count:-0}
    local cwd="$(pwd)"
    local toml_status="absent"
    if [ -f "$ROOT/nyash.toml" ]; then
      toml_status="present"
    fi
    echo "[builder/selfhost-first:trace] prog_json_len=$prog_len tokens=Loop:$loop_count,Compare:$cmp_count cwd=$cwd nyash.toml=$toml_status" >&2
  fi

  set +e
  # Run from repo root to ensure nyash.toml is available for using resolution
  (cd "$ROOT" && \
    HAKO_MIR_BUILDER_INTERNAL=1 HAKO_MIR_BUILDER_REGISTRY=1 \
    HAKO_MIR_BUILDER_LOOP_JSONFRAG="${HAKO_MIR_BUILDER_LOOP_JSONFRAG:-}" \
    HAKO_MIR_BUILDER_LOOP_FORCE_JSONFRAG="${HAKO_MIR_BUILDER_LOOP_FORCE_JSONFRAG:-}" \
    HAKO_MIR_BUILDER_JSONFRAG_NORMALIZE="${HAKO_MIR_BUILDER_JSONFRAG_NORMALIZE:-}" \
    HAKO_MIR_BUILDER_JSONFRAG_PURIFY="${HAKO_MIR_BUILDER_JSONFRAG_PURIFY:-}" \
    HAKO_MIR_BUILDER_NORMALIZE_TAG="${HAKO_MIR_BUILDER_NORMALIZE_TAG:-}" \
    HAKO_MIR_BUILDER_DEBUG="${HAKO_MIR_BUILDER_DEBUG:-}" \
    NYASH_ENABLE_USING=1 HAKO_ENABLE_USING=1 \
    NYASH_PARSER_STAGE3=1 HAKO_PARSER_STAGE3=1 NYASH_PARSER_ALLOW_SEMICOLON=1 \
    HAKO_BUILDER_PROGRAM_JSON="$prog_json" \
    "$NYASH_BIN" --backend vm "$tmp_hako" 2>/dev/null | tee "$tmp_stdout" >/dev/null)
  local rc=$?
  set -e

  # Enhanced failure diagnostics
  if [ $rc -ne 0 ]; then
    if [ "${HAKO_SELFHOST_NO_DELEGATE:-0}" = "1" ]; then
      echo "[builder/selfhost-first:fail:child:rc=$rc]" >&2
      echo "[builder/selfhost-first:fail:detail] Last 80 lines of output:" >&2
      tail -n 80 "$tmp_stdout" >&2 || true
    fi
    return 1
  fi

  if ! grep -q "\[builder/selfhost-first:ok\]" "$tmp_stdout"; then
    if [ "${HAKO_SELFHOST_NO_DELEGATE:-0}" = "1" ]; then
      echo "[builder/selfhost-first:fail:no-ok-marker]" >&2
      echo "[builder/selfhost-first:fail:detail] Last 80 lines of output:" >&2
      tail -n 80 "$tmp_stdout" >&2 || true
    fi
    return 1
  fi
  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
  printf '%s' "$mir" > "$out_path"
  echo "[OK] MIR JSON written (selfhost-first): $out_path"
  return 0
}

# When forcing JSONFrag loop, default-enable normalize+purify (dev-only, no default changes)
if [ "${HAKO_MIR_BUILDER_LOOP_FORCE_JSONFRAG:-0}" = "1" ]; then
  export HAKO_MIR_BUILDER_JSONFRAG_NORMALIZE="${HAKO_MIR_BUILDER_JSONFRAG_NORMALIZE:-1}"
  export HAKO_MIR_BUILDER_JSONFRAG_PURIFY="${HAKO_MIR_BUILDER_JSONFRAG_PURIFY:-1}"
fi

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
fi

tmp_prog="/tmp/hako_emit_prog_$$.json"
trap 'rm -f "$tmp_prog" || true' EXIT
printf '%s' "$PROG_JSON_OUT" > "$tmp_prog"
if "$NYASH_BIN" --program-json-to-mir "$OUT" --json-file "$tmp_prog" >/dev/null 2>&1; then
  echo "[OK] MIR JSON written (delegate): $OUT"
  exit 0
fi
echo "[FAIL] Program→MIR delegate failed" >&2
exit 1