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

refactor(selfhost): clean up selfhost.rs - remove duplicates, unify env access

Browse Source 
## Changes

### Duplicate code removal
- Remove nested double cli_verbose() checks (2 places)
- Remove duplicate pre_run_reset_oob_if_strict() calls
- Remove duplicate OOB strict check blocks

### Environment variable access unification
- All raw std::env::var() calls replaced with config::env functions
- Added new config::env functions:
  - ny_compiler_use_py()
  - macro_selfhost_pre_expand()
  - scopebox_enable()
  - loopform_normalize()
  - selfhost_inline_force()

### Common helper extraction
- maybe_dump_mir_verbose(): MIR dump with verbose check
- check_oob_strict_exit(): OOB strict mode check and exit
- execute_with_oob_check(): Combined run + OOB check

## Result
- Net ~11 lines reduction
- Much better code structure and maintainability
- Consistent environment variable access through config::env

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

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
nyash-codex
2025-11-25 07:18:29 +09:00
parent 59f00db385
commit 22575aa1db
2 changed files with 127 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
src/runner/selfhost.rs
View File

@ -10,6 +10,32 @@ use super::*;
use nyash_rust::{mir::MirCompiler, parser::NyashParser};
use std::{fs, process};
// ============================================================================
// Selfhost pipeline helpers
// ============================================================================
/// Dump MIR if NYASH_CLI_VERBOSE is enabled.
fn maybe_dump_mir_verbose(module: &crate::mir::MirModule) {
if crate::config::env::cli_verbose() {
super::json_v0_bridge::maybe_dump_mir(module);
}
}
/// Check OOB strict mode and exit(1) if out-of-bounds was observed.
fn check_oob_strict_exit() {
if crate::config::env::oob_strict_fail() && crate::runtime::observe::oob_seen() {
eprintln!("[selfhost][oob-strict] Out-of-bounds observed → exit(1)");
std::process::exit(1);
}
}
/// Run module and check OOB, with pre-run reset.
fn execute_with_oob_check(runner: &NyashRunner, module: &crate::mir::MirModule) {
crate::runner::child_env::pre_run_reset_oob_if_strict();
runner.execute_mir_module(module);
check_oob_strict_exit();
}
impl NyashRunner {
/// Selfhost (Ny -> JSON v0) pipeline: EXE/VM/Python フォールバック含む
pub(crate) fn try_run_selfhost_pipeline(&self, filename: &str) -> bool {
@ -114,15 +140,13 @@ impl NyashRunner {
// Default: auto when macro engine is enabled (safe: PyVM only)
// Gate: NYASH_MACRO_SELFHOST_PRE_EXPAND={1|auto|0}
{
let preenv = std::env::var("NYASH_MACRO_SELFHOST_PRE_EXPAND")
.ok()
.or_else(|| {
if crate::r#macro::enabled() {
Some("auto".to_string())
} else {
None
}
});
let preenv = crate::config::env::macro_selfhost_pre_expand().or_else(|| {
if crate::r#macro::enabled() {
Some("auto".to_string())
} else {
None
}
});
let do_pre = match preenv.as_deref() {
Some("1") => true,
Some("auto") => crate::r#macro::enabled() && crate::config::env::vm_use_py(),
@ -183,14 +207,15 @@ impl NyashRunner {
}
}
}
// Preferred: run Ny selfhost compiler program (apps/selfhost/compiler/compiler.hako)
// Preferred: run Ny selfhost compiler program (lang/src/compiler/entry/compiler.hako)
// This avoids inline embedding pitfalls and supports Stage-3 gating via args.
{
use crate::runner::modes::common_util::selfhost::{child, json};
let verbose_level = crate::config::env::dump::cli_verbose_level();
let exe = std::env::current_exe()
.unwrap_or_else(|_| std::path::PathBuf::from("target/release/nyash"));
let parser_prog = std::path::Path::new("apps/selfhost/compiler/compiler.hako");
// Phase 28.2: selfhost compiler entry moved under lang/src/compiler/entry
let parser_prog = std::path::Path::new("lang/src/compiler/entry/compiler.hako");
if parser_prog.exists() {
// Phase 28.2: observation log (NYASH_CLI_VERBOSE>=2)
if verbose_level >= 2 {
@ -209,16 +234,16 @@ impl NyashRunner {
extra_owned.push("--stage3".to_string());
}
// Optional: map env toggles to child args (prepasses)
if std::env::var("NYASH_SCOPEBOX_ENABLE").ok().as_deref() == Some("1") {
if crate::config::env::scopebox_enable() {
extra_owned.push("--".to_string());
extra_owned.push("--scopebox".to_string());
}
if std::env::var("NYASH_LOOPFORM_NORMALIZE").ok().as_deref() == Some("1") {
if crate::config::env::loopform_normalize() {
extra_owned.push("--".to_string());
extra_owned.push("--loopform".to_string());
}
// Optional: developer-provided child args passthrough (space-separated)
if let Ok(raw) = std::env::var("NYASH_SELFHOST_CHILD_ARGS") {
if let Some(raw) = crate::config::env::ny_compiler_child_args() {
let items: Vec<String> = raw
.split(' ')
.filter(|s| !s.trim().is_empty())
@ -302,7 +327,7 @@ impl NyashRunner {
// 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 crate::config::env::ny_compiler_use_py() {
if let Ok(py3) = which::which("python3") {
let py = std::path::Path::new("tools/ny_parser_mvp.py");
if py.exists() {
@ -310,10 +335,7 @@ impl NyashRunner {
// 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(60000); // Phase 25.1b: Increased to 60000ms (60s) for consistency
let timeout_ms = crate::config::env::ny_compiler_timeout_ms();
let out =
match super::modes::common_util::io::spawn_with_timeout(cmd, timeout_ms) {
Ok(o) => o,
@ -327,20 +349,12 @@ impl NyashRunner {
if let Some(line) = crate::runner::modes::common_util::selfhost::json::first_json_v0_line(&s) {
match super::json_v0_bridge::parse_json_v0_to_module(&line) {
Ok(module) => {
if crate::config::env::cli_verbose() {
if crate::config::env::cli_verbose() {
super::json_v0_bridge::maybe_dump_mir(&module);
}
}
let emit_only =
std::env::var("NYASH_NY_COMPILER_EMIT_ONLY")
.unwrap_or_else(|_| "1".to_string())
== "1";
if emit_only {
maybe_dump_mir_verbose(&module);
if crate::config::env::ny_compiler_emit_only() {
return false;
}
// Prefer PyVM for selfhost pipeline (parity reference)
if std::env::var("NYASH_VM_USE_PY").ok().as_deref() == Some("1") {
if crate::config::env::vm_use_py() {
let code = match crate::runner::modes::common_util::pyvm::run_pyvm_harness(&module, "selfhost-py") {
Ok(c) => c,
Err(e) => { eprintln!("❌ PyVM error: {}", e); 1 }
@ -348,12 +362,7 @@ impl NyashRunner {
println!("Result: {}", code);
std::process::exit(code);
}
crate::runner::child_env::pre_run_reset_oob_if_strict();
self.execute_mir_module(&module);
if crate::config::env::oob_strict_fail() && crate::runtime::observe::oob_seen() {
eprintln!("[selfhost][oob-strict] Out-of-bounds observed → exit(1)");
std::process::exit(1);
}
execute_with_oob_check(self, &module);
return true;
}
Err(e) => {
@ -368,9 +377,9 @@ impl NyashRunner {
}
}
// EXE-first: if requested, try external parser EXE (nyash_compiler)
if std::env::var("NYASH_USE_NY_COMPILER_EXE").ok().as_deref() == Some("1") {
if crate::config::env::use_ny_compiler_exe() {
// Resolve parser EXE path
let exe_path = if let Ok(p) = std::env::var("NYASH_NY_COMPILER_EXE_PATH") {
let exe_path = if let Some(p) = crate::config::env::ny_compiler_exe_path() {
std::path::PathBuf::from(p)
} else {
let mut p = std::path::PathBuf::from("dist/nyash_compiler");
@ -394,24 +403,16 @@ impl NyashRunner {
}
};
if exe_path.exists() {
let timeout_ms: u64 = std::env::var("NYASH_NY_COMPILER_TIMEOUT_MS")
.ok()
.and_then(|s| s.parse().ok())
.unwrap_or(2000);
let timeout_ms = crate::config::env::ny_compiler_timeout_ms();
if let Some(module) = super::modes::common_util::selfhost_exe::exe_try_parse_json_v0(
filename, timeout_ms,
) {
if crate::config::env::cli_verbose() {
super::json_v0_bridge::maybe_dump_mir(&module);
}
let emit_only = std::env::var("NYASH_NY_COMPILER_EMIT_ONLY")
.unwrap_or_else(|_| "1".to_string())
== "1";
if emit_only {
maybe_dump_mir_verbose(&module);
if crate::config::env::ny_compiler_emit_only() {
return false;
}
// Prefer PyVM when requested (reference semantics)
if std::env::var("NYASH_VM_USE_PY").ok().as_deref() == Some("1") {
if crate::config::env::vm_use_py() {
if let Ok(py3) = which::which("python3") {
let runner = std::path::Path::new("tools/pyvm_runner.py");
if runner.exists() {
@ -461,19 +462,7 @@ impl NyashRunner {
}
}
}
crate::runner::child_env::pre_run_reset_oob_if_strict();
crate::runner::child_env::pre_run_reset_oob_if_strict();
self.execute_mir_module(&module);
if crate::config::env::oob_strict_fail() && crate::runtime::observe::oob_seen()
{
eprintln!("[selfhost][oob-strict] Out-of-bounds observed → exit(1)");
std::process::exit(1);
}
if crate::config::env::oob_strict_fail() && crate::runtime::observe::oob_seen()
{
eprintln!("[selfhost][oob-strict] Out-of-bounds observed → exit(1)");
std::process::exit(1);
}
execute_with_oob_check(self, &module);
return true;
} else {
return false;
@ -489,23 +478,16 @@ impl NyashRunner {
crate::cli_v!("[ny-compiler] inline selfhost pipeline disabled (Phase 25.1b); falling back to default path");
// Dev-only escape hatch: allow forcing the old inline path when explicitly requested.
if std::env::var("NYASH_SELFHOST_INLINE_FORCE").ok().as_deref() == Some("1") {
if crate::config::env::selfhost_inline_force() {
match super::json_v0_bridge::parse_json_v0_to_module("") {
Ok(module) => {
if crate::config::env::cli_verbose() {
if crate::config::env::cli_verbose() {
super::json_v0_bridge::maybe_dump_mir(&module);
}
}
let emit_only = std::env::var("NYASH_NY_COMPILER_EMIT_ONLY")
.unwrap_or_else(|_| "1".to_string())
== "1";
if emit_only {
maybe_dump_mir_verbose(&module);
if crate::config::env::ny_compiler_emit_only() {
return false;
}
// Phase-15 policy: when NYASH_VM_USE_PY=1, prefer PyVM as reference executor
// regardless of BoxCall presence to ensure semantics parity (e.g., PHI merges).
let prefer_pyvm = std::env::var("NYASH_VM_USE_PY").ok().as_deref() == Some("1");
let prefer_pyvm = crate::config::env::vm_use_py();
// Backward compatibility: if not preferring PyVM explicitly, still auto-enable when BoxCalls exist.
let needs_pyvm = !prefer_pyvm
&& module.functions.values().any(|f| {
@ -530,13 +512,7 @@ impl NyashRunner {
std::process::exit(code);
}
}
crate::runner::child_env::pre_run_reset_oob_if_strict();
self.execute_mir_module(&module);
if crate::config::env::oob_strict_fail() && crate::runtime::observe::oob_seen()
{
eprintln!("[selfhost][oob-strict] Out-of-bounds observed → exit(1)");
std::process::exit(1);
}
execute_with_oob_check(self, &module);
return true;
}
Err(e) => {