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

💢 The truth about Rust + LLVM development hell

Browse Source 
ChatGPT5 struggling for 34+ minutes with Rust lifetime/build errors...
This perfectly illustrates why we need Phase 22 (Nyash LLVM compiler)\!

Key insights:
- 'Rust is safe and beautiful' - Gemini (who never fought lifetime errors)
- Reality: 500-line error messages, 34min debug sessions, lifetime hell
- C would just work: void* compile(void* mir) { done; }
- Python would work: 100 lines with llvmlite
- ANY language with C ABI would work\!

The frustration is real:
- We're SO CLOSE to Nyash self-hosting paradise
- Once bootstrapped, EVERYTHING can be written in Nyash
- No more Rust complexity, no more 5-7min builds
- Just simple, beautiful Box-based code

Current status:
- PHI/SSA hardening in progress (ChatGPT5)
- 'phi incoming value missing' in Main.esc_json/1
- Sealed SSA approach being implemented

The dream is near: Everything is Box, even the compiler\! 🌟
This commit is contained in:
Selfhosting Dev
2025-09-12 05:48:59 +09:00
parent 23fea9258f
commit 1f5ba5f829
9 changed files with 258 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
src/backend/llvm/compiler/codegen/instructions/arith.rs
View File

@ -148,48 +148,44 @@ pub(in super::super) fn lower_compare<'ctx>(
}
} else if let (BasicValueEnum::PointerValue(lp), BasicValueEnum::IntValue(ri)) = (lv, rv) {
use CompareOp as C;
match op {
C::Eq | C::Ne => {
let i64t = codegen.context.i64_type();
let li = codegen
.builder
.build_ptr_to_int(lp, i64t, "pi_l")
.map_err(|e| e.to_string())?;
let pred = if matches!(op, C::Eq) {
inkwell::IntPredicate::EQ
} else {
inkwell::IntPredicate::NE
};
codegen
.builder
.build_int_compare(pred, li, ri, "pcmpi")
.map_err(|e| e.to_string())?
.into()
}
_ => return Err("unsupported pointer-int comparison (only Eq/Ne)".to_string()),
}
let i64t = codegen.context.i64_type();
let li = codegen
.builder
.build_ptr_to_int(lp, i64t, "pi_l")
.map_err(|e| e.to_string())?;
let pred = match op {
C::Eq => inkwell::IntPredicate::EQ,
C::Ne => inkwell::IntPredicate::NE,
C::Lt => inkwell::IntPredicate::SLT,
C::Le => inkwell::IntPredicate::SLE,
C::Gt => inkwell::IntPredicate::SGT,
C::Ge => inkwell::IntPredicate::SGE,
};
codegen
.builder
.build_int_compare(pred, li, ri, "pcmpi")
.map_err(|e| e.to_string())?
.into()
} else if let (BasicValueEnum::IntValue(li), BasicValueEnum::PointerValue(rp)) = (lv, rv) {
use CompareOp as C;
match op {
C::Eq | C::Ne => {
let i64t = codegen.context.i64_type();
let ri = codegen
.builder
.build_ptr_to_int(rp, i64t, "pi_r")
.map_err(|e| e.to_string())?;
let pred = if matches!(op, C::Eq) {
inkwell::IntPredicate::EQ
} else {
inkwell::IntPredicate::NE
};
codegen
.builder
.build_int_compare(pred, li, ri, "pcmpi")
.map_err(|e| e.to_string())?
.into()
}
_ => return Err("unsupported int-pointer comparison (only Eq/Ne)".to_string()),
}
let i64t = codegen.context.i64_type();
let ri = codegen
.builder
.build_ptr_to_int(rp, i64t, "pi_r")
.map_err(|e| e.to_string())?;
let pred = match op {
C::Eq => inkwell::IntPredicate::EQ,
C::Ne => inkwell::IntPredicate::NE,
C::Lt => inkwell::IntPredicate::SLT,
C::Le => inkwell::IntPredicate::SLE,
C::Gt => inkwell::IntPredicate::SGT,
C::Ge => inkwell::IntPredicate::SGE,
};
codegen
.builder
.build_int_compare(pred, li, ri, "pcmpi")
.map_err(|e| e.to_string())?
.into()
} else {
return Err("compare type mismatch".to_string());
};

