use compiler::{Capture, Compiler, Symbol};
use dynamic::{Dynamic, Type};
use parser::{BinaryOp, Expr, ExprKind, PatternKind, Span, Stmt, StmtKind, UnaryOp};
use std::collections::{BTreeMap, HashMap, VecDeque};
use crate::context::LocalVar;
use super::{FnInfo, FnVariant, PTR_TYPE, context::BuildContext, ptr_type};
use cranelift::prelude::*;
use cranelift_jit::{JITBuilder, JITModule};
use cranelift_module::{DataDescription, DataId, FuncId, Module};
use anyhow::{Result, anyhow};
use smol_str::SmolStr;
use std::sync::{Arc, RwLock};
pub struct JITRunTime {
pub compiler: Compiler,
pub fns: BTreeMap<u32, FnVariant>,
pub sigs: Vec<(Vec<Type>, Signature, Type)>,
pub native_symbols: Arc<RwLock<HashMap<String, usize>>>,
pub(crate) pending_fns: VecDeque<PendingFn>,
pub(crate) compile_depth: usize,
#[cfg(feature = "ir-disassembly")]
pub ir_disassembly: BTreeMap<SmolStr, String>,
pub module: JITModule,
pub consts: Vec<Option<DataId>>,
}
pub(crate) struct PendingFn {
pub name: SmolStr,
pub symbol_id: u32,
pub fn_id: FuncId,
pub arg_tys: Vec<Type>,
pub ret_ty: Type,
pub body: Stmt,
}
impl JITRunTime {
fn expr(kind: ExprKind) -> Expr {
Expr::new(kind, Span::default())
}
fn stmt(kind: StmtKind) -> Stmt {
Stmt::new(kind, Span::default())
}
pub fn load(&mut self, code: Vec<u8>, arg_name: SmolStr) -> Result<(i64, Type)> {
let stmts = Compiler::parse_code(code)?;
self.compiler.clear();
self.compiler.symbols.add_module("__console".into());
let mut cap = Capture::default();
let body = Self::stmt(StmtKind::Block(self.compiler.compile_fn(&[arg_name], &mut vec![Type::Any], Self::stmt(StmtKind::Block(stmts)), &mut cap)?));
self.compiler.tys.push(Type::Any);
let ret_ty = self.compiler.infer_stmt(&body)?;
self.compiler.clear();
let fn_id = self.compile_fn(None, &[Type::Any], ret_ty.clone(), &body)?;
self.compiler.clear();
self.compiler.symbols.pop_module();
self.module.finalize_definitions()?;
Ok((self.module.get_finalized_function(fn_id) as i64, ret_ty))
}
pub fn import_code(&mut self, name: &str, code: Vec<u8>) -> Result<()> {
log::info!("import {}", name);
let _ = self.compiler.import_code(name, code)?;
Ok(())
}
#[cfg(feature = "ir-disassembly")]
pub fn disassemble_ir(&mut self, name: &str) -> Result<String> {
if let Some(ir) = self.ir_disassembly.get(name) {
return Ok(ir.clone());
}
let id = self.get_id(name)?;
let (_, symbol) = self.compiler.symbols.get_symbol(id)?;
if let Symbol::Fn { ty, .. } = symbol
&& let Type::Fn { tys, .. } = ty
&& tys.is_empty()
{
let _ = self.gen_fn(None, id, &[])?;
}
self.ir_disassembly.get(name).cloned().ok_or_else(|| anyhow!("未找到函数 {} 的 Cranelift IR；如果它需要参数，请先触发对应实例化", name))
}
pub fn get_fn_ptr(&mut self, name: &str, arg_tys: &[Type]) -> Result<(*const u8, Type)> {
let main_id = self.get_id(name)?;
let fn_info = self.gen_fn(None, main_id, arg_tys)?;
Ok((self.module.get_finalized_function(fn_info.get_id()?), fn_info.get_type()?))
}
pub fn get_const_value(&mut self, ctx: &mut BuildContext, idx: usize) -> Result<(Value, Type)> {
if self.consts.len() < idx + 1 {
self.consts.resize(idx + 1, None);
}
let id = if let Some(id) = self.consts.get(idx).cloned().unwrap_or(None) {
id
} else {
let id = self.module.declare_anonymous_data(true, false)?;
let mut desc = DataDescription::new();
let c = Box::new(self.compiler.consts[idx].deep_clone()); let ptr = Box::into_raw(c);
desc.define((ptr as i64).to_le_bytes().into());
self.module.define_data(id, &desc)?;
self.consts[idx] = Some(id);
id
};
let c = self.module.declare_data_in_func(id, &mut ctx.builder.func);
let addr = ctx.builder.ins().global_value(ptr_type(), c);
let value = ctx.builder.ins().load(ptr_type(), MemFlags::new(), addr, 0); Ok((self.call(ctx, self.get_method(&Type::Any, "clone")?, vec![value])?.0, Type::Any))
}
fn get_null_value(&mut self, ctx: &mut BuildContext) -> Result<(Value, Type)> {
let const_idx = self.compiler.get_const(Dynamic::Null);
self.get_const_value(ctx, const_idx)
}
pub fn get_dynamic(&self, expr: &Expr) -> Option<Dynamic> {
if let ExprKind::Const(idx) = &expr.kind { self.compiler.consts.get(*idx).cloned() } else { None }
}
pub fn get_method(&self, ty: &Type, name: &str) -> Result<FnInfo> {
self.compiler.get_field(ty, name).and_then(|(_, ty)| if let Type::Symbol { id, params: _ } = ty { self.get_fn(id, &[]) } else { Err(anyhow!("不是成员函数")) })
}
pub fn get_id(&self, name: &str) -> Result<u32> {
self.compiler.symbols.get_id(name)
}
pub fn get_type(&mut self, name: &str, arg_tys: &[Type]) -> Result<Type> {
let id = self.get_id(name)?;
if self.compiler.symbols.symbols.get(name).map(|s| s.is_fn()).unwrap_or(false) {
return self.compiler.infer_fn(id, arg_tys);
}
self.compiler.symbols.get_type(&Type::Symbol { id, params: Vec::new() })
}
pub fn new<F: FnMut(&mut JITBuilder)>(mut f: F) -> Self {
let native_symbols = Arc::new(RwLock::new(HashMap::<String, usize>::new()));
let lookup_symbols = native_symbols.clone();
let mut builder = JITBuilder::new(cranelift_module::default_libcall_names()).unwrap();
builder.symbol_lookup_fn(Box::new(move |name| lookup_symbols.read().unwrap().get(name).copied().map(|ptr| ptr as *const u8)));
f(&mut builder);
let module = JITModule::new(builder);
PTR_TYPE.get_or_init(|| module.isa().pointer_type());
let fns = BTreeMap::<u32, FnVariant>::new();
Self {
compiler: Compiler::new(),
fns,
sigs: Vec::new(),
native_symbols,
pending_fns: VecDeque::new(),
compile_depth: 0,
#[cfg(feature = "ir-disassembly")]
ir_disassembly: BTreeMap::new(),
module,
consts: Vec::new(),
}
}
fn unary(ctx: &mut BuildContext, left: (Value, Type), op: UnaryOp) -> Result<(Value, Type)> {
match op {
UnaryOp::Neg => {
if left.1.is_int() || left.1.is_uint() {
if left.1.width() == 8 {
let zero = ctx.builder.ins().iconst(types::I64, 0);
return Ok((ctx.builder.ins().isub(zero, left.0), Type::I64));
} else if left.1.width() == 4 {
let zero = ctx.builder.ins().iconst(types::I32, 0);
return Ok((ctx.builder.ins().isub(zero, left.0), Type::I32));
}
} else if left.1.is_float() {
return Ok((ctx.builder.ins().fneg(left.0), left.1));
}
}
UnaryOp::Not => {
if left.1.is_any() {
return Err(anyhow!("defer any-bool not handling"));
}
let zero = ctx.builder.ins().iconst(types::I8, 0);
let one = ctx.builder.ins().iconst(types::I8, 1);
let is_zero = ctx.builder.ins().icmp_imm(IntCC::Equal, left.0, 0);
return Ok((ctx.builder.ins().select(is_zero, one, zero), Type::Bool));
}
_ => {}
}
Err(anyhow!("未实现 {:?} {:?}", left, op))
}
pub(crate) fn call(&mut self, ctx: &mut BuildContext, fn_info: FnInfo, args: Vec<Value>) -> Result<(Value, Type)> {
match fn_info {
FnInfo::Call { fn_id, arg_tys: _, caps: _, ret } => {
let fn_ref = self.get_fn_ref(ctx, fn_id);
let call_inst = ctx.builder.ins().call(fn_ref, &args);
if !ret.is_void() { Ok((ctx.builder.inst_results(call_inst)[0], ret)) } else { Err(anyhow!("没有返回值")) }
}
FnInfo::Inline { fn_ptr, arg_tys: _ } => fn_ptr(Some(ctx), args).map(|(v, t)| (v.unwrap(), t)),
}
}
fn call_for_side_effect(&mut self, ctx: &mut BuildContext, fn_info: FnInfo, args: Vec<Value>) -> Result<()> {
match fn_info {
FnInfo::Call { fn_id, arg_tys: _, caps: _, ret: _ } => {
let fn_ref = self.get_fn_ref(ctx, fn_id);
ctx.builder.ins().call(fn_ref, &args);
Ok(())
}
FnInfo::Inline { fn_ptr, arg_tys: _ } => fn_ptr(Some(ctx), args).map(|_| ()),
}
}
pub(crate) fn short_circuit_logic(&mut self, ctx: &mut BuildContext, left: (Value, Type), op: BinaryOp, right: &Expr) -> Result<(Value, Type)> {
let is_any = left.1.is_any();
if is_any {
let left_cond = self.bool_value(ctx, left.clone())?;
let rhs_block = ctx.builder.create_block();
let short_block = ctx.builder.create_block();
let end_block = ctx.builder.create_block();
ctx.builder.append_block_param(end_block, ptr_type());
match op {
BinaryOp::And => {
ctx.builder.ins().brif(left_cond, rhs_block, &[], short_block, &[]);
}
BinaryOp::Or => {
ctx.builder.ins().brif(left_cond, short_block, &[], rhs_block, &[]);
}
_ => unreachable!(),
}
ctx.builder.switch_to_block(rhs_block);
let right = self.eval(ctx, right)?.get(ctx).unwrap();
let right_any = self.convert(ctx, right, Type::Any)?;
ctx.builder.ins().jump(end_block, &[cranelift::codegen::ir::BlockArg::Value(right_any)]);
ctx.builder.seal_block(rhs_block);
ctx.builder.switch_to_block(short_block);
ctx.builder.ins().jump(end_block, &[cranelift::codegen::ir::BlockArg::Value(left.0)]);
ctx.builder.seal_block(short_block);
ctx.builder.switch_to_block(end_block);
let result = ctx.builder.block_params(end_block)[0];
Ok((result, Type::Any))
} else {
let left = self.bool_value(ctx, left)?;
let rhs_block = ctx.builder.create_block();
let short_block = ctx.builder.create_block();
let end_block = ctx.builder.create_block();
ctx.builder.append_block_param(end_block, types::I8);
match op {
BinaryOp::And => {
ctx.builder.ins().brif(left, rhs_block, &[], short_block, &[]);
}
BinaryOp::Or => {
ctx.builder.ins().brif(left, short_block, &[], rhs_block, &[]);
}
_ => unreachable!(),
}
ctx.builder.switch_to_block(rhs_block);
let right = self.eval(ctx, right)?.get(ctx).unwrap();
let right = self.bool_value(ctx, right)?;
ctx.builder.ins().jump(end_block, &[cranelift::codegen::ir::BlockArg::Value(right)]);
ctx.builder.seal_block(rhs_block);
ctx.builder.switch_to_block(short_block);
let short_value = match op {
BinaryOp::And => ctx.builder.ins().iconst(types::I8, 0),
BinaryOp::Or => ctx.builder.ins().iconst(types::I8, 1),
_ => unreachable!(),
};
ctx.builder.ins().jump(end_block, &[cranelift::codegen::ir::BlockArg::Value(short_value)]);
ctx.builder.seal_block(short_block);
ctx.builder.switch_to_block(end_block);
let result = ctx.builder.block_params(end_block)[0];
Ok((result, Type::Bool))
}
}
fn struct_alloc(&mut self, ctx: &mut BuildContext, ty: &Type) -> Result<Value> {
let size = ctx.builder.ins().iconst(types::I64, ty.width() as i64);
let alloc_id = self.get_id("__struct_alloc")?;
let alloc = self.get_fn(alloc_id, &[Type::I64])?;
self.call(ctx, alloc, vec![size]).map(|(v, _)| v)
}
fn store_struct_field(&mut self, ctx: &mut BuildContext, base: Value, idx: usize, field_ty: &Type, value: (Value, Type), struct_ty: &Type) -> Result<()> {
let offset = struct_ty.field_offset(idx).ok_or_else(|| anyhow!("结构字段索引越界 {}", idx))?;
let value = self.convert(ctx, value, field_ty.clone())?;
if field_ty.is_struct() || field_ty.is_array() {
let field_addr = ctx.builder.ins().iadd_imm(base, offset as i64);
self.copy_vec_element(ctx, field_addr, value, field_ty);
} else {
ctx.builder.ins().store(MemFlags::trusted(), value, base, offset as i32);
}
Ok(())
}
fn load_struct_field(&mut self, ctx: &mut BuildContext, base: Value, idx: usize, struct_ty: &Type) -> Result<(Value, Type)> {
if let Type::Struct { params: _, fields } = struct_ty {
let field_ty = fields.get(idx).map(|(_, ty)| ty).ok_or_else(|| anyhow!("结构字段索引越界 {}", idx))?;
let offset = struct_ty.field_offset(idx).ok_or_else(|| anyhow!("结构字段索引越界 {}", idx))?;
if field_ty.is_struct() || field_ty.is_array() {
return Ok((ctx.builder.ins().iadd_imm(base, offset as i64), field_ty.clone()));
}
let val = ctx.builder.ins().load(crate::get_type(field_ty)?, MemFlags::trusted(), base, offset as i32);
Ok((val, field_ty.clone()))
} else {
Err(anyhow!("不是结构体 {:?}", struct_ty))
}
}
fn struct_field_index(&self, struct_ty: &Type, right: &Expr) -> Result<usize> {
let value = if let ExprKind::Const(idx) = right.kind { self.compiler.consts.get(idx).cloned().ok_or_else(|| anyhow!("missing const {}", idx))? } else { right.clone().value()? };
if let Some(idx) = value.as_int() {
return usize::try_from(idx).map_err(|_| anyhow!("结构字段索引越界 {}", idx));
}
if value.is_str() {
return self.compiler.get_field(struct_ty, value.as_str()).map(|(idx, _)| idx);
}
Err(anyhow!("非立即数结构字段索引 {:?}", right))
}
fn vec_elem_ty(ty: &Type) -> Option<Type> {
if let Type::Vec(elem, 0) = ty { Some((**elem).clone()) } else { None }
}
fn array_elem_ty(ty: &Type) -> Option<Type> {
if let Type::Array(elem, _) = ty { Some((**elem).clone()) } else { None }
}
fn vec_index_addr(&mut self, ctx: &mut BuildContext, base: Value, idx: (Value, Type), elem_ty: &Type) -> Result<Value> {
let idx = self.convert(ctx, idx, Type::I64)?;
let width = ctx.builder.ins().iconst(types::I64, elem_ty.storage_width() as i64);
let offset = ctx.builder.ins().imul(idx, width);
Ok(ctx.builder.ins().iadd(base, offset))
}
fn array_index_addr(&mut self, ctx: &mut BuildContext, base: Value, idx: (Value, Type), elem_ty: &Type) -> Result<Value> {
self.vec_index_addr(ctx, base, idx, elem_ty)
}
fn load_array_index(&mut self, ctx: &mut BuildContext, base: Value, idx: (Value, Type), elem_ty: &Type) -> Result<(Value, Type)> {
let addr = self.array_index_addr(ctx, base, idx, elem_ty)?;
if elem_ty.is_struct() || elem_ty.is_array() {
Ok((addr, elem_ty.clone()))
} else {
let val = ctx.builder.ins().load(crate::get_type(elem_ty)?, MemFlags::trusted(), addr, 0);
Ok((val, elem_ty.clone()))
}
}
fn store_array_index(&mut self, ctx: &mut BuildContext, base: Value, idx: (Value, Type), elem_ty: &Type, value: (Value, Type)) -> Result<()> {
let addr = self.array_index_addr(ctx, base, idx, elem_ty)?;
let value = self.convert(ctx, value, elem_ty.clone())?;
if elem_ty.is_struct() || elem_ty.is_array() {
self.copy_vec_element(ctx, addr, value, elem_ty);
} else {
ctx.builder.ins().store(MemFlags::trusted(), value, addr, 0);
}
Ok(())
}
fn init_repeat_array(&mut self, ctx: &mut BuildContext, value: (Value, Type), len: u32) -> Result<(Value, Type)> {
let elem_ty = value.1.clone();
let array_ty = Type::Array(std::rc::Rc::new(elem_ty.clone()), len);
let base = self.struct_alloc(ctx, &array_ty)?;
for idx in 0..len {
let idx = (ctx.builder.ins().iconst(types::I64, idx as i64), Type::I64);
self.store_array_index(ctx, base, idx, &elem_ty, value.clone())?;
}
Ok((base, array_ty))
}
fn init_array_from_items(&mut self, ctx: &mut BuildContext, items: &[Expr], ty: &Type) -> Result<Value> {
let Type::Array(elem_ty, len) = ty else {
return Err(anyhow!("not an array type: {:?}", ty));
};
if items.len() != *len as usize {
return Err(anyhow!("array literal length {} does not match {}", items.len(), len));
}
let base = self.struct_alloc(ctx, ty)?;
for (idx, item) in items.iter().enumerate() {
let value = self.eval(ctx, item)?.get(ctx).ok_or(anyhow!("array item has no value"))?;
let idx = (ctx.builder.ins().iconst(types::I64, idx as i64), Type::I64);
self.store_array_index(ctx, base, idx, elem_ty, value)?;
}
Ok(base)
}
fn load_vec_index(&mut self, ctx: &mut BuildContext, base: Value, idx: (Value, Type), elem_ty: &Type) -> Result<(Value, Type)> {
let addr = self.vec_index_addr(ctx, base, idx, elem_ty)?;
if elem_ty.is_struct() {
Ok((addr, elem_ty.clone()))
} else {
let val = ctx.builder.ins().load(crate::get_type(elem_ty)?, MemFlags::trusted(), addr, 0);
Ok((val, elem_ty.clone()))
}
}
fn copy_vec_element(&mut self, ctx: &mut BuildContext, dst: Value, src: Value, elem_ty: &Type) {
let mut offset = 0u32;
let width = elem_ty.storage_width();
while offset < width {
let remaining = width - offset;
let (ty, size) = if remaining >= 8 {
(types::I64, 8)
} else if remaining >= 4 {
(types::I32, 4)
} else if remaining >= 2 {
(types::I16, 2)
} else {
(types::I8, 1)
};
let value = ctx.builder.ins().load(ty, MemFlags::trusted(), src, offset as i32);
ctx.builder.ins().store(MemFlags::trusted(), value, dst, offset as i32);
offset += size;
}
}
fn store_vec_index(&mut self, ctx: &mut BuildContext, base: Value, idx: (Value, Type), elem_ty: &Type, value: (Value, Type)) -> Result<()> {
let addr = self.vec_index_addr(ctx, base, idx, elem_ty)?;
let value = self.convert(ctx, value, elem_ty.clone())?;
if elem_ty.is_struct() {
self.copy_vec_element(ctx, addr, value, elem_ty);
} else {
ctx.builder.ins().store(MemFlags::trusted(), value, addr, 0);
}
Ok(())
}
fn swap_vec_index(&mut self, ctx: &mut BuildContext, base: Value, left: (Value, Type), right: (Value, Type), elem_ty: &Type) -> Result<()> {
let left_addr = self.vec_index_addr(ctx, base, left, elem_ty)?;
let right_addr = self.vec_index_addr(ctx, base, right, elem_ty)?;
let mut offset = 0u32;
let width = elem_ty.storage_width();
while offset < width {
let remaining = width - offset;
let (ty, size) = if remaining >= 8 {
(types::I64, 8)
} else if remaining >= 4 {
(types::I32, 4)
} else if remaining >= 2 {
(types::I16, 2)
} else {
(types::I8, 1)
};
let left_value = ctx.builder.ins().load(ty, MemFlags::trusted(), left_addr, offset as i32);
let right_value = ctx.builder.ins().load(ty, MemFlags::trusted(), right_addr, offset as i32);
ctx.builder.ins().store(MemFlags::trusted(), left_value, right_addr, offset as i32);
ctx.builder.ins().store(MemFlags::trusted(), right_value, left_addr, offset as i32);
offset += size;
}
Ok(())
}
fn init_struct_from_dynamic(&mut self, ctx: &mut BuildContext, value: (Value, Type), ty: &Type) -> Result<Value> {
let Type::Struct { params: _, fields } = ty else {
return Err(anyhow!("不是结构体 {:?}", ty));
};
let base = self.struct_alloc(ctx, ty)?;
for (idx, (_, field_ty)) in fields.iter().enumerate() {
let idx_val = ctx.builder.ins().iconst(types::I64, idx as i64);
let item = self.call(ctx, self.get_method(&Type::Any, "get_idx")?, vec![value.0, idx_val])?;
self.store_struct_field(ctx, base, idx, field_ty, item, ty)?;
}
Ok(base)
}
fn init_struct_from_items(&mut self, ctx: &mut BuildContext, items: &[Expr], ty: &Type) -> Result<Value> {
let Type::Struct { params: _, fields } = ty else {
return Err(anyhow!("not a struct type: {:?}", ty));
};
let base = self.struct_alloc(ctx, ty)?;
for (idx, item) in items.iter().enumerate() {
let Some((_, field_ty)) = fields.get(idx) else {
break;
};
let value = self.eval(ctx, item)?.get(ctx).ok_or(anyhow!("struct field has no value"))?;
self.store_struct_field(ctx, base, idx, field_ty, value, ty)?;
}
Ok(base)
}
fn expr_assigned_var(expr: &Expr) -> Option<(u32, Type)> {
if let ExprKind::Binary { left, op, right } = &expr.kind
&& op.is_assign()
&& let ExprKind::Var(idx) = left.kind
{
return Some((idx, right.get_type()));
}
None
}
fn declare_assigned_vars(&mut self, ctx: &mut BuildContext, stmt: &Stmt) -> Result<()> {
match &stmt.kind {
StmtKind::Expr(expr, _) => {
if let Some((idx, ty)) = Self::expr_assigned_var(expr) {
match ctx.get_var(idx).ok() {
Some(LocalVar::Variable { .. }) | Some(LocalVar::Closure { .. }) => {}
Some(LocalVar::Value { val, ty }) => {
ctx.set_var(idx, LocalVar::Value { val, ty })?;
}
Some(LocalVar::None) | None => {
let init = self.zero_value(ctx, &ty)?;
ctx.set_var(idx, init.into())?;
}
}
}
}
StmtKind::Block(stmts) => {
for stmt in stmts {
self.declare_assigned_vars(ctx, stmt)?;
}
}
StmtKind::If { then_body, else_body, .. } => {
self.declare_assigned_vars(ctx, then_body)?;
if let Some(else_body) = else_body {
self.declare_assigned_vars(ctx, else_body)?;
}
}
StmtKind::While { body, .. } | StmtKind::Loop(body) => {
self.declare_assigned_vars(ctx, body)?;
}
StmtKind::For { body, .. } => {
self.declare_assigned_vars(ctx, body)?;
}
_ => {}
}
Ok(())
}
fn zero_value(&mut self, ctx: &mut BuildContext, ty: &Type) -> Result<(Value, Type)> {
if ty.is_struct() || ty.is_array() {
Ok((self.struct_alloc(ctx, ty)?, ty.clone()))
} else if ty.is_f32() {
Ok((ctx.builder.ins().f32const(0.0), ty.clone()))
} else if ty.is_f64() {
Ok((ctx.builder.ins().f64const(0.0), ty.clone()))
} else {
Ok((ctx.builder.ins().iconst(crate::get_type(ty)?, 0), ty.clone()))
}
}
fn assign(&mut self, ctx: &mut BuildContext, left: &Expr, value: LocalVar) -> Result<(Value, Type)> {
if let ExprKind::Var(idx) = &left.kind {
if value.is_closure() {
ctx.set_var(*idx, value)?;
return self.get_null_value(ctx);
}
let value_ty = value.get_ty();
if let Some(ty) = ctx.get_var_ty(*idx) {
if ty.is_struct() || ty.is_array() {
let dst = ctx.get_var(*idx)?.get(ctx).ok_or(anyhow!("aggregate variable has no value"))?.0;
let src = value.get(ctx).ok_or(anyhow!("aggregate assignment has no value"))?;
let src = self.convert(ctx, src, ty.clone())?;
self.copy_vec_element(ctx, dst, src, &ty);
} else if value_ty != ty {
if let Some(vt) = value.get(ctx) {
let val = self.convert(ctx, vt, ty.clone())?;
ctx.set_var(*idx, LocalVar::Value { val, ty })?;
} else if ty.is_any() {
let const_idx = self.compiler.get_const(Dynamic::Null);
let (val, ty) = self.get_const_value(ctx, const_idx)?;
ctx.set_var(*idx, LocalVar::Value { val, ty })?;
} else {
ctx.set_var(*idx, LocalVar::None)?;
}
} else {
ctx.set_var(*idx, value)?;
}
} else if value_ty.is_struct() || value_ty.is_array() {
let src = value.get(ctx).ok_or(anyhow!("aggregate initializer has no value"))?;
let dst = self.struct_alloc(ctx, &value_ty)?;
let src = self.convert(ctx, src, value_ty.clone())?;
self.copy_vec_element(ctx, dst, src, &value_ty);
ctx.set_var(*idx, LocalVar::Value { val: dst, ty: value_ty })?;
} else {
ctx.set_var(*idx, value)?;
}
let assigned = ctx.get_var(*idx)?;
if assigned.is_closure() {
return self.get_null_value(ctx);
}
let val = assigned.get(ctx).ok_or(anyhow!("assigned variable has no value"))?;
return Ok(val);
} else if left.is_idx() {
let value = value.get(ctx).unwrap();
let (left, _, right) = left.clone().binary().unwrap();
let left = self.eval(ctx, &left)?.get(ctx).ok_or(anyhow!("未知局部变量 {:?}", left))?;
if let Type::Struct { params: _, fields } = &left.1 {
let idx = self.struct_field_index(&left.1, &right)?;
let field_ty = fields.get(idx).map(|(_, ty)| ty.clone()).ok_or_else(|| anyhow!("结构字段索引越界 {}", idx))?;
self.store_struct_field(ctx, left.0, idx, &field_ty, value.clone(), &left.1)?;
return Ok(value);
}
if let Some(elem_ty) = Self::vec_elem_ty(&left.1) {
let idx = if right.is_value() {
let idx = right.clone().value()?.as_int().ok_or(anyhow!("Vec 索引必须是整数"))?;
(ctx.builder.ins().iconst(types::I64, idx), Type::I64)
} else {
self.eval(ctx, &right)?.get(ctx).ok_or(anyhow!("Vec 索引没有值"))?
};
self.store_vec_index(ctx, left.0, idx, &elem_ty, value.clone())?;
return Ok(value);
}
if let Some(elem_ty) = Self::array_elem_ty(&left.1) {
let idx = if right.is_value() {
let idx = right.clone().value()?.as_int().ok_or(anyhow!("array index must be integer"))?;
(ctx.builder.ins().iconst(types::I64, idx), Type::I64)
} else {
self.eval(ctx, &right)?.get(ctx).ok_or(anyhow!("array index has no value"))?
};
self.store_array_index(ctx, left.0, idx, &elem_ty, value.clone())?;
return Ok(value);
}
if right.is_value() {
let right_value = right.clone().value()?;
if let Some(idx) = right_value.as_int() {
let idx = ctx.builder.ins().iconst(types::I64, idx);
let f = self.get_method(&left.1, "set_idx")?;
let args = self.adjust_args(ctx, vec![left, (idx, Type::I64), value.clone()], f.arg_tys()?)?;
self.call_for_side_effect(ctx, f, args)?;
} else {
let key = ctx.get_const(&right_value)?;
let f = self.get_method(&left.1, "set_key")?;
let args = self.adjust_args(ctx, vec![left, key, value.clone()], f.arg_tys()?)?;
self.call_for_side_effect(ctx, f, args)?;
}
} else {
let right = self.eval(ctx, &right)?.get(ctx).unwrap();
if right.1.is_any() {
let f = self.get_method(&left.1, "set_key")?;
let args = self.adjust_args(ctx, vec![left, right, value.clone()], f.arg_tys()?)?;
self.call_for_side_effect(ctx, f, args)?;
} else {
let f = self.get_method(&left.1, "set_idx")?;
let args = self.adjust_args(ctx, vec![left, right, value.clone()], f.arg_tys()?)?;
self.call_for_side_effect(ctx, f, args)?;
}
}
return Ok(value);
} else {
panic!("赋值给 {:?} {:?}", left, value)
}
}
fn closure_value(&self, ctx: &mut BuildContext, id: u32) -> Result<LocalVar> {
let captures = match self.compiler.symbols.get_symbol(id)?.1 {
Symbol::Fn { cap, .. } => cap.vars.iter().map(|idx| ctx.get_var(*idx as u32)?.get(ctx).ok_or_else(|| anyhow!("捕获变量 {} 没有值", idx))).collect::<Result<Vec<_>>>()?,
_ => Vec::new(),
};
Ok(LocalVar::Closure { id, captures })
}
pub(crate) fn call_fn(&mut self, ctx: &mut BuildContext, id: u32, obj: Option<Expr>, params: &Vec<Expr>) -> Result<LocalVar> {
self.call_fn_with_params(ctx, id, &[], obj, params)
}
pub(crate) fn call_fn_with_params(&mut self, ctx: &mut BuildContext, id: u32, generic_args: &[Type], obj: Option<Expr>, params: &Vec<Expr>) -> Result<LocalVar> {
self.call_fn_with_capture_values(ctx, id, generic_args, obj, params, None)
}
pub(crate) fn call_fn_with_capture_values(&mut self, ctx: &mut BuildContext, id: u32, generic_args: &[Type], obj: Option<Expr>, params: &Vec<Expr>, capture_values: Option<Vec<(Value, Type)>>) -> Result<LocalVar> {
let mut args: Vec<(Value, Type)> = if let Some(obj) = obj { vec![self.eval(ctx, &obj)?.get(ctx).unwrap()] } else { Vec::new() };
for p in params {
args.push(self.eval(ctx, p)?.get(ctx).unwrap());
}
if let Some(captures) = &capture_values {
args.extend(captures.iter().cloned());
}
let fn_name = self.compiler.symbols.get_symbol(id).map(|(name, _)| name.clone())?;
if fn_name.as_str().ends_with("Vec::swap")
&& let Some((base, vec_ty)) = args.first().cloned()
&& let Some(elem_ty) = Self::vec_elem_ty(&vec_ty)
{
let [_, left_idx, right_idx]: [(Value, Type); 3] = args.try_into().map_err(|_| anyhow!("Vec::swap 需要 self 和两个索引参数"))?;
self.swap_vec_index(ctx, base, left_idx, right_idx, &elem_ty)?;
return Ok(LocalVar::None);
}
let visible_arg_len = args.len() - capture_values.as_ref().map(|captures| captures.len()).unwrap_or(0);
let arg_tys: Vec<Type> = args.iter().take(visible_arg_len).map(|(_, ty)| ty.clone()).collect();
let fn_info = match if generic_args.is_empty() { self.get_fn(id, &arg_tys) } else { Err(anyhow!("generic function needs specialization")) } {
Ok(info) => info,
Err(_) => self.gen_fn_with_params(Some(ctx), id, &arg_tys, generic_args).map_err(|e| {
log::error!("{:?}", self.compiler.symbols.get_symbol(id));
e
})?,
};
match &fn_info {
FnInfo::Call { fn_id: _, arg_tys: want_tys, caps, ret } => {
let mut args = self.adjust_args(ctx, args, want_tys)?;
if capture_values.is_none() {
for c in caps {
args.push(ctx.get_var(*c as u32)?.get(ctx).unwrap().0);
}
}
if ret.is_void() {
self.call_for_side_effect(ctx, fn_info, args)?;
Ok(LocalVar::None)
} else {
self.call(ctx, fn_info, args).map(|r| r.into())
}
}
_ => panic!("不可能编译出 inline 函数"),
}
}
pub(crate) fn eval(&mut self, ctx: &mut BuildContext, expr: &Expr) -> Result<LocalVar> {
match &expr.kind {
ExprKind::Value(v) => Ok(ctx.get_const(v)?.into()),
ExprKind::Var(idx) => {
let v = ctx.get_var(*idx)?;
Ok(v)
}
ExprKind::Unary { op, value } => {
let v = self.eval(ctx, value)?.get(ctx).unwrap();
if op == &UnaryOp::Not {
let cond = self.bool_value(ctx, v)?;
let zero = ctx.builder.ins().iconst(types::I8, 0);
let one = ctx.builder.ins().iconst(types::I8, 1);
let is_zero = ctx.builder.ins().icmp_imm(IntCC::Equal, cond, 0);
Ok((ctx.builder.ins().select(is_zero, one, zero), Type::Bool).into())
} else {
Ok(Self::unary(ctx, v, op.clone())?.into())
}
}
ExprKind::Binary { left, op, right } => {
if op == &BinaryOp::Assign {
match self.eval(ctx, right) {
Ok(value) => self.assign(ctx, left, value).map(|v| v.into()),
Err(e) => {
log::error!("assign error {:?}", e);
Err(e)
}
}
} else {
let assign_expr = if op.is_assign() { Some(left.clone()) } else { None };
let left = match self.eval(ctx, left)?.get(ctx) {
Some(left) => left,
None if matches!(op, BinaryOp::And | BinaryOp::Or) => self.get_null_value(ctx)?,
None => return Err(anyhow!("binary left has no value: {:?}", left)),
};
if op == &BinaryOp::Idx {
if let Type::Struct { params: _, fields: _ } = &left.1 {
let idx = self.struct_field_index(&left.1, right)?;
return self.load_struct_field(ctx, left.0, idx, &left.1).map(|r| r.into());
}
if let Some(elem_ty) = Self::vec_elem_ty(&left.1) {
let idx = if right.is_value() {
let idx = right.clone().value()?.as_int().ok_or(anyhow!("Vec 索引必须是整数"))?;
(ctx.builder.ins().iconst(types::I64, idx), Type::I64)
} else {
self.eval(ctx, right)?.get(ctx).ok_or(anyhow!("Vec 索引没有值"))?
};
return self.load_vec_index(ctx, left.0, idx, &elem_ty).map(|r| r.into());
}
if let Some(elem_ty) = Self::array_elem_ty(&left.1) {
let idx = if right.is_value() {
let idx = right.clone().value()?.as_int().ok_or(anyhow!("array index must be integer"))?;
(ctx.builder.ins().iconst(types::I64, idx), Type::I64)
} else {
self.eval(ctx, right)?.get(ctx).ok_or(anyhow!("array index has no value"))?
};
return self.load_array_index(ctx, left.0, idx, &elem_ty).map(|r| r.into());
}
if right.is_value() {
let right_value = right.clone().value()?;
if let Some(idx) = right_value.as_int() {
let idx = ctx.builder.ins().iconst(types::I64, idx);
self.call(ctx, self.get_method(&left.1, "get_idx")?, vec![left.0, idx]).map(|r| r.into())
} else {
let key = ctx.get_const(&right_value)?;
self.call(ctx, self.get_method(&left.1, "get_key")?, vec![left.0, key.0]).map(|r| r.into())
}
} else if let ExprKind::Range { start, stop, inclusive } = &right.kind {
let start = self.eval(ctx, start)?.get(ctx).ok_or(anyhow!("range start has no value"))?;
let start = self.convert(ctx, start, Type::I64)?;
let stop = self.eval(ctx, stop)?.get(ctx).ok_or(anyhow!("range stop has no value"))?;
let stop = self.convert(ctx, stop, Type::Any)?;
let inclusive = ctx.builder.ins().iconst(types::I8, i64::from(*inclusive));
self.call(ctx, self.get_method(&left.1, "slice")?, vec![left.0, start, stop, inclusive]).map(|r| r.into())
} else {
let right = self.eval(ctx, right)?.get(ctx).ok_or(anyhow!("非Value {:?}", right))?;
if right.1.is_any() {
self.call(ctx, self.get_method(&left.1, "get_key")?, vec![left.0, right.0]).map(|r| r.into())
} else {
let right = self.convert(ctx, right, Type::I64)?;
self.call(ctx, self.get_method(&left.1, "get_idx")?, vec![left.0, right]).map(|r| r.into())
}
}
} else {
let result = self.binary(ctx, left, op.clone(), right)?.into();
if let Some(expr) = assign_expr { self.assign(ctx, &expr, result).map(|r| r.into()) } else { Ok(result.into()) }
}
}
}
ExprKind::Call { obj, params } => {
if let ExprKind::AssocId { id, params: generic_args } = &obj.kind {
self.call_fn_with_params(ctx, *id, generic_args, None, params)
} else if let ExprKind::Id(id, obj) = &obj.kind {
self.call_fn(ctx, *id, obj.as_ref().map(|o| *o.clone()), params)
} else if obj.is_value() {
return Ok(LocalVar::None);
} else {
if obj.is_idx() {
let (left, _, right) = obj.clone().binary().unwrap();
let left = self.eval(ctx, &left)?.get(ctx).ok_or(anyhow!("obj {:?}", obj))?;
let ty = self.compiler.symbols.get_type(&left.1)?;
if let Some(name) = self.get_dynamic(&right) {
if name.as_str() == "swap"
&& let Some(elem_ty) = Self::vec_elem_ty(&ty)
{
let [left_idx, right_idx]: [(Value, Type); 2] =
params.iter().map(|p| self.eval(ctx, p)?.get(ctx).ok_or(anyhow!("Vec::swap 参数没有值"))).collect::<Result<Vec<_>>>()?.try_into().map_err(|_| anyhow!("Vec::swap 需要两个索引参数"))?;
self.swap_vec_index(ctx, left.0, left_idx, right_idx, &elem_ty)?;
return Ok(LocalVar::None);
}
let mut args = vec![left];
for p in params {
args.push(self.eval(ctx, p)?.get(ctx).unwrap());
}
let (_, method_ty) = self.compiler.get_field(&ty, name.as_str())?;
let Type::Symbol { id, .. } = method_ty else {
return Err(anyhow!("不是成员函数"));
};
let arg_tys: Vec<Type> = args.iter().map(|(_, ty)| ty.clone()).collect();
let method = self.get_fn(id, &arg_tys).or_else(|_| self.gen_fn_with_params(Some(ctx), id, &arg_tys, &[]))?;
let args = self.adjust_args(ctx, args, method.arg_tys()?)?;
self.call(ctx, method, args).map(|r| r.into())
} else {
self.eval(ctx, obj)
}
} else {
let val = self.eval(ctx, obj)?;
if let LocalVar::Closure { id, captures } = val {
return self.call_fn_with_capture_values(ctx, id, &[], None, params, Some(captures));
}
panic!("暂未实现 {:?}", val)
}
}
}
ExprKind::Typed { value, ty } => {
if let Type::Struct { params: _, fields: _ } = ty
&& let ExprKind::List(items) = &value.kind
{
return Ok((self.init_struct_from_items(ctx, items, ty)?, ty.clone()).into());
}
if let Type::Array(_, _) = ty
&& let ExprKind::List(items) = &value.kind
{
return Ok((self.init_array_from_items(ctx, items, ty)?, ty.clone()).into());
}
let evaluated = self.eval(ctx, value)?;
if evaluated.is_closure() {
return Ok(evaluated);
}
let vt = if let Some(vt) = evaluated.get(ctx) {
vt
} else if ty.is_any() {
let idx = self.compiler.get_const(Dynamic::Null);
self.get_const_value(ctx, idx)?
} else {
return Ok(LocalVar::None);
};
if let Type::Struct { params: _, fields: _ } = ty {
if &vt.1 == ty {
Ok(vt.into())
} else if vt.1.is_any() {
Ok((self.init_struct_from_dynamic(ctx, vt, ty)?, ty.clone()).into())
} else {
Err(anyhow!("cannot convert {:?} to {:?}", vt.1, ty))
}
} else if &vt.1 != ty {
Ok((self.convert(ctx, vt, ty.clone())?, ty.clone()).into())
} else {
Ok(vt.into())
}
}
ExprKind::List(_) => Err(anyhow!("未实现 {:?}", expr)),
ExprKind::Repeat { value, len } => {
let value = self.eval(ctx, value)?.get(ctx).ok_or(anyhow!("repeat value has no value"))?;
let Type::ConstInt(len) = len else {
return Err(anyhow!("repeat length must be a compile-time integer"));
};
let len = u32::try_from(*len).map_err(|_| anyhow!("repeat length out of range"))?;
self.init_repeat_array(ctx, value, len).map(|r| r.into())
}
ExprKind::Const(idx) => self.get_const_value(ctx, *idx).map(|v| v.into()),
ExprKind::Id(id, _) => self.closure_value(ctx, *id),
ExprKind::AssocId { id, .. } => self.closure_value(ctx, *id),
expr => {
panic!("未实现 {:?}", expr)
}
}
}
fn gen_loop(&mut self, ctx: &mut BuildContext, cond: Option<&Expr>, body: &Stmt, f: Option<impl FnMut(&mut BuildContext)>) -> Result<()> {
let loop_block = ctx.builder.create_block();
let end_block = ctx.builder.create_block();
if let Some(cond) = cond {
let start_block = ctx.builder.create_block();
ctx.builder.ins().jump(start_block, &[]);
ctx.builder.switch_to_block(start_block);
let cond = self.eval(ctx, cond)?.get(ctx).unwrap();
let cond = self.bool_value(ctx, cond)?;
let continue_block = if f.is_some() { ctx.builder.create_block() } else { start_block };
ctx.builder.ins().brif(cond, loop_block, &[], end_block, &[]);
ctx.builder.switch_to_block(loop_block);
let body_terminated = self.gen_stmt(ctx, body, Some(end_block), Some(continue_block))?;
if !body_terminated {
ctx.builder.ins().jump(continue_block, &[]);
}
ctx.builder.seal_block(loop_block);
f.map(|mut f| {
ctx.builder.switch_to_block(continue_block);
f(ctx);
ctx.builder.ins().jump(start_block, &[]);
ctx.builder.seal_block(continue_block);
});
} else {
ctx.builder.ins().jump(loop_block, &[]);
ctx.builder.switch_to_block(loop_block);
let body_terminated = self.gen_stmt(ctx, body, Some(end_block), Some(loop_block))?;
if !body_terminated {
ctx.builder.ins().jump(loop_block, &[]);
}
ctx.builder.seal_block(loop_block);
}
ctx.builder.switch_to_block(end_block);
Ok(())
}
pub(crate) fn gen_stmt(&mut self, ctx: &mut BuildContext, stmt: &Stmt, break_block: Option<Block>, continue_block: Option<Block>) -> Result<bool> {
match &stmt.kind {
StmtKind::Expr(expr, _) => {
let _ = self.eval(ctx, expr)?;
}
StmtKind::Break => {
ctx.builder.ins().jump(break_block.unwrap(), &[]);
return Ok(true);
}
StmtKind::Continue => {
ctx.builder.ins().jump(continue_block.unwrap(), &[]);
return Ok(true);
}
StmtKind::Return(expr) => {
if let Some(expr) = expr {
let value = self.eval(ctx, expr)?;
if let Some((r, _)) = value.get(ctx) {
ctx.builder.ins().return_(&[r]);
} else {
ctx.builder.ins().return_(&[]);
}
} else {
ctx.builder.ins().return_(&[]);
}
return Ok(true);
}
StmtKind::If { cond, then_body, else_body } => {
self.declare_assigned_vars(ctx, then_body)?;
if let Some(else_body) = else_body {
self.declare_assigned_vars(ctx, else_body)?;
}
let then_block = ctx.builder.create_block();
let cond = self.eval(ctx, cond)?.get(ctx).ok_or(anyhow!("未知的条件 {:?}", cond))?;
let cond = self.bool_value(ctx, cond)?;
let mut end_block = None;
if let Some(else_body) = else_body {
let else_block = ctx.builder.create_block();
ctx.builder.ins().brif(cond, then_block, &[], else_block, &[]);
ctx.builder.switch_to_block(then_block);
if !self.gen_stmt(ctx, then_body, break_block, continue_block)? {
let block = ctx.builder.create_block();
ctx.builder.ins().jump(block, &[]);
end_block = Some(block);
}
ctx.builder.switch_to_block(else_block);
if !self.gen_stmt(ctx, else_body, break_block, continue_block)? {
if end_block.is_none() {
end_block = Some(ctx.builder.create_block());
}
ctx.builder.ins().jump(end_block.unwrap(), &[]);
}
ctx.builder.seal_block(else_block);
} else {
let block = ctx.builder.create_block();
ctx.builder.ins().brif(cond, then_block, &[], block, &[]);
end_block = Some(block);
ctx.builder.switch_to_block(then_block);
if !self.gen_stmt(ctx, then_body, break_block, continue_block)? {
ctx.builder.ins().jump(end_block.unwrap(), &[]); }
}
if let Some(block) = end_block {
ctx.builder.switch_to_block(block);
}
ctx.builder.seal_block(then_block);
return Ok(end_block.is_none());
}
StmtKind::Block(stmts) => {
for (idx, stmt) in stmts.iter().enumerate() {
let r = self.gen_stmt(ctx, stmt, break_block, continue_block)?;
if idx == stmts.len() - 1 {
return Ok(r);
}
}
}
StmtKind::While { cond, body } => {
self.declare_assigned_vars(ctx, body)?;
let no_loop: Option<fn(&mut BuildContext)> = None;
self.gen_loop(ctx, Some(cond), body, no_loop)?;
}
StmtKind::Loop(body) => {
self.declare_assigned_vars(ctx, body)?;
let no_loop: Option<fn(&mut BuildContext)> = None;
self.gen_loop(ctx, None, body, no_loop)?;
}
StmtKind::For { pat, range, body } => {
if let ExprKind::Range { start, stop, inclusive } = &range.kind {
if let PatternKind::Var { idx, .. } = &pat.kind {
let start = self.eval(ctx, start)?;
ctx.set_var(*idx, start)?;
self.declare_assigned_vars(ctx, body)?;
let op = if *inclusive { BinaryOp::Le } else { BinaryOp::Lt };
let cond = Self::expr(ExprKind::Binary { left: Box::new(Self::expr(ExprKind::Var(*idx))), op, right: Box::new(stop.as_ref().clone()) });
self.gen_loop(
ctx,
Some(&cond),
body,
Some(|ctx: &mut BuildContext| {
let v = ctx.get_var(*idx).unwrap().get(ctx).unwrap();
let step = if v.1 == Type::I64 {
ctx.builder.ins().iconst(types::I64, 1)
} else if v.1 == Type::I32 {
ctx.builder.ins().iconst(types::I32, 1)
} else {
panic!("{:?} 不能作为增量", v.1)
};
let vt = (ctx.builder.ins().iadd(v.0, step), v.1).into();
let _ = ctx.set_var(*idx, vt);
}),
)?;
}
} else if let PatternKind::Var { idx, .. } = &pat.kind {
let vt = self.eval(ctx, range)?.get(ctx).unwrap();
if vt.1.is_any() {
let iter = self.call(ctx, self.get_method(&vt.1, "iter")?, vec![vt.0])?;
let next = self.get_method(&vt.1, "next")?;
let next_id = next.get_id()?;
let start = self.call(ctx, next, vec![iter.0])?;
ctx.set_var(*idx, start.into())?;
let cond = Self::expr(ExprKind::Binary { left: Box::new(Self::expr(ExprKind::Var(*idx))), op: BinaryOp::Ne, right: Box::new(Self::expr(ExprKind::Value(Dynamic::Null))) });
self.gen_loop(
ctx,
Some(&cond),
body,
Some(|ctx: &mut BuildContext| {
let fn_ref = ctx.get_fn_ref(next_id).unwrap();
let call_inst = ctx.builder.ins().call(fn_ref, &[iter.0]);
let ret = ctx.builder.inst_results(call_inst)[0];
let _ = ctx.set_var(*idx, (ret, Type::Any).into());
}),
)?;
}
} else if let PatternKind::Tuple(pats) = &pat.kind {
let vt = self.eval(ctx, range)?.get(ctx).unwrap();
if vt.1.is_any() && pats.len() == 2 {
let iter = self.call(ctx, self.get_method(&vt.1, "iter")?, vec![vt.0])?;
let next = self.get_method(&vt.1, "next")?;
let next_id = next.get_id()?;
let get_idx = self.get_method(&vt.1, "get_idx")?.get_id()?;
let start = self.call(ctx, next, vec![iter.0])?;
let key_idx = ctx.builder.ins().iconst(types::I64, 0);
let key = self.call(ctx, self.get_method(&start.1, "get_idx")?, vec![start.0, key_idx])?;
let value_idx = ctx.builder.ins().iconst(types::I64, 1);
let value = self.call(ctx, self.get_method(&start.1, "get_idx")?, vec![start.0, value_idx])?;
ctx.set_var(pats[0].var().unwrap(), key.into())?;
ctx.set_var(pats[1].var().unwrap(), value.into())?;
let cond = Self::expr(ExprKind::Binary { left: Box::new(Self::expr(ExprKind::Var(pats[0].var().unwrap()))), op: BinaryOp::Ne, right: Box::new(Self::expr(ExprKind::Value(Dynamic::Null))) });
self.gen_loop(
ctx,
Some(&cond),
body,
Some(|ctx: &mut BuildContext| {
let fn_ref = ctx.get_fn_ref(next_id).unwrap();
let call_inst = ctx.builder.ins().call(fn_ref, &[iter.0]);
let ret = ctx.builder.inst_results(call_inst)[0];
let fn_ref = ctx.get_fn_ref(get_idx).unwrap();
let call_inst = ctx.builder.ins().call(fn_ref, &[ret, key_idx]);
let key_ret = ctx.builder.inst_results(call_inst)[0];
let call_inst = ctx.builder.ins().call(fn_ref, &[ret, value_idx]);
let value_ret = ctx.builder.inst_results(call_inst)[0];
let _ = ctx.set_var(pats[0].var().unwrap(), (key_ret, Type::Any).into());
let _ = ctx.set_var(pats[1].var().unwrap(), (value_ret, Type::Any).into());
}),
)?;
}
}
}
_ => {
panic!("未实现 {:?}", stmt)
}
}
Ok(false)
}
}