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

127
src/config/env.rs
View File

@ -3,6 +3,13 @@
//! Consolidates NYASH_* environment variables across subsystems and
//! optionally applies overrides from `nyash.toml`.
mod catalog;
pub mod dump;
pub mod stage1;
pub use catalog::{env_vars, AppliesTo, EnvVarMeta};
pub use dump::*;
pub use stage1::*;
use std::collections::BTreeMap;
#[derive(Debug, Clone, Default)]
@ -185,8 +192,7 @@ pub fn fail_fast() -> bool {
// VM legacy by-name call fallback was removed (Phase 2 complete).
// ---- Phase 11.8 MIR cleanup toggles ----
/// Core-13 minimal MIR mode toggle
/// Default: ON (unless explicitly disabled with NYASH_MIR_CORE13=0)
/// Core-13 minimal MIR mode toggle. Default ON unless NYASH_MIR_CORE13=0.
pub fn mir_core13() -> bool {
match std::env::var("NYASH_MIR_CORE13").ok() {
Some(v) => {
@ -209,25 +215,11 @@ pub fn plugin_only() -> bool {
std::env::var("NYASH_PLUGIN_ONLY").ok().as_deref() == Some("1")
}
/// Core-13 "pure" mode: after normalization, only the 13 canonical ops are allowed.
/// If enabled, the optimizer will try lightweight rewrites for Load/Store/NewBox/Unary,
/// and the final verifier will reject any remaining non-Core-13 ops.
/// Core-13 "pure" mode: only the 13 canonical ops are allowed (verifier rejects others).
pub fn mir_core13_pure() -> bool {
env_bool("NYASH_MIR_CORE13_PURE")
}
/// Enable heuristic pre-pin of comparison operands in if/loop headers.
/// Default: OFF (0). Set NYASH_MIR_PREPIN=1 to enable.
pub fn mir_pre_pin_compare_operands() -> bool {
match std::env::var("NYASH_MIR_PREPIN").ok() {
Some(v) => {
let lv = v.to_ascii_lowercase();
!(lv == "0" || lv == "false" || lv == "off")
}
None => false,
}
}
// ---- Optimizer diagnostics ----
pub fn opt_debug() -> bool {
std::env::var("NYASH_OPT_DEBUG").is_ok()
@ -259,15 +251,6 @@ pub fn gc_barrier_trace() -> bool {
pub fn runtime_checkpoint_trace() -> bool {
env_bool("NYASH_RUNTIME_CHECKPOINT_TRACE")
}
pub fn vm_pic_stats() -> bool {
env_bool("NYASH_VM_PIC_STATS")
}
pub fn vm_vt_trace() -> bool {
env_bool("NYASH_VM_VT_TRACE")
}
pub fn vm_pic_trace() -> bool {
std::env::var("NYASH_VM_PIC_TRACE").ok().as_deref() == Some("1")
}
pub fn gc_barrier_strict() -> bool {
std::env::var("NYASH_GC_BARRIER_STRICT").ok().as_deref() == Some("1")
}
@ -300,10 +283,6 @@ pub fn gc_metrics() -> bool {
pub fn gc_metrics_json() -> bool {
std::env::var("NYASH_GC_METRICS_JSON").ok().as_deref() == Some("1")
}
/// Leak diagnostics on exit
pub fn gc_leak_diag() -> bool {
std::env::var("NYASH_GC_LEAK_DIAG").ok().as_deref() == Some("1")
}
/// Optional allocation threshold; if Some(n) and exceeded, print warning
pub fn gc_alloc_threshold() -> Option<u64> {
std::env::var("NYASH_GC_ALLOC_THRESHOLD").ok()?.parse().ok()
@ -356,18 +335,11 @@ pub fn rewrite_future() -> bool {
pub fn abi_vtable() -> bool {
std::env::var("NYASH_ABI_VTABLE").ok().as_deref() == Some("1")
}
/// ABI strict diagnostics: missing vtable methods become errors when enabled.
pub fn abi_strict() -> bool {
std::env::var("NYASH_ABI_STRICT").ok().as_deref() == Some("1")
}
// ---- ExternCall strict diagnostics ----
pub fn extern_strict() -> bool {
std::env::var("NYASH_EXTERN_STRICT").ok().as_deref() == Some("1")
}
pub fn extern_trace() -> bool {
std::env::var("NYASH_EXTERN_TRACE").ok().as_deref() == Some("1")
}
// ---- Operator Boxes adopt defaults ----
/// CompareOperator.apply adopt: default ON (prod/devともに採用)
pub fn operator_box_compare_adopt() -> bool {
@ -406,22 +378,9 @@ pub fn null_strict() -> bool {
}
// ---- Phase 12: thresholds and routing policies ----
/// PIC hotness threshold before promoting to mono cache.
pub fn vm_pic_threshold() -> u32 {
std::env::var("NYASH_VM_PIC_THRESHOLD")
.ok()
.and_then(|s| s.parse().ok())
.unwrap_or(8)
}
/// Route VM ExternCall via name→slot handlers when available
pub fn extern_route_slots() -> bool {
std::env::var("NYASH_EXTERN_ROUTE_SLOTS").ok().as_deref() == Some("1")
}
// ---- Runner/CLI common toggles (hot-path centralization)
pub fn cli_verbose() -> bool {
std::env::var("NYASH_CLI_VERBOSE").ok().as_deref() == Some("1")
cli_verbose_level() > 0
}
pub fn enable_using() -> bool {
// Phase 15: デフォルトON（using systemはメイン機能）
@ -445,12 +404,15 @@ pub fn enable_using() -> bool {
pub fn using_profile() -> String {
std::env::var("NYASH_USING_PROFILE").unwrap_or_else(|_| "dev".to_string())
}
/// True when using profile is prod (disables some dev-only behaviors).
pub fn using_is_prod() -> bool {
using_profile().eq_ignore_ascii_case("prod")
}
/// True when using profile is ci.
pub fn using_is_ci() -> bool {
using_profile().eq_ignore_ascii_case("ci")
}
/// True when using profile is dev (default).
pub fn using_is_dev() -> bool {
using_profile().eq_ignore_ascii_case("dev")
}
@ -501,8 +463,17 @@ pub fn vm_use_py() -> bool {
pub fn pipe_use_pyvm() -> bool {
std::env::var("NYASH_PIPE_USE_PYVM").ok().as_deref() == Some("1")
}
/// (Deprecated) use dispatch-based VM route; currently disabled.
pub fn vm_use_dispatch() -> bool {
std::env::var("NYASH_VM_USE_DISPATCH").ok().as_deref() == Some("1")
false
}
/// Force VM fallback interpreter route (dev-only escape hatch).
pub fn vm_use_fallback() -> bool {
std::env::var("NYASH_VM_USE_FALLBACK").ok().as_deref() == Some("1")
}
/// Trace VM route selection decisions.
pub fn vm_route_trace() -> bool {
std::env::var("NYASH_VM_ROUTE_TRACE").ok().as_deref() == Some("1")
}
// Self-host compiler knobs
@ -512,24 +483,27 @@ pub fn ny_compiler_timeout_ms() -> u64 {
.and_then(|s| s.parse().ok())
.unwrap_or(2000)
}
/// Emit-only flag for selfhost compiler (default ON to avoid execution).
pub fn ny_compiler_emit_only() -> bool {
std::env::var("NYASH_NY_COMPILER_EMIT_ONLY").unwrap_or_else(|_| "1".to_string()) == "1"
}
pub fn ny_compiler_skip_py() -> bool {
std::env::var("NYASH_NY_COMPILER_SKIP_PY").ok().as_deref() == Some("1")
}
/// Path to external selfhost compiler executable (when enabled).
pub fn use_ny_compiler_exe() -> bool {
std::env::var("NYASH_USE_NY_COMPILER_EXE").ok().as_deref() == Some("1")
}
/// Path to external selfhost compiler executable (when enabled).
pub fn ny_compiler_exe_path() -> Option<String> {
std::env::var("NYASH_NY_COMPILER_EXE_PATH").ok()
}
/// Pass `-- --min-json` to child selfhost compiler (minimal JSON output).
pub fn ny_compiler_min_json() -> bool {
std::env::var("NYASH_NY_COMPILER_MIN_JSON").ok().as_deref() == Some("1")
}
/// When true, child reads tmp/ny_parser_input.ny instead of stdin/source text.
pub fn selfhost_read_tmp() -> bool {
std::env::var("NYASH_SELFHOST_READ_TMP").ok().as_deref() == Some("1")
}
/// Pass `-- --stage3` to child selfhost compiler to allow Stage-3 surface.
pub fn ny_compiler_stage3() -> bool {
std::env::var("NYASH_NY_COMPILER_STAGE3").ok().as_deref() == Some("1")
}
@ -600,6 +574,7 @@ pub fn unified_members() -> bool {
}
}
pub fn ny_compiler_child_args() -> Option<String> {
// Pass-through args to selfhost child (space-separated).
std::env::var("NYASH_NY_COMPILER_CHILD_ARGS").ok()
}
pub fn ny_compiler_use_tmp_only() -> bool {
@ -609,6 +584,44 @@ pub fn ny_compiler_use_tmp_only() -> bool {
== Some("1")
}
/// Use Python MVP harness for Ny compiler (NYASH_NY_COMPILER_USE_PY=1).
pub fn ny_compiler_use_py() -> bool {
std::env::var("NYASH_NY_COMPILER_USE_PY")
.ok()
.as_deref()
== Some("1")
}
/// Macro pre-expand mode for selfhost (NYASH_MACRO_SELFHOST_PRE_EXPAND).
/// Returns "1", "auto", or None.
pub fn macro_selfhost_pre_expand() -> Option<String> {
std::env::var("NYASH_MACRO_SELFHOST_PRE_EXPAND").ok()
}
/// ScopeBox enable flag (NYASH_SCOPEBOX_ENABLE=1).
pub fn scopebox_enable() -> bool {
std::env::var("NYASH_SCOPEBOX_ENABLE")
.ok()
.as_deref()
== Some("1")
}
/// LoopForm normalize flag (NYASH_LOOPFORM_NORMALIZE=1).
pub fn loopform_normalize() -> bool {
std::env::var("NYASH_LOOPFORM_NORMALIZE")
.ok()
.as_deref()
== Some("1")
}
/// Dev-only escape hatch: force inline selfhost path (NYASH_SELFHOST_INLINE_FORCE=1).
pub fn selfhost_inline_force() -> bool {
std::env::var("NYASH_SELFHOST_INLINE_FORCE")
.ok()
.as_deref()
== Some("1")
}
/// Unicode decode toggle for string literals (\uXXXX, optional surrogate pairs).
/// Enabled when either HAKO_PARSER_DECODE_UNICODE=1 or NYASH_PARSER_DECODE_UNICODE=1.
/// Default: OFF (for strict backward compatibility).
@ -670,7 +683,7 @@ pub fn verify_primary_is_hakovm() -> bool {
false
}
fn warn_alias_once(alias: &str, primary: &str) {
pub(crate) fn warn_alias_once(alias: &str, primary: &str) {
let set = WARNED_ALIASES.get_or_init(|| Mutex::new(HashSet::new()));
if let Ok(mut s) = set.lock() {
if !s.contains(alias) {

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) => {