4
src/backend/llvm/compiler/codegen/instructions/arrays.rs
View File

@ -17,7 +17,8 @@ pub(super) fn try_handle_array_method<'ctx>(
recv_h: inkwell::values::IntValue<'ctx>,
) -> Result<bool, String> {
// Only when receiver is ArrayBox
let is_array = matches!(func.metadata.value_types.get(box_val), Some(crate::mir::MirType::Box(b)) if b == "ArrayBox");
let is_array = matches!(func.metadata.value_types.get(box_val), Some(crate::mir::MirType::Box(b)) if b == "ArrayBox")
|| matches!(method, "get" | "set" | "push" | "length");
if !is_array {
return Ok(false);
}
@ -127,4 +128,3 @@ pub(super) fn try_handle_array_method<'ctx>(
_ => Ok(false),
}
}

13
src/backend/llvm/compiler/codegen/instructions/blocks.rs
View File

@ -3,6 +3,7 @@ use inkwell::values::{BasicValueEnum, FunctionValue, PhiValue};
use std::collections::HashMap;
use crate::backend::llvm::context::CodegenContext;
use super::super::types::map_mirtype_to_basic;
use crate::mir::{function::MirFunction, BasicBlockId, ValueId};
// Small, safe extraction: create LLVM basic blocks for a MIR function and
@ -59,7 +60,19 @@ pub(in super::super) fn precreate_phis<'ctx>(
{
if let crate::mir::instruction::MirInstruction::Phi { dst, inputs } = inst {
let mut phi_ty: Option<inkwell::types::BasicTypeEnum> = None;
// Prefer pointer when any input (or dst) is String/Box/Array/Future/Unknown
let mut wants_ptr = false;
if let Some(mt) = func.metadata.value_types.get(dst) {
wants_ptr |= matches!(mt, crate::mir::MirType::String | crate::mir::MirType::Box(_) | crate::mir::MirType::Array(_) | crate::mir::MirType::Future(_) | crate::mir::MirType::Unknown);
}
for (_, iv) in inputs.iter() {
if let Some(mt) = func.metadata.value_types.get(iv) {
wants_ptr |= matches!(mt, crate::mir::MirType::String | crate::mir::MirType::Box(_) | crate::mir::MirType::Array(_) | crate::mir::MirType::Future(_) | crate::mir::MirType::Unknown);
}
}
if wants_ptr {
phi_ty = Some(codegen.context.ptr_type(inkwell::AddressSpace::from(0)).into());
} else if let Some(mt) = func.metadata.value_types.get(dst) {
phi_ty = Some(map_mirtype_to_basic(codegen.context, mt));
} else if let Some((_, iv)) = inputs.first() {
if let Some(mt) = func.metadata.value_types.get(iv) {

110
src/backend/llvm/compiler/codegen/instructions/boxcall.rs
View File

@ -5,8 +5,10 @@ use inkwell::values::BasicValueEnum as BVE;
use crate::backend::llvm::context::CodegenContext;
mod fields;
mod invoke;
pub(crate) mod invoke;
mod marshal;
use self::marshal as marshal_mod;
use self::invoke as invoke_mod;
use crate::mir::{function::MirFunction, ValueId};
// BoxCall lowering (large): mirrors existing logic; kept in one function for now
@ -66,6 +68,11 @@ pub(in super::super) fn lower_boxcall<'ctx>(
return Ok(());
}
// Console convenience: treat println as env.console.log
if method == "println" {
return super::externcall::lower_externcall(codegen, func, vmap, dst, &"env.console".to_string(), &"log".to_string(), args);
}
// getField/setField
if fields::try_handle_field_method(codegen, vmap, dst, method, args, recv_h)? {
return Ok(());
@ -106,6 +113,107 @@ pub(in super::super) fn lower_boxcall<'ctx>(
)?;
return Ok(());
} else {
// Fallback: treat as direct call to a user function in the same module, if present.
// Compose candidate name like "<Module>.<method>/<arity>" (e.g., Main.esc_json/1)
let arity = args.len();
let module_name = func
.signature
.name
.split('.')
.next()
.unwrap_or("")
.to_string();
if !module_name.is_empty() {
let candidate = format!("{}.{}{}", module_name, method, format!("/{}", arity));
// Sanitize symbol the same way as codegen/mod.rs does
let sym: String = {
let mut s = String::from("ny_f_");
s.push_str(&candidate.replace('.', "_").replace('/', "_").replace('-', "_"));
s
};
if let Some(callee) = codegen.module.get_function(&sym) {
let mut call_args: Vec<inkwell::values::BasicMetadataValueEnum> = Vec::with_capacity(args.len());
for a in args {
let v = *vmap.get(a).ok_or("boxcall func arg missing")?;
call_args.push(v.into());
}
let call = codegen
.builder
.build_call(callee, &call_args, "user_meth_call")
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
if let Some(rv) = call.try_as_basic_value().left() {
vmap.insert(*d, rv);
}
}
return Ok(());
}
}
// Last resort: invoke plugin by name (host resolves method_id)
{
use crate::backend::llvm::compiler::codegen::instructions::boxcall::marshal::get_i64 as get_i64_any;
let i64t = codegen.context.i64_type();
let argc = i64t.const_int(args.len() as u64, false);
let mname = codegen
.builder
.build_global_string_ptr(method, "meth_name")
.map_err(|e| e.to_string())?;
// up to 2 args for this minimal path
let a1 = if let Some(v0) = args.get(0) { get_i64_any(codegen, vmap, *v0)? } else { i64t.const_zero() };
let a2 = if let Some(v1) = args.get(1) { get_i64_any(codegen, vmap, *v1)? } else { i64t.const_zero() };
let fnty = i64t.fn_type(
&[
i64t.into(), // recv handle
codegen.context.ptr_type(AddressSpace::from(0)).into(), // method cstr
i64t.into(), i64t.into(), i64t.into(), // argc, a1, a2
],
false,
);
let callee = codegen
.module
.get_function("nyash.plugin.invoke_by_name_i64")
.unwrap_or_else(|| codegen.module.add_function("nyash.plugin.invoke_by_name_i64", fnty, None));
let call = codegen
.builder
.build_call(callee, &[recv_h.into(), mname.as_pointer_value().into(), argc.into(), a1.into(), a2.into()], "pinvoke_by_name")
.map_err(|e| e.to_string())?;
if let Some(d) = dst {
let rv = call
.try_as_basic_value()
.left()
.ok_or("invoke_by_name returned void".to_string())?;
// Inline minimal return normalization similar to store_invoke_return()
if let Some(mt) = func.metadata.value_types.get(d) {
match mt {
crate::mir::MirType::Integer => { vmap.insert(*d, rv); }
crate::mir::MirType::Bool => {
if let BVE::IntValue(iv) = rv {
let i64t = codegen.context.i64_type();
let zero = i64t.const_zero();
let b1 = codegen.builder.build_int_compare(inkwell::IntPredicate::NE, iv, zero, "bool_i64_to_i1").map_err(|e| e.to_string())?;
vmap.insert(*d, b1.into());
} else { vmap.insert(*d, rv); }
}
crate::mir::MirType::String => {
if let BVE::IntValue(iv) = rv {
let p = codegen.builder.build_int_to_ptr(iv, codegen.context.ptr_type(AddressSpace::from(0)), "str_h2p_ret").map_err(|e| e.to_string())?;
vmap.insert(*d, p.into());
} else { vmap.insert(*d, rv); }
}
crate::mir::MirType::Box(_) | crate::mir::MirType::Array(_) | crate::mir::MirType::Future(_) | crate::mir::MirType::Unknown => {
if let BVE::IntValue(iv) = rv {
let p = codegen.builder.build_int_to_ptr(iv, codegen.context.ptr_type(AddressSpace::from(0)), "h2p_ret").map_err(|e| e.to_string())?;
vmap.insert(*d, p.into());
} else { vmap.insert(*d, rv); }
}
_ => { vmap.insert(*d, rv); }
}
} else {
vmap.insert(*d, rv);
}
}
return Ok(());
}
Err(format!("BoxCall requires method_id for method '{}'. The method_id should be automatically injected during MIR compilation.", method))
}
}

17
src/backend/llvm/compiler/codegen/instructions/boxcall/invoke.rs
View File

@ -159,9 +159,23 @@ fn store_invoke_return<'ctx>(
) -> Result<(), String> {
if let Some(mt) = func.metadata.value_types.get(&dst) {
match mt {
crate::mir::MirType::Integer | crate::mir::MirType::Bool => {
crate::mir::MirType::Integer => {
vmap.insert(dst, rv);
}
crate::mir::MirType::Bool => {
// Normalize i64 bool (0/1) to i1
if let BVE::IntValue(iv) = rv {
let i64t = codegen.context.i64_type();
let zero = i64t.const_zero();
let b1 = codegen
.builder
.build_int_compare(inkwell::IntPredicate::NE, iv, zero, "bool_i64_to_i1")
.map_err(|e| e.to_string())?;
vmap.insert(dst, b1.into());
} else {
vmap.insert(dst, rv);
}
}
crate::mir::MirType::String => {
// keep as i64 handle
vmap.insert(dst, rv);
@ -191,4 +205,3 @@ fn store_invoke_return<'ctx>(
}
Ok(())
}

17
src/backend/llvm/compiler/codegen/instructions/flow.rs
View File

@ -5,7 +5,7 @@ use std::collections::HashMap;
use crate::backend::llvm::context::CodegenContext;
use crate::mir::{function::MirFunction, BasicBlockId, ValueId};
use super::super::types::to_bool;
use super::super::types::{to_bool, map_mirtype_to_basic};
pub(in super::super) fn emit_return<'ctx>(
codegen: &CodegenContext<'ctx>,
@ -20,9 +20,22 @@ pub(in super::super) fn emit_return<'ctx>(
}
(_t, Some(vid)) => {
let v = *vmap.get(vid).ok_or("ret value missing")?;
// If function expects a pointer but we have an integer handle, convert i64 -> ptr
let expected = map_mirtype_to_basic(codegen.context, &func.signature.return_type);
use inkwell::types::BasicTypeEnum as BT;
let v_adj = match (expected, v) {
(BT::PointerType(pt), BasicValueEnum::IntValue(iv)) => {
codegen
.builder
.build_int_to_ptr(iv, pt, "ret_i2p")
.map_err(|e| e.to_string())?
.into()
}
_ => v,
};
codegen
.builder
.build_return(Some(&v))
.build_return(Some(&v_adj))
.map_err(|e| e.to_string())?;
Ok(())
}

14
src/backend/llvm/compiler/codegen/instructions/strings.rs
View File

@ -16,15 +16,13 @@ pub(super) fn try_handle_string_method<'ctx>(
args: &[ValueId],
recv_v: BVE<'ctx>,
) -> Result<bool, String> {
// Only act if receiver is annotated as String or StringBox
// Act if receiver is annotated as String/StringBox, or if the actual value is an i8* (string literal path)
let is_string_recv = match func.metadata.value_types.get(box_val) {
Some(crate::mir::MirType::String) => true,
Some(crate::mir::MirType::Box(b)) if b == "StringBox" => true,
_ => false,
_ => matches!(recv_v, BVE::PointerValue(_)),
};
if !is_string_recv {
return Ok(false);
}
// Do not early-return; allow method-specific checks below to validate types
// concat fast-paths
if method == "concat" {
@ -153,9 +151,13 @@ pub(super) fn try_handle_string_method<'ctx>(
}
let i64t = codegen.context.i64_type();
let i8p = codegen.context.ptr_type(AddressSpace::from(0));
// receiver must be i8* for this fast path
// receiver preferably i8*; if it's a handle (i64), conservatively cast to i8*
let recv_p = match recv_v {
BVE::PointerValue(p) => p,
BVE::IntValue(iv) => codegen
.builder
.build_int_to_ptr(iv, codegen.context.ptr_type(AddressSpace::from(0)), "str_h2p_sub")
.map_err(|e| e.to_string())?,
_ => return Ok(false),
};
let a0 = *vmap.get(&args[0]).ok_or("substring start arg missing")?;