use crate::ast::*;
use crate::host::{self, ops, CatchClause, ClassDef, FuncDef, TryDef};
use crate::lexer::CompileDiag;
use fusevm::{Chunk, ChunkBuilder, Op, Value};
use rustc_hash::{FxHashMap, FxHashSet};
enum LinkError {
Fatal(String),
Throw(String),
}
pub struct Program {
pub main: Chunk,
pub main_locals: Vec<String>,
pub functions: Vec<(String, FuncDef)>,
pub classes: Vec<(String, ClassDef)>,
pub try_defs: Vec<TryDef>,
pub diags: Vec<CompileDiag>,
pub counters: Counters,
}
#[derive(Debug, Clone, Copy, Default)]
pub struct Counters {
pub tmp: usize,
pub static_slot: usize,
pub anon_classes: usize,
pub try_defs: usize,
}
struct LoopCtx {
breaks: Vec<usize>,
continues: Vec<usize>,
}
enum LvSeg<'a> {
Key(&'a Expr),
Append,
}
fn array_mutator_subop(name: &str) -> Option<i64> {
use crate::host::arrmut;
match name.to_ascii_lowercase().as_str() {
"array_push" => Some(arrmut::PUSH),
"array_pop" => Some(arrmut::POP),
"array_shift" => Some(arrmut::SHIFT),
"array_unshift" => Some(arrmut::UNSHIFT),
"array_splice" => Some(arrmut::SPLICE),
_ => None,
}
}
#[derive(Clone, Copy, PartialEq)]
enum ByRefArg {
Lvalue,
VarTemp,
TmpConst,
}
fn byref_arg_class(e: &Expr) -> ByRefArg {
match e {
Expr::NamedArg(_, inner) => byref_arg_class(inner),
Expr::Var(_)
| Expr::VarVar(_)
| Expr::Index(..)
| Expr::PropGet(..)
| Expr::StaticProp(..) => ByRefArg::Lvalue,
Expr::Call(..)
| Expr::CallValue(..)
| Expr::MethodCall(..)
| Expr::NullsafeMethodCall(..)
| Expr::StaticCall(..)
| Expr::New(..)
| Expr::NewAnon { .. } => ByRefArg::VarTemp,
_ => ByRefArg::TmpConst,
}
}
fn chain_recv(e: &Expr) -> Option<&Expr> {
match e {
Expr::PropGet(r, _)
| Expr::NullsafePropGet(r, _)
| Expr::MethodCall(r, _, _)
| Expr::NullsafeMethodCall(r, _, _)
| Expr::Index(r, _) => Some(r),
_ => None,
}
}
fn chain_has_nullsafe(e: &Expr) -> bool {
let mut cur = e;
loop {
if matches!(
cur,
Expr::NullsafePropGet(..) | Expr::NullsafeMethodCall(..)
) {
return true;
}
match chain_recv(cur) {
Some(r) => cur = r,
None => return false,
}
}
}
const BYREF_ARG_DIAG: &[(&str, u32, &str)] = &[
("sort", 1, "array"),
("rsort", 1, "array"),
("asort", 1, "array"),
("arsort", 1, "array"),
("ksort", 1, "array"),
("krsort", 1, "array"),
("usort", 1, "array"),
("uasort", 1, "array"),
("uksort", 1, "array"),
("natsort", 1, "array"),
("natcasesort", 1, "array"),
("shuffle", 1, "array"),
("array_push", 1, "array"),
("array_pop", 1, "array"),
("array_shift", 1, "array"),
("array_unshift", 1, "array"),
("array_splice", 1, "array"),
("array_walk", 1, "array"),
("array_walk_recursive", 1, "array"),
("end", 1, "array"),
("reset", 1, "array"),
("next", 1, "array"),
("prev", 1, "array"),
("settype", 1, "var"),
("parse_str", 2, "result"),
("similar_text", 3, "percent"),
("preg_match", 3, "matches"),
("preg_match_all", 3, "matches"),
("str_replace", 4, "count"),
("str_ireplace", 4, "count"),
("preg_replace", 5, "count"),
("preg_replace_callback", 5, "count"),
];
const BYREF_MAX_ARGNO: usize = 5;
fn byref_diag_slots(name: &str, nargs: usize) -> Vec<(usize, u32, &'static str)> {
let lname = name
.rsplit('\\')
.next()
.unwrap_or(name)
.to_ascii_lowercase();
if lname == "sscanf" {
return (2..nargs).map(|i| (i, i as u32 + 1, "")).collect();
}
BYREF_ARG_DIAG
.iter()
.filter(|(n, argno, _)| *n == lname && (*argno as usize) <= nargs)
.map(|&(_, argno, param)| (argno as usize - 1, argno, param))
.collect()
}
fn is_direct_minmax2(name: &str, args: &[Expr]) -> bool {
if args.len() != 2 {
return false;
}
let bare = name.rsplit('\\').next().unwrap_or(name);
bare.eq_ignore_ascii_case("min") || bare.eq_ignore_ascii_case("max")
}
type ByRefSlots = (String, Vec<(usize, u32, String)>);
struct ByRefFn {
spelled: String,
byref: Vec<(usize, String)>,
params: Vec<String>,
variadic: bool,
}
type SavedScope = (
FxHashMap<String, u32>,
Vec<String>,
FxHashMap<String, u16>,
FxHashSet<String>,
);
#[derive(Default)]
pub struct Compiler {
functions: Vec<(String, FuncDef)>,
classes: Vec<(String, ClassDef)>,
current_class: Option<String>,
current_parent: Option<String>,
loops: Vec<LoopCtx>,
try_defs: Vec<TryDef>,
in_try: usize,
tmp: usize,
static_slot: usize,
byref_fns: FxHashMap<String, Vec<usize>>,
byref_user_fns: FxHashMap<String, ByRefFn>,
debug: bool,
ret_by_ref: bool,
decl_site: host::DeclSite,
cur_line: u32,
method_order: FxHashMap<String, Vec<String>>,
anon_classes: usize,
known_traits: Vec<(String, ClassDef)>,
try_base: usize,
slots: FxHashMap<String, u32>,
slot_order: Vec<String>,
fslots: FxHashMap<String, u16>,
in_trait: bool,
fnumeric: FxHashSet<String>,
}
pub fn compile(stmts: &[Stmt], debug: bool) -> Result<Program, String> {
let mut c = Compiler {
debug,
..Compiler::default()
};
c.seed_builtin_byref();
c.collect_byref(stmts);
let mut b = ChunkBuilder::new();
let mut promoted = c.promotable_locals(&[], stmts, false);
match crate::promote::globals_reached(stmts) {
Some(reached) => promoted.names.retain(|n| !reached.contains(n)),
None => promoted.names.clear(),
}
let saved = c.enter_scope_promoting(scope_slots(&[], stmts), promoted);
c.compile_top_level(&mut b, stmts)?;
let main_locals = c.leave_scope(saved);
let counters = c.counters();
Ok(Program {
main: b.build(),
main_locals,
functions: c.functions,
classes: c.classes,
try_defs: c.try_defs,
counters,
diags: crate::lexer::take_diags(),
})
}
pub fn compile_nested(stmts: &[Stmt], start: Counters, source: &str) -> Result<Program, String> {
let mut c = Compiler {
tmp: start.tmp,
static_slot: start.static_slot,
anon_classes: start.anon_classes,
try_base: start.try_defs,
..Compiler::default()
};
c.seed_builtin_byref();
c.seed_loaded_byref();
c.known_traits = host::with_host(|h| h.trait_defs());
c.collect_byref(stmts);
let mut b = ChunkBuilder::new();
let saved = c.enter_scope(Vec::new());
c.compile_top_level(&mut b, stmts)?;
c.leave_scope(saved);
let counters = c.counters();
let mut prog = Program {
main: b.build(),
main_locals: Vec::new(),
functions: c.functions,
classes: c.classes,
try_defs: c.try_defs,
counters,
diags: crate::lexer::take_diags(),
};
stamp_source(&mut prog, source);
Ok(prog)
}
fn stamp_source(prog: &mut Program, source: &str) {
fn chunk(c: &mut Chunk, source: &str) {
c.source = source.to_string();
for sub in &mut c.sub_chunks {
chunk(sub, source);
}
}
fn func(f: &mut FuncDef, source: &str) {
chunk(&mut f.chunk, source);
for p in &mut f.params {
if let Some(d) = &mut p.default {
chunk(d, source);
}
}
}
chunk(&mut prog.main, source);
for (_, f) in &mut prog.functions {
func(f, source);
}
for (_, class) in &mut prog.classes {
for m in class.methods.values_mut() {
func(m, source);
}
for (_, c) in class
.consts
.iter_mut()
.chain(class.prop_defaults.iter_mut())
.chain(class.static_prop_defaults.iter_mut())
{
chunk(c, source);
}
for (_, c) in &mut class.enum_cases {
if let Some(c) = c {
chunk(c, source);
}
}
}
for t in &mut prog.try_defs {
chunk(&mut t.try_chunk, source);
for c in &mut t.catches {
chunk(&mut c.chunk, source);
}
if let Some(f) = &mut t.finally_chunk {
chunk(f, source);
}
}
}
impl Compiler {
fn counters(&self) -> Counters {
Counters {
tmp: self.tmp,
static_slot: self.static_slot,
anon_classes: self.anon_classes,
try_defs: self.try_base + self.try_defs.len(),
}
}
fn seed_loaded_byref(&mut self) {
for (name, params) in host::with_host(|h| h.user_function_params()) {
let positions: Vec<usize> = params
.iter()
.enumerate()
.filter(|(_, p)| p.1)
.map(|(i, _)| i)
.collect();
if positions.is_empty() {
continue;
}
self.byref_user_fns.insert(
name.clone(),
ByRefFn {
spelled: name.clone(),
byref: positions
.iter()
.map(|&i| {
let (pname, _, variadic) = ¶ms[i];
(
i,
if *variadic {
String::new()
} else {
pname.clone()
},
)
})
.collect(),
params: params.iter().map(|p| p.0.clone()).collect(),
variadic: params.iter().any(|p| p.2),
},
);
self.byref_fns.insert(name, positions);
}
}
fn tmp_name(&mut self, tag: &str) -> String {
self.tmp += 1;
format!("@{tag}{}", self.tmp)
}
fn compile_params(&mut self, params: &[Param]) -> Result<Vec<host::Param>, String> {
let mut out = Vec::with_capacity(params.len());
for p in params {
let default = match &p.default {
Some(expr) => {
let mut db = ChunkBuilder::new();
self.in_other_frame(|c| c.compile_expr(&mut db, expr))?;
Some(db.build())
}
None => None,
};
out.push(host::Param {
name: p.name.clone(),
line: p.line,
default,
variadic: p.variadic,
by_ref: p.by_ref,
ty: p.ty.clone(),
});
}
Ok(out)
}
fn emit_byref_arg_diag(
&mut self,
b: &mut ChunkBuilder,
callee: &str,
argno: u32,
param: &str,
class: ByRefArg,
) {
let kind = match class {
ByRefArg::Lvalue => return,
ByRefArg::VarTemp => 0,
ByRefArg::TmpConst => 1,
};
b.emit(Op::LoadInt(kind), 0);
let c = b.add_constant(Value::str(callee.to_string()));
b.emit(Op::LoadConst(c), 0);
b.emit(Op::LoadInt(i64::from(argno)), 0);
let c = b.add_constant(Value::str(param.to_string()));
b.emit(Op::LoadConst(c), 0);
b.emit(Op::CallBuiltin(ops::BYREF_ARG_DIAG, 4), self.cur_line);
b.emit(Op::Pop, 0);
}
fn emit_mcall_recv_check(
&mut self,
b: &mut ChunkBuilder,
name: &Member,
argc: usize,
) -> Result<(), String> {
if argc == 0 {
return Ok(());
}
self.emit_member(b, name, 0)?;
b.emit(Op::CallBuiltin(ops::MCALL_RECV_CHECK, 2), self.cur_line);
Ok(())
}
fn emit_member(&mut self, b: &mut ChunkBuilder, m: &Member, line: u32) -> Result<(), String> {
match m {
Member::Name(n) => {
let idx = b.add_constant(Value::str(n.clone()));
b.emit(Op::LoadConst(idx), line);
}
Member::Dyn(e) => self.compile_expr(b, e)?,
}
Ok(())
}
fn method_member(
&mut self,
b: &mut ChunkBuilder,
m: &Member,
argc: usize,
) -> Result<Member, String> {
if argc == 0 {
return Ok(m.clone());
}
self.stash_member(b, m)
}
fn stash_member(&mut self, b: &mut ChunkBuilder, m: &Member) -> Result<Member, String> {
match m {
Member::Name(_) => Ok(m.clone()),
Member::Dyn(e) => {
let t = self.tmp_name("mn");
self.emit_set_var(b, &t, |c, b| c.compile_expr(b, e))?;
Ok(Member::Dyn(Box::new(Expr::Var(t))))
}
}
}
fn emit_callee_check(&mut self, b: &mut ChunkBuilder, op: u16, argc: usize) {
if argc == 0 {
return;
}
b.emit(Op::CallBuiltin(op, 1), self.cur_line);
}
fn emit_call_name_check(&mut self, b: &mut ChunkBuilder, name: &str, argc: usize) {
if name.starts_with("__") {
return;
}
self.emit_callee_check(b, ops::CALL_NAME_CHECK, argc);
}
fn emit_scall_callee_check(&mut self, b: &mut ChunkBuilder, name_idx: u16, argc: usize) {
if argc == 0 {
return;
}
b.emit(Op::LoadConst(name_idx), 0);
b.emit(Op::CallBuiltin(ops::SCALL_CALLEE_CHECK, 2), self.cur_line);
}
fn emit_byref_writeback(
&mut self,
b: &mut ChunkBuilder,
args: &[Expr],
positions: &[usize],
guarded: bool,
) -> Result<(), String> {
for &pos in positions {
let Some(arg) = args.get(pos) else { continue };
if !matches!(
arg,
Expr::Var(_) | Expr::Index(..) | Expr::PropGet(..) | Expr::StaticProp(..)
) {
continue;
}
let skip = if guarded {
b.emit(Op::LoadInt(pos as i64), 0);
b.emit(Op::CallBuiltin(ops::BYREF_LIVE, 1), 0);
Some(b.emit(Op::JumpIfFalse(0), 0))
} else {
None
};
match arg {
Expr::Var(vname) => {
let nidx = b.add_constant(Value::str(vname.clone()));
b.emit(Op::LoadConst(nidx), 0);
b.emit(Op::LoadInt(pos as i64), 0);
b.emit(Op::CallBuiltin(ops::BYREF_OUT, 1), 0);
b.emit(Op::CallBuiltin(ops::SETVAR, 2), 0);
b.emit(Op::Pop, 0);
}
_ => {
let tmp = self.tmp_name("bo");
self.emit_set_var(b, &tmp, |_, b| {
b.emit(Op::LoadInt(pos as i64), 0);
b.emit(Op::CallBuiltin(ops::BYREF_OUT, 1), 0);
Ok(())
})?;
let back = Expr::Assign(Box::new(arg.clone()), None, Box::new(Expr::Var(tmp)));
self.compile_expr(b, &back)?;
b.emit(Op::Pop, 0);
}
}
if let Some(j) = skip {
let end = b.current_pos();
b.patch_jump(j, end);
}
}
Ok(())
}
fn seed_builtin_byref(&mut self) {
const BYREF_BUILTINS: &[(&str, &[usize])] = &[
("preg_match", &[2]),
("preg_match_all", &[2]),
("preg_replace", &[4]),
("preg_replace_callback", &[4]),
("parse_str", &[1]),
("similar_text", &[2]),
("str_replace", &[3]),
("settype", &[0]),
];
for (name, positions) in BYREF_BUILTINS {
self.byref_fns.insert(name.to_string(), positions.to_vec());
}
}
const BYREF_VARIADIC_BUILTINS: &'static [(&'static str, usize)] = &[("sscanf", 2)];
fn byref_positions(&self, name: &str, nargs: usize) -> Option<(Vec<usize>, bool)> {
let lname = name.to_ascii_lowercase();
if let Some(p) = self.byref_fns.get(&lname) {
return Some((p.clone(), false));
}
Self::BYREF_VARIADIC_BUILTINS
.iter()
.find(|(n, _)| *n == lname)
.map(|&(_, from)| ((from..nargs).collect(), true))
}
fn byref_user_slots(&self, name: &str, nargs: usize) -> Option<ByRefSlots> {
let f = self.byref_user_fns.get(&name.to_ascii_lowercase())?;
let mut slots = Vec::new();
for (pos, pname) in &f.byref {
if pname.is_empty() {
slots.extend((*pos..nargs).map(|i| (i, i as u32 + 1, String::new())));
} else if *pos < nargs {
slots.push((*pos, *pos as u32 + 1, pname.clone()));
}
}
Some((f.spelled.clone(), slots))
}
fn loop_at_level(&self, level: u32) -> Option<usize> {
self.loops.len().checked_sub(level.max(1) as usize)
}
fn collect_byref(&mut self, stmts: &[Stmt]) {
for s in stmts {
match &s.kind {
StmtKind::Function {
name, params, body, ..
} => {
let positions: Vec<usize> = params
.iter()
.enumerate()
.filter(|(_, p)| p.by_ref)
.map(|(i, _)| i)
.collect();
if !positions.is_empty() {
let named = positions
.iter()
.map(|&i| {
(
i,
if params[i].variadic {
String::new()
} else {
params[i].name.clone()
},
)
})
.collect();
self.byref_user_fns.insert(
name.to_ascii_lowercase(),
ByRefFn {
spelled: name.clone(),
byref: named,
params: params.iter().map(|p| p.name.clone()).collect(),
variadic: params.iter().any(|p| p.variadic),
},
);
self.byref_fns.insert(name.to_ascii_lowercase(), positions);
}
self.collect_byref(body);
}
StmtKind::If {
then, elifs, els, ..
} => {
self.collect_byref(then);
for (_, body) in elifs {
self.collect_byref(body);
}
if let Some(e) = els {
self.collect_byref(e);
}
}
StmtKind::While { body, .. }
| StmtKind::DoWhile { body, .. }
| StmtKind::For { body, .. }
| StmtKind::Foreach { body, .. }
| StmtKind::Block(body) => self.collect_byref(body),
StmtKind::Switch { cases, .. } => {
for c in cases {
self.collect_byref(&c.body);
}
}
StmtKind::Try {
body,
catches,
finally,
} => {
self.collect_byref(body);
for c in catches {
self.collect_byref(&c.body);
}
if let Some(f) = finally {
self.collect_byref(f);
}
}
_ => {}
}
}
}
fn compile_top_level(&mut self, b: &mut ChunkBuilder, stmts: &[Stmt]) -> Result<(), String> {
let mut hoisted: FxHashSet<usize> = FxHashSet::default();
for (i, s) in stmts.iter().enumerate() {
if let StmtKind::Class(d) = &s.kind {
if d.is_trait && d.uses.is_empty() {
self.compile_stmt(b, s)?;
hoisted.insert(i);
}
}
}
for (i, s) in stmts.iter().enumerate() {
if !hoisted.contains(&i) {
self.compile_stmt(b, s)?;
}
}
Ok(())
}
fn compile_seq(&mut self, b: &mut ChunkBuilder, body: &[Stmt]) -> Result<(), String> {
for s in body {
self.compile_stmt(b, s)?;
}
Ok(())
}
fn compile_stmt(&mut self, b: &mut ChunkBuilder, s: &Stmt) -> Result<(), String> {
if self.debug && s.line != 0 {
b.emit(Op::LoadInt(s.line as i64), s.line);
b.emit(Op::CallBuiltin(ops::DBG_LINE, 1), s.line);
b.emit(Op::Pop, s.line);
}
let line = s.line;
if line != 0 {
self.cur_line = line;
}
match &s.kind {
StmtKind::InlineHtml(text) => {
let idx = b.add_constant(Value::str(text.clone()));
b.emit(Op::LoadConst(idx), line);
b.emit(Op::CallBuiltin(ops::ECHO, 1), line);
b.emit(Op::Pop, line);
}
StmtKind::Echo(args) => {
for a in args {
self.compile_expr(b, a)?;
b.emit(Op::CallBuiltin(ops::ECHO, 1), line);
b.emit(Op::Pop, line);
}
}
StmtKind::Expr(e) => {
self.compile_expr(b, e)?;
b.emit(Op::Pop, line);
}
StmtKind::Block(body) => self.compile_seq(b, body)?,
StmtKind::Global(names) => {
for name in names {
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), line);
b.emit(Op::CallBuiltin(ops::GLOBAL_BIND, 1), line);
b.emit(Op::Pop, 0);
}
}
StmtKind::StaticLocal(decls) => {
for (name, default) in decls {
let key = format!("@static#{}", self.static_slot);
self.static_slot += 1;
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), line);
let kidx = b.add_constant(Value::str(key));
b.emit(Op::LoadConst(kidx), line);
match default {
Some(e) => self.compile_expr(b, e)?,
None => {
b.emit(Op::LoadUndef, line);
}
}
b.emit(Op::CallBuiltin(ops::STATIC_BIND, 3), line);
b.emit(Op::Pop, line);
}
}
StmtKind::ConstDecl(decls) => {
for (name, value) in decls {
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), line);
self.compile_expr(b, value)?;
b.emit(Op::CallBuiltin(ops::CONST_DECL, 2), line);
b.emit(Op::Pop, line);
}
}
StmtKind::Return(e) => {
let by_ref = self.ret_by_ref
&& matches!(
e,
Some(Expr::Var(_)) | Some(Expr::Index(..)) | Some(Expr::PropGet(..))
);
match e {
Some(e) if by_ref => {
self.compile_ref_slot(b, e)?;
b.emit(Op::CallBuiltin(ops::RET_REF, 1), line);
}
Some(e) => self.compile_expr(b, e)?,
None => {
b.emit(Op::LoadUndef, line);
}
}
b.emit(Op::CallBuiltin(ops::SIG_RETURN, 1), line);
b.emit(Op::Pop, line);
}
StmtKind::Break(level) => {
if let Some(idx) = self.loop_at_level(*level) {
let j = b.emit(Op::Jump(0), line);
self.loops[idx].breaks.push(j);
} else if self.in_try > 0 {
b.emit(Op::LoadInt(*level as i64), line);
b.emit(Op::CallBuiltin(ops::SIG_BREAK, 1), line);
b.emit(Op::Pop, line);
} else {
return Err(break_level_error("break", *level, self.loops.len()));
}
}
StmtKind::Continue(level) => {
if let Some(idx) = self.loop_at_level(*level) {
let j = b.emit(Op::Jump(0), line);
self.loops[idx].continues.push(j);
} else if self.in_try > 0 {
b.emit(Op::LoadInt(*level as i64), line);
b.emit(Op::CallBuiltin(ops::SIG_CONTINUE, 1), line);
b.emit(Op::Pop, line);
} else {
return Err(break_level_error("continue", *level, self.loops.len()));
}
}
StmtKind::Try {
body,
catches,
finally,
} => self.compile_try(b, body, catches, finally.as_deref(), line)?,
StmtKind::Function {
name,
params,
body,
ret,
by_ref_return,
} => {
let cparams = self.compile_params(params)?;
let mut fb = ChunkBuilder::new();
let saved = std::mem::take(&mut self.loops);
let saved_ref = std::mem::replace(&mut self.ret_by_ref, *by_ref_return);
let saved_site = std::mem::replace(
&mut self.decl_site,
host::DeclSite::Named(format!("{name}()")),
);
let promoted = self.promotable_locals(params, body, body_has_yield(body));
let locals = self.enter_scope_promoting(scope_slots(params, body), promoted);
self.compile_seq(&mut fb, body)?;
let locals = self.leave_scope(locals);
self.decl_site = saved_site;
self.ret_by_ref = saved_ref;
self.loops = saved;
self.functions.push((
name.to_ascii_lowercase(),
FuncDef {
params: cparams,
chunk: fb.build(),
is_generator: body_has_yield(body),
ret: ret.clone(),
locals,
closure_site: None,
},
));
}
StmtKind::Class(decl) => self.compile_class(b, decl)?,
StmtKind::If {
cond,
then,
elifs,
els,
} => self.compile_if(b, cond, then, elifs, els)?,
StmtKind::While { cond, body } => self.compile_while(b, cond, body)?,
StmtKind::DoWhile { cond, body } => self.compile_do_while(b, cond, body)?,
StmtKind::Switch { subj, cases } => self.compile_switch(b, subj, cases)?,
StmtKind::For {
init,
cond,
step,
body,
} => self.compile_for(b, init, cond.as_ref(), step, body)?,
StmtKind::Foreach {
arr,
key_var,
val,
by_ref,
body,
} => self.compile_foreach(b, arr, key_var.as_deref(), val, *by_ref, body)?,
}
Ok(())
}
fn compile_if(
&mut self,
b: &mut ChunkBuilder,
cond: &Expr,
then: &[Stmt],
elifs: &[(Expr, Vec<Stmt>)],
els: &Option<Vec<Stmt>>,
) -> Result<(), String> {
let mut ends: Vec<usize> = Vec::new();
let arms: Vec<(&Expr, &[Stmt])> = std::iter::once((cond, then))
.chain(elifs.iter().map(|(c, body)| (c, body.as_slice())))
.collect();
for (c, body) in arms {
self.compile_truthy(b, c)?;
let next = b.emit(Op::JumpIfFalse(0), 0);
self.compile_seq(b, body)?;
ends.push(b.emit(Op::Jump(0), 0));
let here = b.current_pos();
b.patch_jump(next, here);
}
if let Some(body) = els {
self.compile_seq(b, body)?;
}
let end = b.current_pos();
for j in ends {
b.patch_jump(j, end);
}
Ok(())
}
fn compile_while(
&mut self,
b: &mut ChunkBuilder,
cond: &Expr,
body: &[Stmt],
) -> Result<(), String> {
let enter = b.emit(Op::Jump(0), 0);
let body_pos = b.current_pos();
self.loops.push(LoopCtx {
breaks: vec![],
continues: vec![],
});
self.compile_seq(b, body)?;
let ctx = self.loops.pop().unwrap();
let cond_pos = b.current_pos();
b.patch_jump(enter, cond_pos);
self.compile_truthy(b, cond)?;
b.emit(Op::JumpIfTrue(body_pos), 0);
let end = b.current_pos();
for j in ctx.breaks {
b.patch_jump(j, end);
}
for j in ctx.continues {
b.patch_jump(j, cond_pos);
}
Ok(())
}
fn compile_do_while(
&mut self,
b: &mut ChunkBuilder,
cond: &Expr,
body: &[Stmt],
) -> Result<(), String> {
let top = b.current_pos();
self.loops.push(LoopCtx {
breaks: vec![],
continues: vec![],
});
self.compile_seq(b, body)?;
let ctx = self.loops.pop().unwrap();
let cond_pos = b.current_pos();
self.compile_truthy(b, cond)?;
b.emit(Op::JumpIfTrue(top), 0);
let end = b.current_pos();
for j in ctx.breaks {
b.patch_jump(j, end);
}
for j in ctx.continues {
b.patch_jump(j, cond_pos);
}
Ok(())
}
fn compile_switch(
&mut self,
b: &mut ChunkBuilder,
subj: &Expr,
cases: &[SwitchCase],
) -> Result<(), String> {
let sw_t = self.tmp_name("sw");
self.emit_set_var(b, &sw_t, |c, b| c.compile_expr(b, subj))?;
let mut dispatch: Vec<(usize, usize)> = Vec::new(); let mut default_index: Option<usize> = None;
for (i, case) in cases.iter().enumerate() {
match &case.test {
Some(test) => {
self.emit_get_var(b, &sw_t);
self.compile_expr(b, test)?;
b.emit(Op::CallBuiltin(ops::LOOSE_EQ, 2), 0);
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
let jt = b.emit(Op::JumpIfTrue(0), 0);
dispatch.push((i, jt));
}
None => default_index = Some(i),
}
}
let fallthrough = b.emit(Op::Jump(0), 0);
self.loops.push(LoopCtx {
breaks: vec![],
continues: vec![],
});
let mut body_starts = Vec::with_capacity(cases.len());
for case in cases {
body_starts.push(b.current_pos());
self.compile_seq(b, &case.body)?;
}
let ctx = self.loops.pop().unwrap();
let end = b.current_pos();
for (i, jt) in dispatch {
b.patch_jump(jt, body_starts[i]);
}
match default_index {
Some(di) => b.patch_jump(fallthrough, body_starts[di]),
None => b.patch_jump(fallthrough, end),
}
for j in ctx.breaks {
b.patch_jump(j, end);
}
for j in ctx.continues {
b.patch_jump(j, end);
}
Ok(())
}
fn compile_for(
&mut self,
b: &mut ChunkBuilder,
init: &[Expr],
cond: Option<&Expr>,
step: &[Expr],
body: &[Stmt],
) -> Result<(), String> {
for e in init {
self.compile_expr(b, e)?;
b.emit(Op::Pop, 0);
}
let enter = cond.map(|_| b.emit(Op::Jump(0), 0));
let body_pos = b.current_pos();
self.loops.push(LoopCtx {
breaks: vec![],
continues: vec![],
});
self.compile_seq(b, body)?;
let ctx = self.loops.pop().unwrap();
let step_pos = b.current_pos();
for e in step {
self.compile_expr(b, e)?;
b.emit(Op::Pop, 0);
}
match cond {
Some(c) => {
let cond_pos = b.current_pos();
if let Some(enter) = enter {
b.patch_jump(enter, cond_pos);
}
self.compile_truthy(b, c)?;
b.emit(Op::JumpIfTrue(body_pos), 0);
}
None => {
b.emit(Op::Jump(body_pos), 0);
}
}
let end = b.current_pos();
for j in ctx.breaks {
b.patch_jump(j, end);
}
for j in ctx.continues {
b.patch_jump(j, step_pos);
}
Ok(())
}
fn compile_foreach(
&mut self,
b: &mut ChunkBuilder,
arr: &Expr,
key_var: Option<&str>,
val: &ForeachVal,
by_ref: bool,
body: &[Stmt],
) -> Result<(), String> {
let (val_name, pattern) = match val {
ForeachVal::Var(n) => (n.clone(), None),
ForeachVal::Pattern(p) => (self.tmp_name("fev"), Some(p)),
};
let val_var: &str = &val_name;
let subj_t = self.tmp_name("subj");
self.emit_set_var(b, &subj_t, |c, b| c.compile_expr(b, arr))?;
self.emit_get_var(b, &subj_t);
b.emit(Op::CallBuiltin(ops::IS_GENERATOR, 1), 0);
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
let to_array = b.emit(Op::JumpIfFalse(0), 0);
self.compile_foreach_generator(b, &subj_t, key_var, val_var, pattern, body)?;
let after_gen = b.emit(Op::Jump(0), 0);
let array_start = b.current_pos();
b.patch_jump(to_array, array_start);
let arr_t = self.tmp_name("arr");
let keys_t = self.tmp_name("keys");
let i_t = self.tmp_name("i");
self.emit_set_var(b, &arr_t, |c, b| {
c.emit_get_var(b, &subj_t);
b.emit(Op::CallBuiltin(ops::FOREACH_PREP, 1), 0);
Ok(())
})?;
self.emit_set_var(b, &keys_t, |c, b| {
c.emit_get_var(b, &arr_t);
b.emit(Op::CallBuiltin(ops::ARRAYKEYS, 1), 0);
Ok(())
})?;
self.emit_set_var(b, &i_t, |_, b| {
b.emit(Op::LoadInt(0), 0);
Ok(())
})?;
let top = b.current_pos();
self.emit_get_var(b, &i_t);
self.emit_get_var(b, &keys_t);
b.emit(Op::CallBuiltin(ops::ARRAYLEN, 1), 0);
b.emit(Op::CallBuiltin(ops::LT, 2), 0);
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
let exit = b.emit(Op::JumpIfFalse(0), 0);
let k_t = self.tmp_name("k");
self.emit_set_var(b, &k_t, |c, b| {
c.emit_get_var(b, &keys_t);
c.emit_get_var(b, &i_t);
b.emit(Op::CallBuiltin(ops::INDEX_GET_Q, 2), 0);
Ok(())
})?;
let mut skip_missing = None;
if by_ref {
let fi = b.add_constant(Value::str("array_key_exists"));
b.emit(Op::LoadConst(fi), 0);
self.emit_get_var(b, &k_t);
self.emit_get_var(b, &arr_t);
b.emit(Op::CallBuiltin(ops::CALL, 3), self.cur_line);
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
skip_missing = Some(b.emit(Op::JumpIfFalse(0), 0));
}
if let Some(kv) = key_var {
self.emit_set_var(b, kv, |c, b| {
c.emit_get_var(b, &k_t);
Ok(())
})?;
}
if by_ref {
let elem = Expr::Index(
Box::new(Expr::Var(arr_t.clone())),
Box::new(Expr::Var(k_t.clone())),
);
self.compile_ref_assign(b, &Expr::Var(val_name.clone()), &elem)?;
b.emit(Op::Pop, 0);
} else {
self.emit_set_var(b, val_var, |c, b| {
c.emit_get_var(b, &arr_t);
c.emit_get_var(b, &k_t);
b.emit(Op::CallBuiltin(ops::INDEX_GET_Q, 2), 0);
b.emit(Op::CallBuiltin(ops::COPY, 1), 0);
Ok(())
})?;
}
let row_path = Expr::Index(
Box::new(Expr::Var(arr_t.clone())),
Box::new(Expr::Var(k_t.clone())),
);
self.emit_foreach_destructure(b, pattern, val_var, Some(&row_path))?;
self.loops.push(LoopCtx {
breaks: vec![],
continues: vec![],
});
self.compile_seq(b, body)?;
let ctx = self.loops.pop().unwrap();
let cont_target = b.current_pos();
if let Some(j) = skip_missing {
b.patch_jump(j, cont_target);
}
self.emit_set_var(b, &i_t, |c, b| {
c.emit_get_var(b, &i_t);
b.emit(Op::LoadInt(1), 0);
b.emit(Op::Add, 0);
Ok(())
})?;
b.emit(Op::Jump(top), 0);
let end = b.current_pos();
b.patch_jump(exit, end);
for j in ctx.breaks {
b.patch_jump(j, end);
}
for j in ctx.continues {
b.patch_jump(j, cont_target);
}
b.patch_jump(after_gen, end);
Ok(())
}
fn compile_foreach_generator(
&mut self,
b: &mut ChunkBuilder,
subj_t: &str,
key_var: Option<&str>,
val_var: &str,
pattern: Option<&Expr>,
body: &[Stmt],
) -> Result<(), String> {
self.emit_get_var(b, subj_t);
b.emit(Op::CallBuiltin(ops::GEN_REWIND, 1), 0);
b.emit(Op::Pop, 0);
let top = b.current_pos();
self.emit_get_var(b, subj_t);
b.emit(Op::CallBuiltin(ops::GEN_VALID, 1), 0);
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
let exit = b.emit(Op::JumpIfFalse(0), 0);
if let Some(kv) = key_var {
self.emit_set_var(b, kv, |c, b| {
c.emit_get_var(b, subj_t);
b.emit(Op::CallBuiltin(ops::GEN_KEY, 1), 0);
Ok(())
})?;
}
self.emit_set_var(b, val_var, |c, b| {
c.emit_get_var(b, subj_t);
b.emit(Op::CallBuiltin(ops::GEN_CURRENT, 1), 0);
Ok(())
})?;
self.emit_foreach_destructure(b, pattern, val_var, None)?;
self.loops.push(LoopCtx {
breaks: vec![],
continues: vec![],
});
self.compile_seq(b, body)?;
let ctx = self.loops.pop().unwrap();
let cont_target = b.current_pos();
self.emit_get_var(b, subj_t);
b.emit(Op::CallBuiltin(ops::GEN_NEXT, 1), 0);
b.emit(Op::Pop, 0);
b.emit(Op::Jump(top), 0);
let end = b.current_pos();
b.patch_jump(exit, end);
for j in ctx.breaks {
b.patch_jump(j, end);
}
for j in ctx.continues {
b.patch_jump(j, cont_target);
}
Ok(())
}
fn emit_foreach_destructure(
&mut self,
b: &mut ChunkBuilder,
pattern: Option<&Expr>,
val_var: &str,
ref_path: Option<&Expr>,
) -> Result<(), String> {
let Some(p) = pattern else {
return Ok(());
};
if let Expr::Array(elems) = p {
self.compile_list_targets(b, elems, val_var, ref_path)?;
return Ok(());
}
self.compile_assign(b, p, None, &Expr::Var(val_var.to_string()))?;
b.emit(Op::Pop, 0);
Ok(())
}
fn compile_class(&mut self, b: &mut ChunkBuilder, decl: &ClassDecl) -> Result<(), String> {
let prev_class = self.current_class.take();
let prev_parent = self.current_parent.take();
let prev_in_trait = std::mem::replace(&mut self.in_trait, decl.is_trait);
self.current_class = Some(decl.name.clone());
self.current_parent = decl.parent.clone();
let mut consts: Vec<(String, Chunk)> = Vec::new();
let mut const_vis: FxHashMap<String, Visibility> = FxHashMap::default();
let mut prop_defaults: Vec<(String, Chunk)> = Vec::new();
let mut static_prop_defaults: Vec<(String, Chunk)> = Vec::new();
let mut methods: FxHashMap<String, FuncDef> = FxHashMap::default();
let mut prop_vis: FxHashMap<String, Visibility> = FxHashMap::default();
let mut readonly_props: FxHashSet<String> = FxHashSet::default();
let mut uninit_props: FxHashMap<String, String> = FxHashMap::default();
let mut method_vis: FxHashMap<String, Visibility> = FxHashMap::default();
let mut static_methods: FxHashSet<String> = FxHashSet::default();
let mut order: Vec<String> = Vec::new();
match self.seed_from_traits(
decl,
&mut consts,
&mut const_vis,
&mut prop_defaults,
&mut static_prop_defaults,
&mut methods,
&mut prop_vis,
&mut readonly_props,
&mut method_vis,
&mut static_methods,
&mut order,
) {
Ok(()) => {}
Err(err) => {
match err {
LinkError::Fatal(msg) => {
let idx = b.add_constant(Value::str(msg));
b.emit(Op::LoadConst(idx), self.cur_line);
b.emit(Op::CallBuiltin(ops::DECL_FATAL, 1), self.cur_line);
}
LinkError::Throw(msg) => {
let e = Expr::Throw(Box::new(Expr::New(
"Error".to_string(),
vec![Expr::Str(msg)],
)));
self.compile_expr(b, &e)?;
}
}
b.emit(Op::Pop, self.cur_line);
self.current_class = prev_class;
self.in_trait = prev_in_trait;
self.current_parent = prev_parent;
return Ok(());
}
}
for (name, expr) in &decl.consts {
let mut cb = ChunkBuilder::new();
self.in_other_frame(|c| c.compile_expr(&mut cb, expr))?;
consts.retain(|(n, _)| n != name);
consts.push((name.clone(), cb.build()));
const_vis.remove(name);
}
for (name, vis) in &decl.const_vis {
const_vis.insert(name.clone(), *vis);
}
for tname in &decl.uses {
if let Some(t) = self.find_class(tname) {
uninit_props.extend(t.uninit_props.iter().map(|(n, ty)| (n.clone(), ty.clone())));
}
}
for prop in &decl.props {
let name = &prop.name;
prop_vis.insert(name.clone(), prop.visibility);
match (&prop.ty, &prop.default, prop.is_static) {
(Some(ty), None, false) => {
let display = ty.declared(&decl.name, decl.parent.as_deref());
uninit_props.insert(name.clone(), display);
}
_ => {
uninit_props.remove(name);
}
}
if prop.readonly && !prop.is_static {
readonly_props.insert(name.clone());
}
let mut pb = ChunkBuilder::new();
match &prop.default {
Some(e) => self.in_other_frame(|c| c.compile_expr(&mut pb, e))?,
None => {
pb.emit(Op::LoadUndef, 0);
}
}
if prop.is_static {
static_prop_defaults.retain(|(n, _)| n != name);
static_prop_defaults.push((name.clone(), pb.build()));
} else {
prop_defaults.retain(|(n, _)| n != name);
prop_defaults.push((name.clone(), pb.build()));
}
}
prop_defaults
.sort_by_key(|(n, _)| !decl.props.iter().any(|p| !p.is_static && &p.name == n));
for m in &decl.methods {
method_vis.insert(m.name.to_ascii_lowercase(), m.visibility);
if m.is_static {
static_methods.insert(m.name.to_ascii_lowercase());
}
order.retain(|n| !n.eq_ignore_ascii_case(&m.name));
order.push(m.name.clone());
let cparams = self.compile_params(&m.params)?;
let mut mb = ChunkBuilder::new();
let saved = std::mem::take(&mut self.loops);
let mut promotions: Vec<Expr> = Vec::new();
if m.name.eq_ignore_ascii_case("__construct") {
for p in m.params.iter().filter(|p| p.promoted) {
prop_vis.insert(p.name.clone(), Visibility::Public);
if p.readonly || decl.is_readonly {
readonly_props.insert(p.name.clone());
}
promotions.push(Expr::Assign(
Box::new(Expr::PropGet(
Box::new(Expr::Var("this".to_string())),
Member::Name(p.name.clone()),
)),
None,
Box::new(Expr::Var(p.name.clone())),
));
}
}
let saved_ref = std::mem::replace(&mut self.ret_by_ref, m.by_ref_return);
let saved_site = std::mem::replace(
&mut self.decl_site,
host::DeclSite::Named(format!("{}::{}()", decl.name, m.name)),
);
self.in_other_frame(|c| {
for assign in &promotions {
c.compile_expr(&mut mb, assign)?;
mb.emit(Op::Pop, 0);
}
c.compile_seq(&mut mb, &m.body)
})?;
self.decl_site = saved_site;
self.ret_by_ref = saved_ref;
self.loops = saved;
methods.insert(
m.name.to_ascii_lowercase(),
FuncDef {
params: cparams,
closure_site: None,
chunk: mb.build(),
is_generator: body_has_yield(&m.body),
ret: m.ret.clone(),
locals: Vec::new(),
},
);
}
let mut enum_cases: Vec<(String, Option<Chunk>)> = Vec::new();
for case in &decl.cases {
let chunk = match &case.value {
Some(e) => {
let mut cb = ChunkBuilder::new();
self.in_other_frame(|c| c.compile_expr(&mut cb, e))?;
Some(cb.build())
}
None => None,
};
enum_cases.push((case.name.clone(), chunk));
}
self.method_order
.insert(decl.name.to_ascii_lowercase(), order);
self.classes.push((
decl.name.to_ascii_lowercase(),
ClassDef {
name: decl.name.clone(),
parent: decl.parent.clone(),
interfaces: decl.implements.clone(),
consts,
const_vis,
prop_defaults,
static_prop_defaults,
methods,
prop_vis,
readonly_props,
uninit_props,
method_vis,
static_methods,
is_enum: decl.is_enum,
is_abstract: decl.is_abstract,
is_interface: decl.is_interface,
is_trait: decl.is_trait,
uses: decl.uses.clone(),
allow_dynamic_props: decl
.attributes
.iter()
.any(|a| a.eq_ignore_ascii_case("AllowDynamicProperties")),
enum_cases,
},
));
self.current_class = prev_class;
self.in_trait = prev_in_trait;
self.current_parent = prev_parent;
Ok(())
}
#[allow(clippy::too_many_arguments)]
fn seed_from_traits(
&self,
decl: &ClassDecl,
consts: &mut Vec<(String, Chunk)>,
const_vis: &mut FxHashMap<String, Visibility>,
prop_defaults: &mut Vec<(String, Chunk)>,
static_prop_defaults: &mut Vec<(String, Chunk)>,
methods: &mut FxHashMap<String, FuncDef>,
prop_vis: &mut FxHashMap<String, Visibility>,
readonly_props: &mut FxHashSet<String>,
method_vis: &mut FxHashMap<String, Visibility>,
static_methods: &mut FxHashSet<String>,
order: &mut Vec<String>,
) -> Result<(), LinkError> {
if decl.uses.is_empty() {
return Ok(());
}
let mut used: Vec<&ClassDef> = Vec::with_capacity(decl.uses.len());
for tname in &decl.uses {
match self.find_class(tname) {
Some(d) => used.push(d),
None => return Err(LinkError::Throw(format!("Trait \"{tname}\" not found"))),
}
}
let mut named = Vec::new();
for ins in &decl.trait_insteadof {
named.push(&ins.winner);
named.extend(ins.losers.iter());
}
named.extend(decl.trait_aliases.iter().filter_map(|a| a.from.as_ref()));
for tname in named {
if !used.iter().any(|d| d.name.eq_ignore_ascii_case(tname)) {
return Err(LinkError::Fatal(match self.find_class(tname) {
Some(_) => format!("Required Trait {tname} wasn't added to {}", decl.name),
None => format!("Could not find trait {tname}"),
}));
}
}
for tdef in &used {
consts.extend(tdef.consts.iter().cloned());
for (n, v) in &tdef.const_vis {
const_vis.insert(n.clone(), *v);
}
prop_defaults.extend(tdef.prop_defaults.iter().cloned());
static_prop_defaults.extend(tdef.static_prop_defaults.iter().cloned());
for (n, v) in &tdef.prop_vis {
prop_vis.insert(n.clone(), *v);
}
readonly_props.extend(tdef.readonly_props.iter().cloned());
}
let excluded: Vec<(String, String)> = decl
.trait_insteadof
.iter()
.flat_map(|ins| {
ins.losers
.iter()
.map(|l| (l.to_ascii_lowercase(), ins.method.to_ascii_lowercase()))
})
.collect();
let is_excluded = |tdef: &ClassDef, m: &str| {
excluded
.iter()
.any(|(t, em)| tdef.name.eq_ignore_ascii_case(t) && em == m)
};
let mut seen: Vec<String> = Vec::new();
for tdef in &used {
let mut keys: Vec<String> = self
.declared_methods(&tdef.name)
.iter()
.map(|s| s.to_ascii_lowercase())
.collect();
if keys.is_empty() {
keys = tdef.methods.keys().cloned().collect();
keys.sort();
}
for key in keys {
if !seen.contains(&key) {
seen.push(key);
}
}
}
for m in &seen {
let candidates: Vec<&&ClassDef> = used
.iter()
.filter(|t| t.methods.contains_key(m) && !is_excluded(t, m))
.collect();
let Some(winner) = candidates.first() else {
continue;
};
if let Some(loser) = candidates.get(1) {
let kept = self.method_spelling(&winner.name, m);
let dropped = self.method_spelling(&loser.name, m);
return Err(LinkError::Fatal(format!(
"Trait method {}::{dropped} has not been applied as {}::{dropped}, \
because of collision with {}::{kept}",
loser.name, decl.name, winner.name
)));
}
methods.insert(m.clone(), winner.methods[m].clone());
if let Some(v) = winner.method_vis.get(m) {
method_vis.insert(m.clone(), *v);
}
if winner.static_methods.contains(m) {
static_methods.insert(m.clone());
}
order.push(self.method_spelling(&winner.name, m));
}
for al in &decl.trait_aliases {
let key = al.method.to_ascii_lowercase();
let source = match &al.from {
Some(tname) => {
let tdef = used
.iter()
.find(|d| d.name.eq_ignore_ascii_case(tname))
.expect("adaptation trait names were checked above");
if !tdef.methods.contains_key(&key) {
return Err(LinkError::Fatal(format!(
"An alias was defined for {tname}::{} but this method does not exist",
al.method
)));
}
*tdef
}
None => {
let found: Vec<&&ClassDef> = used
.iter()
.filter(|d| d.methods.contains_key(&key))
.collect();
match found.as_slice() {
[one] => **one,
[] => {
let alias = al.alias.clone().unwrap_or_else(|| al.method.clone());
return Err(LinkError::Fatal(format!(
"An alias ({alias}) was defined for method {}(), but this \
method does not exist",
al.method
)));
}
[a, b, ..] => {
let m = self.method_spelling(&a.name, &key);
return Err(LinkError::Fatal(format!(
"An alias was defined for method {m}(), which exists in both \
{} and {}. Use {}::{m} or {}::{m} to resolve the ambiguity",
a.name, b.name, a.name, b.name
)));
}
}
}
};
match &al.alias {
Some(alias) => {
let ak = alias.to_ascii_lowercase();
methods.insert(ak.clone(), source.methods[&key].clone());
let vis = al
.visibility
.or_else(|| source.method_vis.get(&key).copied())
.unwrap_or(Visibility::Public);
method_vis.insert(ak.clone(), vis);
if source.static_methods.contains(&key) {
static_methods.insert(ak);
}
order.push(alias.clone());
}
None => {
if let Some(v) = al.visibility {
method_vis.insert(key, v);
}
}
}
}
Ok(())
}
fn anon_class_name(&mut self, decl: &ClassDecl, line: u32) -> String {
let base = decl
.parent
.as_deref()
.or(decl.implements.first().map(String::as_str))
.unwrap_or("class");
let n = self.anon_classes;
self.anon_classes += 1;
let script = host::with_host(|h| h.script_name().to_string());
format!("{base}@anonymous\0{script}:{line}${n:x}")
}
fn find_class(&self, name: &str) -> Option<&ClassDef> {
let key = name.to_ascii_lowercase();
self.classes
.iter()
.chain(self.known_traits.iter())
.find(|(n, _)| *n == key)
.map(|(_, d)| d)
}
fn declared_methods(&self, class: &str) -> &[String] {
self.method_order
.get(&class.to_ascii_lowercase())
.map_or(&[], Vec::as_slice)
}
fn method_spelling(&self, class: &str, key: &str) -> String {
self.declared_methods(class)
.iter()
.find(|n| n.eq_ignore_ascii_case(key))
.cloned()
.unwrap_or_else(|| key.to_string())
}
fn emit_class_name(&mut self, b: &mut ChunkBuilder, class: &str) -> Result<(), String> {
if self.in_trait {
match class.to_ascii_lowercase().as_str() {
"self" => {
b.emit(Op::CallBuiltin(ops::SELF_CLASS, 0), self.cur_line);
return Ok(());
}
"parent" => {
b.emit(Op::CallBuiltin(ops::PARENT_CLASS, 0), self.cur_line);
return Ok(());
}
_ => {}
}
}
let unbound_closure =
self.current_class.is_none() && !matches!(self.decl_site, host::DeclSite::Named(_));
if unbound_closure {
let lower = class.to_ascii_lowercase();
if matches!(lower.as_str(), "self" | "parent" | "static") {
let kw = b.add_constant(Value::str(lower.clone()));
b.emit(Op::LoadConst(kw), self.cur_line);
let op = if lower == "parent" {
ops::PARENT_CLASS
} else {
ops::SELF_CLASS
};
b.emit(Op::CallBuiltin(op, 1), self.cur_line);
if lower == "static" {
b.emit(Op::CallBuiltin(ops::LSB_CLASS, 1), self.cur_line);
}
return Ok(());
}
}
let cname = self.resolve_class_name(class)?;
let idx = b.add_constant(Value::str(cname));
b.emit(Op::LoadConst(idx), 0);
if class.eq_ignore_ascii_case("static") {
b.emit(Op::CallBuiltin(ops::LSB_CLASS, 1), 0);
}
Ok(())
}
fn emit_class_ref(&mut self, b: &mut ChunkBuilder, class: &ClassRef) -> Result<(), String> {
match class {
ClassRef::Name(n) => self.emit_class_name(b, n),
ClassRef::Expr(e) => {
self.compile_expr(b, e)?;
b.emit(Op::CallBuiltin(ops::DYN_CLASS, 1), self.cur_line);
Ok(())
}
}
}
fn emit_lsb_forward(&mut self, b: &mut ChunkBuilder, class: &ClassRef) {
let lower = class.name().unwrap_or_default().to_ascii_lowercase();
if matches!(lower.as_str(), "self" | "parent" | "static") {
b.emit(Op::CallBuiltin(ops::LSB_FORWARD, 0), 0);
b.emit(Op::Pop, 0);
}
}
fn resolve_class_name(&self, name: &str) -> Result<String, String> {
match name.to_ascii_lowercase().as_str() {
"self" | "static" => self
.current_class
.clone()
.ok_or_else(|| format!("'{name}' used outside of a class")),
"parent" => self
.current_parent
.clone()
.ok_or_else(|| "'parent' used in a class with no parent".to_string()),
_ => Ok(name.to_string()),
}
}
fn compile_detached(&mut self, body: &[Stmt]) -> Result<Chunk, String> {
let mut fb = ChunkBuilder::new();
let saved = std::mem::take(&mut self.loops);
self.in_try += 1;
let r = self.compile_seq(&mut fb, body);
self.in_try -= 1;
self.loops = saved;
r?;
Ok(fb.build())
}
fn compile_try(
&mut self,
b: &mut ChunkBuilder,
body: &[Stmt],
catches: &[CatchArm],
finally: Option<&[Stmt]>,
line: u32,
) -> Result<(), String> {
let try_chunk = self.compile_detached(body)?;
let mut cc = Vec::with_capacity(catches.len());
for c in catches {
cc.push(CatchClause {
classes: c.types.clone(),
var: c.var.clone(),
chunk: self.compile_detached(&c.body)?,
});
}
let finally_chunk = match finally {
Some(f) => Some(self.compile_detached(f)?),
None => None,
};
let id = (self.try_base + self.try_defs.len()) as i64;
self.try_defs.push(TryDef {
try_chunk,
catches: cc,
finally_chunk,
});
b.emit(Op::LoadInt(id), line);
b.emit(Op::CallBuiltin(ops::RUN_TRY, 1), line);
let j_ret = self.branch_if_status(b, 1, line);
let j_throw = self.branch_if_status(b, 2, line);
let j_break = self.branch_if_status(b, 3, line);
let j_cont = self.branch_if_status(b, 4, line);
b.emit(Op::Pop, line);
let j_end = b.emit(Op::Jump(0), line);
let ret_pos = b.current_pos();
b.patch_jump(j_ret, ret_pos);
b.emit(Op::Pop, line);
b.emit(Op::CallBuiltin(ops::SIG_HALT, 0), line);
b.emit(Op::Pop, line);
let throw_pos = b.current_pos();
b.patch_jump(j_throw, throw_pos);
b.emit(Op::Pop, line);
b.emit(Op::CallBuiltin(ops::SIG_HALT, 0), line);
b.emit(Op::Pop, line);
let break_pos = b.current_pos();
b.patch_jump(j_break, break_pos);
b.emit(Op::Pop, line);
self.emit_break_dispatch(b, true, line);
let cont_pos = b.current_pos();
b.patch_jump(j_cont, cont_pos);
b.emit(Op::Pop, line);
self.emit_break_dispatch(b, false, line);
let end = b.current_pos();
b.patch_jump(j_end, end);
Ok(())
}
fn emit_break_dispatch(&mut self, b: &mut ChunkBuilder, is_break: bool, line: u32) {
let depth = self.loops.len();
for level in 1..=depth {
b.emit(Op::CallBuiltin(ops::SIG_LEVEL, 0), line);
b.emit(Op::LoadInt(level as i64), line);
b.emit(Op::CallBuiltin(ops::STRICT_EQ, 2), line);
let j = b.emit(Op::JumpIfTrue(0), line);
let target = b.current_pos();
b.patch_jump(j, target + 1);
let skip = b.emit(Op::Jump(0), line);
let hit = b.emit(Op::Jump(0), line);
let idx = depth - level;
if is_break {
self.loops[idx].breaks.push(hit);
} else {
self.loops[idx].continues.push(hit);
}
let after = b.current_pos();
b.patch_jump(skip, after);
}
b.emit(Op::CallBuiltin(ops::SIG_LEVEL, 0), line);
b.emit(Op::LoadInt(depth as i64), line);
b.emit(Op::Sub, line);
let sig = if is_break {
ops::SIG_BREAK
} else {
ops::SIG_CONTINUE
};
b.emit(Op::CallBuiltin(sig, 1), line);
b.emit(Op::Pop, line);
}
fn branch_if_status(&mut self, b: &mut ChunkBuilder, code: i64, line: u32) -> usize {
b.emit(Op::Dup, line);
b.emit(Op::LoadInt(code), line);
b.emit(Op::CallBuiltin(ops::STRICT_EQ, 2), line);
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), line);
b.emit(Op::JumpIfTrue(0), line)
}
fn compile_expr(&mut self, b: &mut ChunkBuilder, e: &Expr) -> Result<(), String> {
if chain_has_nullsafe(e) {
return self.compile_nullsafe_chain(b, e, false);
}
match e {
Expr::VarVar(inner) => {
self.compile_expr(b, inner)?;
b.emit(Op::CallBuiltin(ops::GETVAR, 1), self.cur_line);
}
Expr::Null => {
b.emit(Op::LoadUndef, 0);
}
Expr::Bool(v) => {
b.emit(if *v { Op::LoadTrue } else { Op::LoadFalse }, 0);
}
Expr::Int(n) => {
b.emit(Op::LoadInt(*n), 0);
}
Expr::Float(f) => {
b.emit(Op::LoadFloat(*f), 0);
}
Expr::Str(s) => {
let idx = b.add_constant(Value::str(s.clone()));
b.emit(Op::LoadConst(idx), 0);
}
Expr::Interp(parts) => self.compile_interp(b, parts)?,
Expr::Var(name) => self.emit_get_var(b, name),
Expr::Array(elems) => {
if let Some(e) = elems.iter().find(|e| e.by_ref) {
let _ = e;
return Err("`&` in an array literal is supported only in a \
destructuring target, not in a value array"
.into());
}
for (chunk, es) in elems.chunks(host::MKARRAY_CHUNK_PAIRS).enumerate() {
for e in es {
if let Expr::Spread(inner) = &e.value {
let sk = b.add_constant(host::SPREAD_KEY);
b.emit(Op::LoadConst(sk), 0);
self.compile_expr(b, inner)?;
continue;
}
match &e.key {
Some(k) => self.compile_expr(b, k)?,
None => {
let ai = b.add_constant(host::AUTO_INDEX);
b.emit(Op::LoadConst(ai), 0);
}
}
self.compile_expr(b, &e.value)?;
}
let (op, argc) = if chunk == 0 {
(ops::MKARRAY, es.len() * 2)
} else {
(ops::MKARRAY_ADD, es.len() * 2 + 1)
};
b.emit(Op::CallBuiltin(op, argc as u8), self.cur_line);
}
if elems.is_empty() {
b.emit(Op::CallBuiltin(ops::MKARRAY, 0), self.cur_line);
}
}
Expr::Index(recv, idx) => {
self.compile_expr(b, recv)?;
self.compile_expr(b, idx)?;
b.emit(Op::CallBuiltin(ops::INDEX_GET, 2), self.cur_line);
}
Expr::ListElem(recv, idx) => {
self.compile_expr(b, recv)?;
self.compile_expr(b, idx)?;
b.emit(Op::CallBuiltin(ops::LIST_ELEM_GET, 2), self.cur_line);
}
Expr::Append(_) => {
return Err("'[]' append is only valid as an assignment target".into())
}
Expr::Unary(op, e) => {
self.compile_expr(b, e)?;
match op {
UnOp::Neg => {
b.emit(Op::Negate, self.cur_line);
}
UnOp::Pos => {
b.emit(Op::LoadInt(1), self.cur_line);
b.emit(Op::Mul, self.cur_line);
}
UnOp::Not => {
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
b.emit(Op::LogNot, 0);
}
UnOp::BitNot => {
b.emit(Op::CallBuiltin(ops::BITNOT, 1), self.cur_line);
}
}
}
Expr::Binary(op, l, r) => self.compile_binary(b, *op, l, r)?,
Expr::Assign(lhs, op, rhs) => self.compile_assign(b, lhs, *op, rhs)?,
Expr::IncDec {
target,
inc,
prefix,
} => self.compile_incdec(b, target, *inc, *prefix)?,
Expr::Call(name, args) if has_named(args) => {
let idx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(idx), 0);
self.emit_call_name_check(b, name, args.len());
self.compile_arg_pairs_for(b, name, args)?;
b.emit(
Op::CallBuiltin(ops::CALL_NAMED, (args.len() * 2 + 1) as u8),
self.cur_line,
);
}
Expr::Call(name, args) => {
let has_spread = args.iter().any(|a| matches!(a, Expr::Spread(_)));
let mut_diag = args.first().map(byref_arg_class);
let mutator_target = match (has_spread, array_mutator_subop(name), args.first()) {
(false, Some(sub), Some(Expr::Var(vname))) => Some((sub, vname.clone())),
(false, Some(sub), Some(root)) => {
let tmp = self.tmp_name("mut");
let root = root.clone();
self.emit_set_var(b, &tmp, |c, b| c.compile_expr(b, &root))?;
Some((sub, tmp))
}
_ => None,
};
if let Some((sub, vname)) = mutator_target {
if let Some(class) = mut_diag {
self.emit_byref_arg_diag(b, name, 1, "array", class);
}
let nidx = b.add_constant(Value::str(vname.clone()));
b.emit(Op::LoadConst(nidx), 0);
b.emit(Op::LoadInt(sub), 0);
for a in &args[1..] {
self.compile_expr(b, a)?;
}
b.emit(
Op::CallBuiltin(ops::ARR_MUT, (args.len() + 1) as u8),
self.cur_line,
);
} else if has_spread {
let idx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(idx), 0);
let (shown, diag) = self.byref_slots_for(name, args.len());
let mut seen_spread = false;
for (i, a) in args.iter().enumerate() {
match a {
Expr::Spread(inner) => {
seen_spread = true;
b.emit(Op::LoadTrue, 0);
self.compile_expr(b, inner)?;
}
_ => {
b.emit(Op::LoadFalse, 0);
self.compile_expr(b, a)?;
if !seen_spread {
if let Some((_, argno, param)) =
diag.iter().find(|(p, ..)| *p == i).cloned()
{
self.emit_byref_arg_diag(
b,
&shown,
argno,
¶m,
byref_arg_class(a),
);
}
}
}
}
}
b.emit(
Op::CallBuiltin(ops::CALL_SPREAD, (args.len() * 2 + 1) as u8),
self.cur_line,
);
let first_spread = args
.iter()
.position(|a| matches!(a, Expr::Spread(_)))
.unwrap_or(args.len());
if let Some((positions, guarded)) = self.byref_positions(name, args.len()) {
let known: Vec<usize> = positions
.into_iter()
.filter(|p| *p < first_spread)
.collect();
self.emit_byref_writeback(b, args, &known, guarded)?;
}
} else if is_direct_minmax2(name, args) {
let idx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(idx), 0);
for a in args {
self.compile_expr(b, a)?;
}
b.emit(Op::CallBuiltin(ops::MINMAX_FLF2, 3), self.cur_line);
} else {
let idx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(idx), 0);
self.emit_call_name_check(b, name, args.len());
let byref = self.byref_positions(name, args.len());
let diag = byref_diag_slots(name, args.len());
let user = self.byref_user_slots(name, args.len());
for (i, a) in args.iter().enumerate() {
let in_diag = diag.iter().any(|(p, ..)| *p == i);
match &byref {
Some((p, _)) if p.contains(&i) => self.compile_quiet(b, a)?,
_ if in_diag => self.compile_quiet(b, a)?,
_ => self.compile_expr(b, a)?,
}
if let Some(&(_, argno, param)) = diag.iter().find(|(p, ..)| *p == i) {
self.emit_byref_arg_diag(b, name, argno, param, byref_arg_class(a));
} else if let Some((spelled, argno, param)) =
user.as_ref().and_then(|(s, slots)| {
slots
.iter()
.find(|(p, ..)| *p == i)
.map(|(_, n, pn)| (s.clone(), *n, pn.clone()))
})
{
self.emit_byref_arg_diag(
b,
&spelled,
argno,
¶m,
byref_arg_class(a),
);
}
}
b.emit(
Op::CallBuiltin(ops::CALL, (args.len() + 1) as u8),
self.cur_line,
);
if let Some((positions, guarded)) = byref {
self.emit_byref_writeback(b, args, &positions, guarded)?;
}
}
}
Expr::Spread(_) => {
return Err("'...' argument unpacking is only valid in a function call".into())
}
Expr::Fcc { callable, instance } => self.compile_fcc(b, callable, *instance)?,
Expr::CallValue(callee, args) if needs_arg_pairs(args) => {
self.compile_expr(b, callee)?;
self.emit_callee_check(b, ops::CALLVALUE_CHECK, args.len());
self.compile_arg_pairs(b, args)?;
b.emit(
Op::CallBuiltin(ops::CALLVALUE_NAMED, (args.len() * 2 + 1) as u8),
self.cur_line,
);
}
Expr::CallValue(callee, args) => {
self.compile_expr(b, callee)?;
self.emit_callee_check(b, ops::CALLVALUE_CHECK, args.len());
for a in args {
self.compile_expr(b, a)?;
}
b.emit(
Op::CallBuiltin(ops::CALL_VALUE, (args.len() + 1) as u8),
self.cur_line,
);
let all = (0..args.len()).collect::<Vec<_>>();
self.emit_byref_writeback(b, args, &all, true)?;
}
Expr::Closure {
params,
uses,
body,
ret,
is_static,
line,
} => {
self.compile_closure(b, params, uses, body, ret.as_ref(), *is_static, *line)?;
}
Expr::ArrowFn {
params,
body,
ret: ret_ty,
line,
} => {
let ret = vec![Stmt {
line: 0,
kind: StmtKind::Return(Some((**body).clone())),
}];
let mut captures = Vec::new();
collect_free_vars(body, &mut captures);
captures.retain(|n| !params.iter().any(|p| p.name == *n));
let captures: Vec<Capture> = captures
.into_iter()
.map(|name| Capture {
name,
by_ref: false,
})
.collect();
self.compile_closure(b, params, &captures, &ret, ret_ty.as_ref(), false, *line)?;
}
Expr::NewAnon { decl, args, line } => {
let name = self.anon_class_name(decl, *line);
let named = ClassDecl {
name: name.clone(),
..(**decl).clone()
};
let site = self.cur_line;
self.compile_class(b, &named)?;
self.cur_line = *line;
self.compile_expr(b, &Expr::New(name, args.clone()))?;
self.cur_line = site;
}
Expr::New(class, args) if needs_arg_pairs(args) => {
self.emit_class_name(b, class)?;
self.emit_callee_check(b, ops::CALL_CLASS_CHECK, args.len());
self.compile_arg_pairs(b, args)?;
b.emit(
Op::CallBuiltin(ops::NEW_NAMED, (args.len() * 2 + 1) as u8),
self.cur_line,
);
}
Expr::New(class, args) => {
self.emit_class_name(b, class)?;
self.emit_callee_check(b, ops::CALL_CLASS_CHECK, args.len());
for a in args {
self.compile_expr(b, a)?;
}
b.emit(
Op::CallBuiltin(ops::NEW, (args.len() + 1) as u8),
self.cur_line,
);
}
Expr::PropGet(recv, name) => {
self.compile_expr(b, recv)?;
self.emit_member(b, name, 0)?;
b.emit(Op::CallBuiltin(ops::PROP_GET, 2), self.cur_line);
}
Expr::MethodCall(recv, name, args) if needs_arg_pairs(args) => {
self.compile_expr(b, recv)?;
let name = &self.method_member(b, name, args.len())?;
self.emit_mcall_recv_check(b, name, args.len())?;
self.emit_member(b, name, 0)?;
self.compile_arg_pairs(b, args)?;
b.emit(
Op::CallBuiltin(ops::MCALL_NAMED, (args.len() * 2 + 2) as u8),
self.cur_line,
);
}
Expr::MethodCall(recv, name, args) => {
self.compile_expr(b, recv)?;
let name = &self.method_member(b, name, args.len())?;
self.emit_mcall_recv_check(b, name, args.len())?;
self.emit_member(b, name, 0)?;
for a in args {
self.compile_expr(b, a)?;
}
b.emit(
Op::CallBuiltin(ops::MCALL, (args.len() + 2) as u8),
self.cur_line,
);
let all = (0..args.len()).collect::<Vec<_>>();
self.emit_byref_writeback(b, args, &all, true)?;
}
Expr::NullsafePropGet(..) | Expr::NullsafeMethodCall(..) => {
self.compile_nullsafe_chain(b, e, false)?;
}
Expr::NamedArg(_, inner) => {
self.compile_expr(b, inner)?;
}
Expr::StaticGet(class, name) => {
if name.eq_ignore_ascii_case("class") {
match class {
ClassRef::Expr(e) => {
self.compile_expr(b, e)?;
b.emit(Op::CallBuiltin(ops::DYN_CLASS_CONST, 1), self.cur_line);
}
ClassRef::Name(_) => self.emit_class_ref(b, class)?,
}
} else {
self.emit_class_ref(b, class)?;
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), 0);
b.emit(Op::CallBuiltin(ops::SCONST, 2), self.cur_line);
}
}
Expr::StaticProp(class, name) => {
self.emit_class_ref(b, class)?;
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), 0);
b.emit(Op::CallBuiltin(ops::SPROP_GET, 2), 0);
}
Expr::StaticCall(class, name, args) if needs_arg_pairs(args) => {
self.emit_lsb_forward(b, class);
self.emit_class_ref(b, class)?;
let nidx = b.add_constant(Value::str(name.clone()));
self.emit_scall_callee_check(b, nidx, args.len());
b.emit(Op::LoadConst(nidx), 0);
self.compile_arg_pairs(b, args)?;
b.emit(
Op::CallBuiltin(ops::SCALL_NAMED, (args.len() * 2 + 2) as u8),
self.cur_line,
);
}
Expr::StaticCall(class, name, args) => {
self.emit_lsb_forward(b, class);
self.emit_class_ref(b, class)?;
let nidx = b.add_constant(Value::str(name.clone()));
self.emit_scall_callee_check(b, nidx, args.len());
b.emit(Op::LoadConst(nidx), 0);
for a in args {
self.compile_expr(b, a)?;
}
b.emit(
Op::CallBuiltin(ops::SCALL, (args.len() + 2) as u8),
self.cur_line,
);
let all = (0..args.len()).collect::<Vec<_>>();
self.emit_byref_writeback(b, args, &all, true)?;
}
Expr::Ternary(c, t, f) => {
self.compile_truthy(b, c)?;
let jf = b.emit(Op::JumpIfFalse(0), 0);
self.compile_expr(b, t)?;
let jend = b.emit(Op::Jump(0), 0);
let els = b.current_pos();
b.patch_jump(jf, els);
self.compile_expr(b, f)?;
let end = b.current_pos();
b.patch_jump(jend, end);
}
Expr::Elvis(a, els) => {
self.compile_expr(b, a)?; b.emit(Op::Dup, 0); b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0); let keep = b.emit(Op::JumpIfTrue(0), 0); b.emit(Op::Pop, 0); self.compile_expr(b, els)?; let jend = b.emit(Op::Jump(0), 0);
let keep_pos = b.current_pos();
b.patch_jump(keep, keep_pos);
let end = b.current_pos();
b.patch_jump(jend, end);
}
Expr::Quiet(inner) => self.compile_quiet(b, inner)?,
Expr::Suppress(inner) => {
b.emit(Op::CallBuiltin(ops::SUPPRESS_PUSH, 0), self.cur_line);
b.emit(Op::Pop, self.cur_line);
self.compile_expr(b, inner)?;
b.emit(Op::CallBuiltin(ops::SUPPRESS_POP, 1), self.cur_line);
}
Expr::IssetOf(inner) => match inner.as_ref() {
Expr::PropGet(recv, name) => {
self.compile_quiet(b, recv)?;
self.emit_member(b, name, self.cur_line)?;
b.emit(Op::CallBuiltin(ops::PROP_ISSET, 2), self.cur_line);
}
Expr::Index(recv, key) => {
self.compile_quiet(b, recv)?;
self.compile_expr(b, key)?;
b.emit(Op::CallBuiltin(ops::INDEX_ISSET, 2), self.cur_line);
}
other => {
self.compile_quiet(b, other)?;
let idx = b.add_constant(Value::Undef);
b.emit(Op::LoadConst(idx), self.cur_line);
b.emit(Op::CallBuiltin(ops::STRICT_NE, 2), self.cur_line);
}
},
Expr::EmptyOf(inner) => match inner.as_ref() {
Expr::PropGet(recv, name) => {
self.compile_quiet(b, recv)?;
self.emit_member(b, name, self.cur_line)?;
b.emit(Op::CallBuiltin(ops::PROP_GET_EMPTY, 2), self.cur_line);
}
Expr::Index(recv, key) => {
self.compile_quiet(b, recv)?;
self.compile_expr(b, key)?;
b.emit(Op::CallBuiltin(ops::INDEX_GET_EMPTY, 2), self.cur_line);
}
other => self.compile_quiet(b, other)?,
},
Expr::Coalesce(a, els) => {
self.compile_quiet(b, a)?; b.emit(Op::Dup, 0); b.emit(Op::LoadUndef, 0); b.emit(Op::CallBuiltin(ops::STRICT_EQ, 2), 0); b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0); let use_b = b.emit(Op::JumpIfTrue(0), 0); let jend = b.emit(Op::Jump(0), 0); let use_b_pos = b.current_pos();
b.patch_jump(use_b, use_b_pos);
b.emit(Op::Pop, 0); self.compile_expr(b, els)?; let end = b.current_pos();
b.patch_jump(jend, end);
}
Expr::Match { subj, arms } => self.compile_match(b, subj, arms)?,
Expr::Clone(inner) => {
self.compile_expr(b, inner)?;
b.emit(Op::CallBuiltin(ops::CLONE, 1), self.cur_line);
}
Expr::Throw(inner) => {
self.compile_expr(b, inner)?;
b.emit(Op::CallBuiltin(ops::THROW, 1), self.cur_line);
}
Expr::ConstFetch(name) => {
let idx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(idx), 0);
b.emit(Op::CallBuiltin(ops::CONST_FETCH, 1), self.cur_line);
}
Expr::Magic(m) => {
let (op, prefix, suffix) = match m {
MagicConst::File { prefix, suffix } => (ops::MAGIC_FILE, prefix, suffix),
MagicConst::Class { prefix, suffix } => (ops::MAGIC_CLASS, prefix, suffix),
MagicConst::Dir => {
b.emit(Op::CallBuiltin(ops::MAGIC_DIR, 0), 0);
return Ok(());
}
};
let p = b.add_constant(Value::str(prefix.clone()));
b.emit(Op::LoadConst(p), 0);
let s = b.add_constant(Value::str(suffix.clone()));
b.emit(Op::LoadConst(s), 0);
b.emit(Op::CallBuiltin(op, 2), 0);
}
Expr::Unset(targets) => {
for t in targets {
self.compile_unset_target(b, t)?;
}
b.emit(Op::LoadUndef, 0);
}
Expr::InstanceOf(e, class) => {
self.compile_expr(b, e)?;
self.emit_class_name(b, class)?;
b.emit(Op::CallBuiltin(ops::INSTANCEOF, 2), 0);
}
Expr::RefAssign(lhs, rhs) => self.compile_ref_assign(b, lhs, rhs)?,
Expr::Yield { key, value } => {
match value {
Some(v) => self.compile_expr(b, v)?,
None => {
b.emit(Op::LoadUndef, 0);
}
}
match key {
Some(k) => {
self.compile_expr(b, k)?;
b.emit(Op::CallBuiltin(ops::YIELD_KV, 2), 0);
}
None => {
b.emit(Op::CallBuiltin(ops::YIELD, 1), 0);
}
}
}
Expr::Print(operand) => {
let line = self.cur_line;
self.compile_expr(b, operand)?;
b.emit(Op::CallBuiltin(ops::ECHO, 1), line);
b.emit(Op::Pop, line);
let idx = b.add_constant(Value::int(1));
b.emit(Op::LoadConst(idx), line);
}
Expr::YieldFrom(src) => {
self.compile_expr(b, src)?;
b.emit(Op::CallBuiltin(ops::YIELD_FROM, 1), 0);
}
Expr::Include(kind, path) => {
let line = self.cur_line;
self.compile_expr(b, path)?;
b.emit(Op::LoadInt(kind.code()), line);
b.emit(Op::CallBuiltin(ops::INCLUDE, 2), line);
}
Expr::Eval(code) => {
let line = self.cur_line;
self.compile_expr(b, code)?;
b.emit(Op::CallBuiltin(ops::EVAL, 1), line);
}
}
Ok(())
}
fn compile_quiet(&mut self, b: &mut ChunkBuilder, e: &Expr) -> Result<(), String> {
if chain_has_nullsafe(e) {
return self.compile_nullsafe_chain(b, e, true);
}
let line = self.cur_line;
match e {
Expr::Quiet(inner) => self.compile_quiet(b, inner)?,
Expr::Var(name) => {
if let Some(&i) = self.fslots.get(name) {
b.emit(Op::GetSlot(i), line);
} else if let Some(&i) = self.slots.get(name) {
b.emit(Op::LoadInt(i as i64), line);
b.emit(Op::CallBuiltin(ops::GETSLOT_Q, 1), line);
} else {
let idx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(idx), line);
b.emit(Op::CallBuiltin(ops::GETVAR_Q, 1), line);
}
}
Expr::VarVar(inner) => {
self.compile_expr(b, inner)?;
b.emit(Op::CallBuiltin(ops::GETVAR_Q, 1), line);
}
Expr::Index(recv, idx) => {
self.compile_quiet(b, recv)?;
self.compile_expr(b, idx)?;
b.emit(Op::CallBuiltin(ops::INDEX_GET_Q, 2), line);
}
Expr::PropGet(recv, name) => {
self.compile_quiet(b, recv)?;
self.emit_member(b, name, line)?;
b.emit(Op::CallBuiltin(ops::PROP_GET_Q, 2), line);
}
Expr::StaticProp(class, name) => {
self.emit_class_ref(b, class)?;
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), line);
b.emit(Op::CallBuiltin(ops::SPROP_GET_Q, 2), line);
}
other => self.compile_expr(b, other)?,
}
Ok(())
}
fn compile_ref_assign(
&mut self,
b: &mut ChunkBuilder,
lhs: &Expr,
rhs: &Expr,
) -> Result<(), String> {
if let (Expr::Var(t), Expr::Var(s)) = (lhs, rhs) {
let ti = b.add_constant(Value::str(t.clone()));
b.emit(Op::LoadConst(ti), 0);
let si = b.add_constant(Value::str(s.clone()));
b.emit(Op::LoadConst(si), 0);
b.emit(Op::CallBuiltin(ops::REF_BIND, 2), 0);
return Ok(());
}
match lhs {
Expr::Var(name) => {
let ni = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(ni), 0);
self.compile_ref_slot(b, rhs)?;
b.emit(Op::CallBuiltin(ops::REF_TO_VAR, 2), 0);
}
Expr::Index(..) | Expr::Append(..) => {
let (root, segs) = Self::flatten_segments(lhs)?;
let name = self.ref_root_name(b, root)?;
let append = matches!(segs.last(), Some(LvSeg::Append));
let key_segs = if append {
&segs[..segs.len() - 1]
} else {
&segs[..]
};
let ni = b.add_constant(Value::str(name));
b.emit(Op::LoadConst(ni), 0);
for s in key_segs {
match s {
LvSeg::Key(k) => self.compile_expr(b, k)?,
LvSeg::Append => {
return Err("`[]` may appear only as the last segment of a \
reference assignment"
.into())
}
}
}
self.compile_ref_slot(b, rhs)?;
let op = if append {
ops::REF_TO_APPEND
} else {
ops::REF_TO_ELEM
};
b.emit(Op::CallBuiltin(op, (key_segs.len() + 2) as u8), 0);
}
Expr::PropGet(recv, prop) => {
self.compile_expr(b, recv)?;
self.emit_member(b, prop, 0)?;
self.compile_ref_slot(b, rhs)?;
b.emit(Op::CallBuiltin(ops::REF_TO_PROP, 3), 0);
}
_ => {
return Err(
"reference `= &` assigns only to a variable, an array element or \
an object property"
.into(),
)
}
}
Ok(())
}
fn compile_ref_slot(&mut self, b: &mut ChunkBuilder, src: &Expr) -> Result<(), String> {
match src {
Expr::Var(name) => {
let ni = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(ni), 0);
b.emit(Op::CallBuiltin(ops::REF_SLOT_VAR, 1), 0);
}
Expr::Index(..) => {
let (root, segs) = Self::flatten_segments(src)?;
let name = self.ref_root_name(b, root)?;
let ni = b.add_constant(Value::str(name));
b.emit(Op::LoadConst(ni), 0);
for s in &segs {
match s {
LvSeg::Key(k) => self.compile_expr(b, k)?,
LvSeg::Append => return Err("cannot take a reference to `$a[]`".into()),
}
}
b.emit(
Op::CallBuiltin(ops::REF_SLOT_ELEM, (segs.len() + 1) as u8),
0,
);
}
Expr::PropGet(recv, prop) => {
self.compile_expr(b, recv)?;
self.emit_member(b, prop, 0)?;
b.emit(Op::CallBuiltin(ops::REF_SLOT_PROP, 2), 0);
}
Expr::Call(..) | Expr::MethodCall(..) | Expr::StaticCall(..) | Expr::CallValue(..) => {
self.compile_expr(b, src)?;
b.emit(Op::CallBuiltin(ops::REF_SLOT_RET, 1), 0);
}
_ => {
return Err(
"`&` takes a reference to a variable, an array element or an \
object property"
.into(),
)
}
}
Ok(())
}
fn ref_root_name(&mut self, b: &mut ChunkBuilder, root: &Expr) -> Result<String, String> {
match root {
Expr::Var(name) => Ok(name.clone()),
Expr::PropGet(recv, prop) => {
let tmp = self.tmp_name("ref");
let (recv, prop) = (recv.as_ref().clone(), prop.clone());
self.emit_set_var(b, &tmp, |c, b| {
c.compile_expr(b, &recv)?;
c.emit_member(b, &prop, 0)?;
b.emit(Op::CallBuiltin(ops::PROP_ENSURE_ARRAY, 2), c.cur_line);
Ok(())
})?;
Ok(tmp)
}
_ => Err("a reference path must be rooted at a variable or a property".into()),
}
}
fn compile_unset_target(&mut self, b: &mut ChunkBuilder, t: &Expr) -> Result<(), String> {
match t {
Expr::PropGet(recv, prop) => {
self.compile_expr(b, recv)?;
self.emit_member(b, prop, self.cur_line)?;
b.emit(Op::CallBuiltin(ops::PROP_UNSET, 2), self.cur_line);
b.emit(Op::Pop, self.cur_line);
}
Expr::Var(name) => {
let idx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(idx), 0);
b.emit(Op::CallBuiltin(ops::UNSET_VAR, 1), 0);
b.emit(Op::Pop, 0);
}
Expr::VarVar(inner) => {
self.compile_expr(b, inner)?;
b.emit(Op::CallBuiltin(ops::UNSET_VAR, 1), 0);
b.emit(Op::Pop, 0);
}
Expr::Index(..) => {
let (root, segs) = Self::flatten_segments(t)?;
let name = match root {
Expr::Var(name) => name.clone(),
Expr::PropGet(..) | Expr::StaticProp(..) => {
let tmp = self.tmp_name("uns");
let root = root.clone();
self.emit_set_var(b, &tmp, |c, b| c.compile_expr(b, &root))?;
b.emit(Op::Pop, 0);
tmp
}
_ => {
return Err(
"unset() supports only `$var`, `$var[...]` and `$obj->prop[...]` \
targets"
.into(),
)
}
};
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), 0);
for seg in &segs {
match seg {
LvSeg::Key(k) => self.compile_expr(b, k)?,
LvSeg::Append => return Err("cannot unset an `[]` append target".into()),
}
}
b.emit(
Op::CallBuiltin(ops::UNSET_PATH, (segs.len() + 1) as u8),
self.cur_line,
);
b.emit(Op::Pop, 0);
}
_ => return Err("unset() target must be a variable or an array element".into()),
}
Ok(())
}
fn compile_match(
&mut self,
b: &mut ChunkBuilder,
subj: &Expr,
arms: &[MatchArm],
) -> Result<(), String> {
let m_t = self.tmp_name("m");
self.emit_set_var(b, &m_t, |c, b| c.compile_expr(b, subj))?;
let mut dispatch: Vec<(usize, usize)> = Vec::new(); let mut default_index: Option<usize> = None;
for (i, arm) in arms.iter().enumerate() {
match &arm.conds {
Some(conds) => {
for cond in conds {
self.emit_get_var(b, &m_t);
self.compile_expr(b, cond)?;
b.emit(Op::CallBuiltin(ops::STRICT_EQ, 2), 0);
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
let jt = b.emit(Op::JumpIfTrue(0), 0);
dispatch.push((i, jt));
}
}
None => default_index = Some(i),
}
}
let default_jump = if default_index.is_some() {
Some(b.emit(Op::Jump(0), 0))
} else {
let cls = b.add_constant(Value::str("UnhandledMatchError".to_string()));
b.emit(Op::LoadConst(cls), 0);
self.emit_get_var(b, &m_t);
b.emit(Op::CallBuiltin(ops::MATCH_ERROR_MSG, 1), 0); b.emit(Op::CallBuiltin(ops::NEW, 2), self.cur_line); b.emit(Op::CallBuiltin(ops::THROW, 1), self.cur_line); None
};
let mut body_starts = Vec::with_capacity(arms.len());
let mut body_ends = Vec::with_capacity(arms.len());
for arm in arms {
body_starts.push(b.current_pos());
self.compile_expr(b, &arm.body)?;
body_ends.push(b.emit(Op::Jump(0), 0));
}
let end = b.current_pos();
for (i, jt) in dispatch {
b.patch_jump(jt, body_starts[i]);
}
if let Some(di) = default_index {
b.patch_jump(default_jump.unwrap(), body_starts[di]);
}
for j in body_ends {
b.patch_jump(j, end);
}
Ok(())
}
fn compile_interp(&mut self, b: &mut ChunkBuilder, parts: &[InterpPart]) -> Result<(), String> {
let empty = b.add_constant(Value::str(String::new()));
b.emit(Op::LoadConst(empty), 0);
for part in parts {
match part {
InterpPart::Lit(s) => {
let idx = b.add_constant(Value::str(s.clone()));
b.emit(Op::LoadConst(idx), 0);
}
InterpPart::Expr(e) => self.compile_expr(b, e)?,
}
b.emit(Op::CallBuiltin(ops::CONCAT, 2), self.cur_line);
}
Ok(())
}
fn compile_binary(
&mut self,
b: &mut ChunkBuilder,
op: BinOp,
l: &Expr,
r: &Expr,
) -> Result<(), String> {
if matches!(op, BinOp::And | BinOp::Or) {
self.compile_truthy(b, l)?;
let short = if op == BinOp::And {
b.emit(Op::JumpIfFalse(0), 0)
} else {
b.emit(Op::JumpIfTrue(0), 0)
};
self.compile_truthy(b, r)?;
let jend = b.emit(Op::Jump(0), 0);
let shortcut = b.current_pos();
b.patch_jump(short, shortcut);
b.emit(
if op == BinOp::And {
Op::LoadFalse
} else {
Op::LoadTrue
},
0,
);
let end = b.current_pos();
b.patch_jump(jend, end);
return Ok(());
}
let swap = op == BinOp::Mul && is_const_operand(l) && is_definitely_runtime(r);
if swap {
self.compile_expr(b, r)?;
self.compile_expr(b, l)?;
} else {
self.compile_expr(b, l)?;
self.compile_expr(b, r)?;
}
match op {
BinOp::Add => {
b.emit(Op::Add, self.cur_line);
}
BinOp::Sub => {
b.emit(Op::Sub, self.cur_line);
}
BinOp::Mul => {
b.emit(Op::Mul, self.cur_line);
}
BinOp::Div => {
b.emit(Op::CallBuiltin(ops::DIV, 2), self.cur_line);
}
BinOp::Mod => {
b.emit(Op::CallBuiltin(ops::MOD, 2), self.cur_line);
}
BinOp::Pow => {
b.emit(Op::CallBuiltin(ops::POW, 2), self.cur_line);
}
BinOp::Concat => {
b.emit(Op::CallBuiltin(ops::CONCAT, 2), self.cur_line);
}
BinOp::LooseEq => {
b.emit(Op::CallBuiltin(ops::LOOSE_EQ, 2), 0);
}
BinOp::LooseNe => {
b.emit(Op::CallBuiltin(ops::LOOSE_NE, 2), 0);
}
BinOp::StrictEq => {
b.emit(Op::CallBuiltin(ops::STRICT_EQ, 2), 0);
}
BinOp::StrictNe => {
b.emit(Op::CallBuiltin(ops::STRICT_NE, 2), 0);
}
BinOp::Lt => {
b.emit(Op::NumLt, self.cur_line);
}
BinOp::Gt => {
b.emit(Op::NumGt, self.cur_line);
}
BinOp::Le => {
b.emit(Op::NumLe, self.cur_line);
}
BinOp::Ge => {
b.emit(Op::NumGe, self.cur_line);
}
BinOp::Spaceship => {
b.emit(Op::CallBuiltin(ops::SPACESHIP, 2), 0);
}
BinOp::BitAnd => {
b.emit(Op::CallBuiltin(ops::BITAND, 2), self.cur_line);
}
BinOp::BitOr => {
b.emit(Op::CallBuiltin(ops::BITOR, 2), self.cur_line);
}
BinOp::BitXor => {
b.emit(Op::CallBuiltin(ops::BITXOR, 2), self.cur_line);
}
BinOp::Shl => {
b.emit(Op::CallBuiltin(ops::SHL, 2), self.cur_line);
}
BinOp::Shr => {
b.emit(Op::CallBuiltin(ops::SHR, 2), self.cur_line);
}
BinOp::And | BinOp::Or => unreachable!("handled above"),
}
Ok(())
}
fn compile_rhs(&mut self, b: &mut ChunkBuilder, rhs: &Expr) -> Result<(), String> {
self.compile_expr(b, rhs)?;
if !never_array(rhs) {
b.emit(Op::CallBuiltin(ops::COPY, 1), 0);
}
Ok(())
}
fn compile_assign(
&mut self,
b: &mut ChunkBuilder,
lhs: &Expr,
op: Option<BinOp>,
rhs: &Expr,
) -> Result<(), String> {
match lhs {
Expr::Var(name) => {
self.emit_var_target(b, name);
match op {
None => self.compile_rhs(b, rhs)?,
Some(cop) => {
self.emit_get_var(b, name);
self.compile_expr(b, rhs)?;
self.emit_binop(b, cop);
}
}
self.emit_store_var(b, name);
}
Expr::PropGet(recv, name) => {
match op {
None => {
self.compile_expr(b, recv)?;
self.emit_member(b, name, 0)?;
self.compile_rhs(b, rhs)?;
b.emit(Op::CallBuiltin(ops::PROP_SET, 3), self.cur_line);
}
Some(cop) => {
let r = self.tmp_name("pr");
self.emit_set_var(b, &r, |c, b| c.compile_expr(b, recv))?;
let name = &self.stash_member(b, name)?;
self.emit_get_var(b, &r);
self.emit_member(b, name, 0)?;
b.emit(Op::CallBuiltin(ops::PROP_TOUCH, 2), self.cur_line);
self.emit_member(b, name, 0)?;
self.emit_get_var(b, &r);
self.emit_member(b, name, 0)?;
b.emit(Op::CallBuiltin(ops::PROP_GET, 2), self.cur_line);
self.compile_rhs(b, rhs)?;
self.emit_binop(b, cop);
b.emit(Op::CallBuiltin(ops::PROP_SET_RW, 3), self.cur_line);
}
}
}
Expr::Index(..) | Expr::Append(..) => {
let (root, segs) = Self::flatten_segments(lhs)?;
match root {
Expr::Var(name) => self.compile_lvalue_assign(b, name, &segs, op, rhs)?,
Expr::PropGet(recv, prop) => {
let t = self.tmp_name("po");
self.emit_set_var(b, &t, |c, b| {
c.compile_expr(b, recv)?;
c.emit_member(b, prop, 0)?;
b.emit(Op::CallBuiltin(ops::PROP_ENSURE_ARRAY, 2), c.cur_line);
Ok(())
})?;
self.compile_lvalue_assign(b, &t, &segs, op, rhs)?;
}
_ => return Err("unsupported assignment target".into()),
}
}
Expr::StaticProp(class, name) => {
self.emit_class_ref(b, class)?;
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), 0);
match op {
None => self.compile_rhs(b, rhs)?,
Some(cop) => {
self.compile_expr(b, lhs)?;
self.compile_rhs(b, rhs)?;
self.emit_binop(b, cop);
}
}
b.emit(Op::CallBuiltin(ops::SPROP_SET, 3), 0);
}
Expr::Array(elems) => {
if op.is_some() {
return Err("compound assignment cannot target a list()/[] pattern".into());
}
let ref_root = Self::ref_source(rhs);
if ref_root.is_none() && Self::pattern_binds_by_ref(elems) && is_literal(rhs) {
return Err("Cannot assign reference to non referenceable value".into());
}
let src = self.tmp_name("list");
self.emit_set_var(b, &src, |c, b| c.compile_rhs(b, rhs))?;
self.compile_list_targets(b, elems, &src, ref_root)?;
self.emit_get_var(b, &src);
}
Expr::VarVar(inner) => {
self.compile_expr(b, inner)?;
match op {
None => self.compile_rhs(b, rhs)?,
Some(cop) => {
b.emit(Op::Dup, 0);
b.emit(Op::CallBuiltin(ops::GETVAR, 1), self.cur_line);
self.compile_expr(b, rhs)?;
self.emit_binop(b, cop);
}
}
b.emit(Op::CallBuiltin(ops::SETVAR, 2), self.cur_line);
}
_ => return Err("invalid assignment target".into()),
}
Ok(())
}
fn ref_source(rhs: &Expr) -> Option<&Expr> {
match rhs {
Expr::Var(_) | Expr::Index(..) | Expr::PropGet(..) => Some(rhs),
_ => None,
}
}
fn pattern_binds_by_ref(elems: &[ArrayElem]) -> bool {
elems.iter().any(|e| {
e.by_ref
|| match &e.value {
Expr::Array(inner) => Self::pattern_binds_by_ref(inner),
_ => false,
}
})
}
fn compile_list_targets(
&mut self,
b: &mut ChunkBuilder,
elems: &[ArrayElem],
value_tmp: &str,
ref_path: Option<&Expr>,
) -> Result<(), String> {
let mut counter: i64 = 0;
for e in elems {
let key = match &e.key {
Some(ke) => ke.clone(),
None => {
let i = counter;
counter += 1;
Expr::Int(i)
}
};
if matches!(e.value, Expr::Null) {
continue;
}
let elem = Expr::ListElem(
Box::new(Expr::Var(value_tmp.to_string())),
Box::new(key.clone()),
);
let deeper = ref_path.map(|p| Expr::Index(Box::new(p.clone()), Box::new(key.clone())));
match &e.value {
Expr::Array(inner) => {
let inner_tmp = self.tmp_name("list");
self.emit_set_var(b, &inner_tmp, |c, b| c.compile_expr(b, &elem))?;
self.compile_list_targets(b, inner, &inner_tmp, deeper.as_ref())?;
}
target if e.by_ref => match &deeper {
Some(source) => {
self.compile_ref_assign(b, target, source)?;
b.emit(Op::Pop, 0);
}
None => {
self.compile_assign(b, target, None, &elem)?;
b.emit(Op::Pop, 0);
}
},
target => {
self.compile_assign(b, target, None, &elem)?;
b.emit(Op::Pop, 0);
}
}
}
Ok(())
}
fn flatten_segments(lhs: &Expr) -> Result<(&Expr, Vec<LvSeg<'_>>), String> {
let mut cur = lhs;
let mut segs: Vec<LvSeg> = Vec::new();
loop {
match cur {
Expr::Index(recv, idx) => {
segs.push(LvSeg::Key(idx));
cur = recv;
}
Expr::Append(inner) => {
segs.push(LvSeg::Append);
cur = inner;
}
other => {
segs.reverse();
return Ok((other, segs));
}
}
}
}
fn compile_lvalue_assign(
&mut self,
b: &mut ChunkBuilder,
name: &str,
segs: &[LvSeg],
op: Option<BinOp>,
rhs: &Expr,
) -> Result<(), String> {
let mid = segs
.iter()
.position(|s| matches!(s, LvSeg::Append))
.filter(|&i| i + 1 < segs.len());
if let Some(i) = mid {
let prefix: Vec<&Expr> = segs[..i]
.iter()
.map(|s| match s {
LvSeg::Key(k) => *k,
LvSeg::Append => unreachable!("first mid-append has no earlier append"),
})
.collect();
let t = self.tmp_name("ap");
self.emit_set_var(b, &t, |c, b| {
let nidx = b.add_constant(Value::str(name.to_string()));
b.emit(Op::LoadConst(nidx), 0);
for k in &prefix {
c.compile_expr(b, k)?;
}
b.emit(
Op::CallBuiltin(ops::PATH_APPEND_CHILD, (prefix.len() + 1) as u8),
0,
);
Ok(())
})?;
return self.compile_lvalue_assign(b, &t, &segs[i + 1..], op, rhs);
}
let append = matches!(segs.last(), Some(LvSeg::Append));
let key_segs = if append {
&segs[..segs.len() - 1]
} else {
segs
};
let keys: Vec<&Expr> = key_segs
.iter()
.map(|s| match s {
LvSeg::Key(k) => *k,
LvSeg::Append => unreachable!("only the final segment may be an append here"),
})
.collect();
if append {
if op.is_some() {
return Err("`[]` append takes only plain `=`".into());
}
let nidx = b.add_constant(Value::str(name.to_string()));
b.emit(Op::LoadConst(nidx), 0);
if keys.is_empty() {
self.compile_rhs(b, rhs)?;
b.emit(Op::CallBuiltin(ops::ARR_APPEND, 2), 0);
} else {
for k in &keys {
self.compile_expr(b, k)?;
}
self.compile_rhs(b, rhs)?;
b.emit(Op::CallBuiltin(ops::APPEND_PATH, (keys.len() + 2) as u8), 0);
}
} else if keys.len() == 1 && op.is_none() {
let nidx = b.add_constant(Value::str(name.to_string()));
b.emit(Op::LoadConst(nidx), 0);
self.compile_expr(b, keys[0])?;
self.compile_rhs(b, rhs)?;
b.emit(Op::CallBuiltin(ops::INDEX_SET, 3), self.cur_line);
} else {
self.compile_index_assign(b, name, &keys, op, rhs)?;
}
Ok(())
}
fn compile_index_assign(
&mut self,
b: &mut ChunkBuilder,
name: &str,
keys: &[&Expr],
op: Option<BinOp>,
rhs: &Expr,
) -> Result<(), String> {
let nidx = b.add_constant(Value::str(name.to_string()));
match op {
None => {
b.emit(Op::LoadConst(nidx), 0);
for k in keys {
self.compile_expr(b, k)?;
}
self.compile_rhs(b, rhs)?;
b.emit(Op::CallBuiltin(ops::SET_PATH, (keys.len() + 2) as u8), 0);
}
Some(cop) => {
let key_tmps: Vec<String> = keys.iter().map(|_| self.tmp_name("lk")).collect();
for (t, k) in key_tmps.iter().zip(keys) {
self.emit_set_var(b, t, |c, b| c.compile_expr(b, k))?;
}
b.emit(Op::LoadConst(nidx), 0);
for t in &key_tmps {
self.emit_get_var(b, t);
}
b.emit(Op::LoadConst(nidx), 0);
for t in &key_tmps {
self.emit_get_var(b, t);
}
b.emit(
Op::CallBuiltin(ops::GET_PATH, (key_tmps.len() + 1) as u8),
self.cur_line,
);
self.compile_rhs(b, rhs)?;
self.emit_binop(b, cop);
b.emit(
Op::CallBuiltin(ops::SET_PATH, (key_tmps.len() + 2) as u8),
0,
);
}
}
Ok(())
}
fn compile_fcc(
&mut self,
b: &mut ChunkBuilder,
callable: &Expr,
instance: bool,
) -> Result<(), String> {
let tmp = self.tmp_name("fcc");
self.emit_set_var(b, &tmp, |c, b| {
c.compile_expr(b, callable)?;
b.emit(
if instance {
Op::LoadTrue
} else {
Op::LoadFalse
},
0,
);
b.emit(Op::CallBuiltin(ops::FCC_CHECK, 2), c.cur_line);
Ok(())
})?;
let param = Param {
name: "args".to_string(),
line: self.cur_line,
ty: None,
default: None,
variadic: true,
promoted: false,
readonly: false,
by_ref: false,
};
let body = Expr::Call(
"call_user_func_array".to_string(),
vec![Expr::Var(tmp), Expr::Var("args".to_string())],
);
self.compile_expr(
b,
&Expr::ArrowFn {
params: vec![param],
body: Box::new(body),
ret: None,
line: self.cur_line,
},
)
}
#[allow(clippy::too_many_arguments)]
fn compile_closure(
&mut self,
b: &mut ChunkBuilder,
params: &[Param],
captures: &[Capture],
body: &[Stmt],
ret: Option<&TypeHint>,
is_static: bool,
line: u32,
) -> Result<(), String> {
let cparams = self.compile_params(params)?;
let mut fb = ChunkBuilder::new();
let saved = std::mem::take(&mut self.loops);
let site = host::DeclSite::Closure(Box::new(self.decl_site.clone()), line);
let saved_site = std::mem::replace(&mut self.decl_site, site.clone());
self.in_other_frame(|c| c.compile_seq(&mut fb, body))?;
self.decl_site = saved_site;
self.loops = saved;
let def_name = self.tmp_name("closure");
self.functions.push((
def_name.clone(),
FuncDef {
params: cparams,
chunk: fb.build(),
is_generator: body_has_yield(body),
ret: ret.cloned(),
locals: Vec::new(),
closure_site: Some(site),
},
));
let nidx = b.add_constant(Value::str(def_name));
b.emit(Op::LoadConst(nidx), 0);
if is_static {
let kidx = b.add_constant(Value::str(host::STATIC_CLOSURE_CAPTURE.to_string()));
b.emit(Op::LoadConst(kidx), 0);
b.emit(Op::LoadTrue, 0);
}
for cap in captures {
let cidx = b.add_constant(Value::str(cap.name.clone()));
b.emit(Op::LoadConst(cidx), 0);
if cap.by_ref {
let nidx = b.add_constant(Value::str(cap.name.clone()));
b.emit(Op::LoadConst(nidx), 0);
b.emit(Op::CallBuiltin(ops::REF_CELL, 1), 0);
} else if cap.name == "this" {
self.compile_quiet(b, &Expr::Var("this".to_string()))?;
} else {
self.emit_get_var(b, &cap.name);
}
}
b.emit(
Op::CallBuiltin(
ops::MKCLOSURE,
(1 + (captures.len() + usize::from(is_static)) * 2) as u8,
),
0,
);
Ok(())
}
fn compile_incdec(
&mut self,
b: &mut ChunkBuilder,
target: &Expr,
inc: bool,
prefix: bool,
) -> Result<(), String> {
let code = (inc as i64) | ((prefix as i64) << 1);
match target {
Expr::Var(name) if self.fslots.contains_key(name) && self.fnumeric.contains(name) => {
let i = self.fslots[name];
b.emit(Op::GetSlot(i), self.cur_line);
if prefix {
b.emit(Op::LoadInt(1), 0);
b.emit(if inc { Op::Add } else { Op::Sub }, self.cur_line);
b.emit(Op::Dup, 0);
b.emit(Op::SetSlot(i), self.cur_line);
} else {
b.emit(Op::Dup, 0);
b.emit(Op::LoadInt(1), 0);
b.emit(if inc { Op::Add } else { Op::Sub }, self.cur_line);
b.emit(Op::SetSlot(i), self.cur_line);
}
}
Expr::Var(name) if self.fslots.contains_key(name) => {
let i = self.fslots[name];
b.emit(Op::GetSlot(i), self.cur_line);
if prefix {
b.emit(Op::LoadInt(i64::from(inc)), 0);
b.emit(Op::CallBuiltin(ops::INCDEC_STEP, 2), self.cur_line);
b.emit(Op::Dup, 0);
b.emit(Op::SetSlot(i), self.cur_line);
} else {
b.emit(Op::Dup, 0);
b.emit(Op::LoadInt(i64::from(inc)), 0);
b.emit(Op::CallBuiltin(ops::INCDEC_STEP, 2), self.cur_line);
b.emit(Op::SetSlot(i), self.cur_line);
}
}
Expr::Var(name) => match self.slots.get(name) {
Some(&i) => {
b.emit(Op::LoadInt(i as i64), 0);
b.emit(Op::LoadInt(code), 0);
b.emit(Op::CallBuiltin(ops::INCDEC_SLOT, 2), self.cur_line);
}
None => {
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), 0);
b.emit(Op::LoadInt(code), 0);
b.emit(Op::CallBuiltin(ops::INCDEC, 2), self.cur_line);
}
},
Expr::PropGet(recv, name) => {
self.compile_expr(b, recv)?;
self.emit_member(b, name, 0)?;
b.emit(Op::LoadInt(code), 0);
b.emit(Op::CallBuiltin(ops::PROP_INCDEC, 3), self.cur_line);
}
Expr::StaticProp(class, name) => {
self.emit_class_ref(b, class)?;
let nidx = b.add_constant(Value::str(name.clone()));
b.emit(Op::LoadConst(nidx), 0);
b.emit(Op::LoadInt(code), 0);
b.emit(Op::CallBuiltin(ops::SPROP_INCDEC, 3), self.cur_line);
}
Expr::Index(..) => {
let (root, segs) = Self::flatten_segments(target)?;
let mut keys: Vec<&Expr> = Vec::with_capacity(segs.len());
for s in &segs {
match s {
LvSeg::Key(k) => keys.push(k),
LvSeg::Append => return Err("cannot ++/-- an `[]` append target".into()),
}
}
let name: String = match root {
Expr::Var(name) => name.clone(),
Expr::PropGet(recv, prop) => {
let t = self.tmp_name("po");
self.emit_set_var(b, &t, |c, b| {
c.compile_expr(b, recv)?;
c.emit_member(b, prop, 0)?;
b.emit(Op::CallBuiltin(ops::PROP_ENSURE_ARRAY, 2), c.cur_line);
Ok(())
})?;
t
}
_ => return Err("unsupported ++/-- target".into()),
};
let nidx = b.add_constant(Value::str(name));
b.emit(Op::LoadConst(nidx), 0);
for k in &keys {
self.compile_expr(b, k)?;
}
b.emit(Op::LoadInt(code), 0);
b.emit(
Op::CallBuiltin(ops::INCDEC_PATH, (keys.len() + 2) as u8),
self.cur_line,
);
}
_ => {
return Err(
"scaffold supports ++/-- only on variables, array elements, and properties"
.into(),
)
}
}
Ok(())
}
fn emit_binop(&mut self, b: &mut ChunkBuilder, op: BinOp) {
match op {
BinOp::Add => {
b.emit(Op::Add, self.cur_line);
}
BinOp::Sub => {
b.emit(Op::Sub, self.cur_line);
}
BinOp::Mul => {
b.emit(Op::Mul, self.cur_line);
}
BinOp::Div => {
b.emit(Op::CallBuiltin(ops::DIV, 2), self.cur_line);
}
BinOp::Mod => {
b.emit(Op::CallBuiltin(ops::MOD, 2), self.cur_line);
}
BinOp::Pow => {
b.emit(Op::CallBuiltin(ops::POW, 2), self.cur_line);
}
BinOp::Concat => {
b.emit(Op::CallBuiltin(ops::CONCAT, 2), self.cur_line);
}
BinOp::BitAnd => {
b.emit(Op::CallBuiltin(ops::BITAND, 2), self.cur_line);
}
BinOp::BitOr => {
b.emit(Op::CallBuiltin(ops::BITOR, 2), self.cur_line);
}
BinOp::BitXor => {
b.emit(Op::CallBuiltin(ops::BITXOR, 2), self.cur_line);
}
BinOp::Shl => {
b.emit(Op::CallBuiltin(ops::SHL, 2), self.cur_line);
}
BinOp::Shr => {
b.emit(Op::CallBuiltin(ops::SHR, 2), self.cur_line);
}
_ => unreachable!("compound assignment only uses arithmetic/bitwise/concat ops"),
}
}
fn compile_truthy(&mut self, b: &mut ChunkBuilder, e: &Expr) -> Result<(), String> {
self.compile_expr(b, e)?;
if !yields_bool(e) {
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0);
}
Ok(())
}
fn compile_nullsafe_chain(
&mut self,
b: &mut ChunkBuilder,
e: &Expr,
quiet: bool,
) -> Result<(), String> {
let mut spine = Vec::new();
let mut base = e;
while let Some(r) = chain_recv(base) {
spine.push(base);
base = r;
}
if quiet {
self.compile_quiet(b, base)?;
} else {
self.compile_expr(b, base)?;
}
let mut exits = Vec::new();
for link in spine.iter().rev() {
if matches!(
link,
Expr::NullsafePropGet(..) | Expr::NullsafeMethodCall(..)
) {
b.emit(Op::Dup, 0); b.emit(Op::LoadUndef, 0); b.emit(Op::CallBuiltin(ops::STRICT_EQ, 2), 0); b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 0); exits.push(b.emit(Op::JumpIfTrue(0), 0));
}
self.compile_chain_link(b, link, quiet)?;
}
let end = b.current_pos();
for j in exits {
b.patch_jump(j, end);
}
Ok(())
}
fn compile_chain_link(
&mut self,
b: &mut ChunkBuilder,
link: &Expr,
quiet: bool,
) -> Result<(), String> {
let line = self.cur_line;
match link {
Expr::PropGet(_, name) | Expr::NullsafePropGet(_, name) => {
self.emit_member(b, name, line)?;
let op = if quiet {
ops::PROP_GET_Q
} else {
ops::PROP_GET
};
b.emit(Op::CallBuiltin(op, 2), line);
}
Expr::Index(_, idx) => {
self.compile_expr(b, idx)?;
let op = if quiet {
ops::INDEX_GET_Q
} else {
ops::INDEX_GET
};
b.emit(Op::CallBuiltin(op, 2), line);
}
Expr::MethodCall(_, name, args) | Expr::NullsafeMethodCall(_, name, args) => {
let name = &self.method_member(b, name, args.len())?;
self.emit_mcall_recv_check(b, name, args.len())?;
self.emit_member(b, name, line)?;
if needs_arg_pairs(args) {
self.compile_arg_pairs(b, args)?;
b.emit(
Op::CallBuiltin(ops::MCALL_NAMED, (args.len() * 2 + 2) as u8),
line,
);
} else {
for a in args {
self.compile_expr(b, a)?;
}
b.emit(Op::CallBuiltin(ops::MCALL, (args.len() + 2) as u8), line);
let all = (0..args.len()).collect::<Vec<_>>();
self.emit_byref_writeback(b, args, &all, true)?;
}
}
other => return Err(format!("not an access-chain link: {other:?}")),
}
Ok(())
}
fn compile_arg_pairs(&mut self, b: &mut ChunkBuilder, args: &[Expr]) -> Result<(), String> {
self.compile_arg_pairs_for(b, "", args)
}
fn byref_slots_for(&self, callee: &str, nargs: usize) -> ByRefSlots {
match self.byref_user_slots(callee, nargs) {
Some(slots) => slots,
None => (
callee.to_string(),
byref_diag_slots(callee, nargs)
.into_iter()
.map(|(p, argno, param)| (p, argno, param.to_string()))
.collect(),
),
}
}
fn compile_arg_pairs_for(
&mut self,
b: &mut ChunkBuilder,
callee: &str,
args: &[Expr],
) -> Result<(), String> {
let (shown, diag) = self.byref_slots_for(callee, args.len().max(BYREF_MAX_ARGNO));
let known = self
.byref_user_fns
.get(&callee.to_ascii_lowercase())
.map(|f| {
(
f.params
.iter()
.cloned()
.collect::<std::collections::HashSet<_>>(),
f.variadic,
)
});
let mut blocked = false;
for (i, a) in args.iter().enumerate() {
let slot = match a {
Expr::NamedArg(n, v) => {
let idx = b.add_constant(Value::str(n.clone()));
b.emit(Op::LoadConst(idx), 0);
self.compile_expr(b, v)?;
let found = diag
.iter()
.find(|(_, _, param)| param == n)
.cloned()
.or_else(|| {
known.as_ref().and_then(|_| {
diag.iter()
.find(|(p, _, param)| *p == i && param.is_empty())
.map(|(p, _, param)| (*p, 1, param.clone()))
})
});
if let Some((names, variadic)) = &known {
if !variadic && !names.contains(n) {
blocked = true;
}
}
found
}
Expr::Spread(inner) => {
b.emit(Op::LoadTrue, 0);
self.compile_expr(b, inner)?;
None
}
_ => {
b.emit(Op::LoadUndef, 0);
self.compile_expr(b, a)?;
diag.iter().find(|(p, ..)| *p == i).cloned()
}
};
if let Some((_, argno, param)) = slot.filter(|_| !blocked) {
let inner = match a {
Expr::NamedArg(_, v) => v,
_ => a,
};
self.emit_byref_arg_diag(b, &shown, argno, ¶m, byref_arg_class(inner));
}
}
Ok(())
}
fn in_other_frame<T>(
&mut self,
f: impl FnOnce(&mut Self) -> Result<T, String>,
) -> Result<T, String> {
let saved = self.enter_scope(Vec::new());
let r = f(self);
self.leave_scope(saved);
r
}
fn promotable_locals(
&self,
params: &[Param],
body: &[Stmt],
is_generator: bool,
) -> crate::promote::Promoted {
crate::promote::promotable(params, body, is_generator, &|name, idx| {
let written_back = self
.byref_positions(name, idx + 1)
.is_some_and(|(p, _)| p.contains(&idx));
let mutated = byref_diag_slots(name, idx + 1)
.iter()
.any(|&(pos, ..)| pos == idx);
let arrmut = array_mutator_subop(name).is_some() && idx == 0;
written_back || mutated || arrmut
})
}
fn enter_scope(&mut self, names: Vec<String>) -> SavedScope {
self.enter_scope_promoting(
names,
crate::promote::Promoted {
names: Vec::new(),
numeric: FxHashSet::default(),
},
)
}
fn enter_scope_promoting(
&mut self,
names: Vec<String>,
promoted: crate::promote::Promoted,
) -> SavedScope {
let names: Vec<String> = names
.into_iter()
.filter(|n| !promoted.names.iter().any(|p| p == n))
.collect();
let map = names
.iter()
.enumerate()
.map(|(i, n)| (n.clone(), i as u32))
.collect();
(
std::mem::replace(&mut self.slots, map),
std::mem::replace(&mut self.slot_order, names),
std::mem::replace(&mut self.fslots, crate::promote::slot_map(&promoted.names)),
std::mem::replace(&mut self.fnumeric, promoted.numeric),
)
}
fn leave_scope(&mut self, saved: SavedScope) -> Vec<String> {
self.slots = saved.0;
self.fslots = saved.2;
self.fnumeric = saved.3;
std::mem::replace(&mut self.slot_order, saved.1)
}
fn emit_get_var(&mut self, b: &mut ChunkBuilder, name: &str) {
if let Some(&i) = self.fslots.get(name) {
b.emit(Op::GetSlot(i), self.cur_line);
return;
}
if let Some(&i) = self.slots.get(name) {
b.emit(Op::LoadInt(i as i64), 0);
b.emit(Op::CallBuiltin(ops::GETSLOT, 1), self.cur_line);
return;
}
let idx = b.add_constant(Value::str(name.to_string()));
b.emit(Op::LoadConst(idx), 0);
b.emit(Op::CallBuiltin(ops::GETVAR, 1), self.cur_line);
}
fn emit_var_target(&mut self, b: &mut ChunkBuilder, name: &str) {
if self.fslots.contains_key(name) {
return;
}
match self.slots.get(name) {
Some(&i) => b.emit(Op::LoadInt(i as i64), 0),
None => {
let idx = b.add_constant(Value::str(name.to_string()));
b.emit(Op::LoadConst(idx), 0)
}
};
}
fn emit_store_var(&mut self, b: &mut ChunkBuilder, name: &str) {
if let Some(&i) = self.fslots.get(name) {
b.emit(Op::Dup, 0);
b.emit(Op::SetSlot(i), self.cur_line);
return;
}
let op = match self.slots.contains_key(name) {
true => ops::SETSLOT,
false => ops::SETVAR,
};
b.emit(Op::CallBuiltin(op, 2), 0);
}
fn emit_set_var(
&mut self,
b: &mut ChunkBuilder,
name: &str,
f: impl FnOnce(&mut Self, &mut ChunkBuilder) -> Result<(), String>,
) -> Result<(), String> {
self.emit_var_target(b, name);
f(self, b)?;
self.emit_store_var(b, name);
b.emit(Op::Pop, 0);
Ok(())
}
}
fn has_named(args: &[Expr]) -> bool {
args.iter().any(|a| matches!(a, Expr::NamedArg(..)))
}
fn needs_arg_pairs(args: &[Expr]) -> bool {
args.iter()
.any(|a| matches!(a, Expr::NamedArg(..) | Expr::Spread(_)))
}
pub(crate) fn collect_free_vars(e: &Expr, out: &mut Vec<String>) {
fn push(name: &str, out: &mut Vec<String>) {
if !out.iter().any(|n| n == name) {
out.push(name.to_string());
}
}
match e {
Expr::Var(n) => push(n, out),
Expr::VarVar(inner) => collect_free_vars(inner, out),
Expr::Interp(parts) => {
for p in parts {
match p {
InterpPart::Expr(e) => collect_free_vars(e, out),
InterpPart::Lit(_) => {}
}
}
}
Expr::Array(elems) => {
for e in elems {
if let Some(k) = &e.key {
collect_free_vars(k, out);
}
collect_free_vars(&e.value, out);
}
}
Expr::Index(a, b)
| Expr::ListElem(a, b)
| Expr::Binary(_, a, b)
| Expr::Elvis(a, b)
| Expr::Coalesce(a, b) => {
collect_free_vars(a, out);
collect_free_vars(b, out);
}
Expr::Append(a)
| Expr::Unary(_, a)
| Expr::Spread(a)
| Expr::Quiet(a)
| Expr::Suppress(a)
| Expr::IssetOf(a)
| Expr::EmptyOf(a) => collect_free_vars(a, out),
Expr::Assign(a, _, b) => {
collect_free_vars(a, out);
collect_free_vars(b, out);
}
Expr::IncDec { target, .. } => collect_free_vars(target, out),
Expr::Call(_, args) => {
for a in args {
collect_free_vars(a, out);
}
}
Expr::CallValue(callee, args) => {
collect_free_vars(callee, out);
for a in args {
collect_free_vars(a, out);
}
}
Expr::Ternary(a, b, c) => {
collect_free_vars(a, out);
collect_free_vars(b, out);
collect_free_vars(c, out);
}
Expr::Fcc { callable, .. } => collect_free_vars(callable, out),
Expr::Match { subj, arms } => {
collect_free_vars(subj, out);
for arm in arms {
if let Some(conds) = &arm.conds {
for c in conds {
collect_free_vars(c, out);
}
}
collect_free_vars(&arm.body, out);
}
}
Expr::ArrowFn { params, body, .. } => {
let mut inner = Vec::new();
collect_free_vars(body, &mut inner);
for n in inner {
if !params.iter().any(|p| p.name == n) {
push(&n, out);
}
}
}
Expr::Closure { uses, .. } => {
for u in uses {
push(&u.name, out);
}
}
Expr::New(_, args) | Expr::NewAnon { args, .. } => {
for a in args {
collect_free_vars(a, out);
}
}
Expr::StaticCall(class, _, args) => {
if let ClassRef::Expr(c) = class {
collect_free_vars(c, out);
}
for a in args {
collect_free_vars(a, out);
}
}
Expr::PropGet(recv, m) | Expr::NullsafePropGet(recv, m) => {
collect_free_vars(recv, out);
if let Some(d) = m.operand() {
collect_free_vars(d, out);
}
}
Expr::MethodCall(recv, m, args) | Expr::NullsafeMethodCall(recv, m, args) => {
collect_free_vars(recv, out);
if let Some(d) = m.operand() {
collect_free_vars(d, out);
}
for a in args {
collect_free_vars(a, out);
}
}
Expr::NamedArg(_, v) => collect_free_vars(v, out),
Expr::StaticGet(class, _) | Expr::StaticProp(class, _) => {
if let ClassRef::Expr(c) = class {
collect_free_vars(c, out);
}
}
Expr::Throw(inner) | Expr::Clone(inner) => collect_free_vars(inner, out),
Expr::ConstFetch(_) | Expr::Magic(_) => {}
Expr::Unset(targets) => {
for t in targets {
collect_free_vars(t, out);
}
}
Expr::InstanceOf(e, _) => collect_free_vars(e, out),
Expr::RefAssign(a, b) => {
collect_free_vars(a, out);
collect_free_vars(b, out);
}
Expr::Yield { key, value } => {
if let Some(k) = key {
collect_free_vars(k, out);
}
if let Some(v) = value {
collect_free_vars(v, out);
}
}
Expr::YieldFrom(src) => collect_free_vars(src, out),
Expr::Print(a) => collect_free_vars(a, out),
Expr::Include(_, a) | Expr::Eval(a) => collect_free_vars(a, out),
Expr::Null | Expr::Bool(_) | Expr::Int(_) | Expr::Float(_) | Expr::Str(_) => {}
}
}
fn body_has_yield(body: &[Stmt]) -> bool {
body.iter().any(stmt_has_yield)
}
fn stmt_has_yield(s: &Stmt) -> bool {
match &s.kind {
StmtKind::Expr(e) | StmtKind::Return(Some(e)) => expr_has_yield(e),
StmtKind::Echo(es) => es.iter().any(expr_has_yield),
StmtKind::If {
cond,
then,
elifs,
els,
} => {
expr_has_yield(cond)
|| body_has_yield(then)
|| elifs
.iter()
.any(|(c, b)| expr_has_yield(c) || body_has_yield(b))
|| els.as_ref().is_some_and(|b| body_has_yield(b))
}
StmtKind::While { cond, body } | StmtKind::DoWhile { cond, body } => {
expr_has_yield(cond) || body_has_yield(body)
}
StmtKind::For {
init,
cond,
step,
body,
} => {
init.iter().any(expr_has_yield)
|| cond.as_ref().is_some_and(expr_has_yield)
|| step.iter().any(expr_has_yield)
|| body_has_yield(body)
}
StmtKind::Foreach { arr, body, .. } => expr_has_yield(arr) || body_has_yield(body),
StmtKind::Switch { subj, cases } => {
expr_has_yield(subj)
|| cases
.iter()
.any(|c| c.test.as_ref().is_some_and(expr_has_yield) || body_has_yield(&c.body))
}
StmtKind::Try {
body,
catches,
finally,
} => {
body_has_yield(body)
|| catches.iter().any(|c| body_has_yield(&c.body))
|| finally.as_ref().is_some_and(|b| body_has_yield(b))
}
StmtKind::Block(b) => body_has_yield(b),
_ => false,
}
}
fn expr_has_yield(e: &Expr) -> bool {
match e {
Expr::Yield { .. } | Expr::YieldFrom(_) => true,
Expr::Unary(_, a)
| Expr::Spread(a)
| Expr::Index(a, _)
| Expr::Append(a)
| Expr::Throw(a)
| Expr::Clone(a)
| Expr::Print(a)
| Expr::Include(_, a)
| Expr::Eval(a)
| Expr::InstanceOf(a, _)
| Expr::NamedArg(_, a) => expr_has_yield(a),
Expr::Binary(_, a, b)
| Expr::Elvis(a, b)
| Expr::Coalesce(a, b)
| Expr::RefAssign(a, b) => expr_has_yield(a) || expr_has_yield(b),
Expr::Assign(a, _, b) => expr_has_yield(a) || expr_has_yield(b),
Expr::Ternary(a, c, d) => expr_has_yield(a) || expr_has_yield(c) || expr_has_yield(d),
Expr::IncDec { target, .. } => expr_has_yield(target),
Expr::Call(_, args) | Expr::New(_, args) | Expr::NewAnon { args, .. } => {
args.iter().any(expr_has_yield)
}
Expr::StaticCall(class, _, args) => {
class.operand().is_some_and(expr_has_yield) || args.iter().any(expr_has_yield)
}
Expr::StaticGet(class, _) | Expr::StaticProp(class, _) => {
class.operand().is_some_and(expr_has_yield)
}
Expr::CallValue(c, args) => expr_has_yield(c) || args.iter().any(expr_has_yield),
Expr::PropGet(r, m) | Expr::NullsafePropGet(r, m) => {
expr_has_yield(r) || m.operand().is_some_and(expr_has_yield)
}
Expr::MethodCall(r, m, args) | Expr::NullsafeMethodCall(r, m, args) => {
expr_has_yield(r)
|| m.operand().is_some_and(expr_has_yield)
|| args.iter().any(expr_has_yield)
}
Expr::Array(items) => items
.iter()
.any(|e| e.key.as_ref().is_some_and(expr_has_yield) || expr_has_yield(&e.value)),
Expr::Interp(parts) => parts.iter().any(|p| match p {
InterpPart::Expr(e) => expr_has_yield(e),
InterpPart::Lit(_) => false,
}),
Expr::Match { subj, arms } => {
expr_has_yield(subj)
|| arms.iter().any(|a| {
a.conds
.as_ref()
.is_some_and(|cs| cs.iter().any(expr_has_yield))
|| expr_has_yield(&a.body)
})
}
Expr::Unset(targets) => targets.iter().any(expr_has_yield),
_ => false,
}
}
fn break_level_error(kw: &str, level: u32, depth: usize) -> String {
if depth == 0 {
format!("'{kw}' outside of a loop")
} else {
format!("Cannot '{kw}' {level} levels")
}
}
fn is_const_operand(e: &Expr) -> bool {
match e {
Expr::Null | Expr::Bool(_) | Expr::Int(_) | Expr::Float(_) | Expr::Str(_) => true,
Expr::Interp(parts) => parts.iter().all(|p| matches!(p, InterpPart::Lit(_))),
Expr::Unary(UnOp::Neg | UnOp::Pos, x) => is_const_operand(x),
Expr::Binary(op, a, b) if is_foldable_arith(*op) => folds_without_diagnostic(*op, a, b),
_ => false,
}
}
fn is_definitely_runtime(e: &Expr) -> bool {
match e {
Expr::Var(_)
| Expr::Index(..)
| Expr::Append(_)
| Expr::Assign(..)
| Expr::IncDec { .. }
| Expr::RefAssign(..) => true,
Expr::Binary(op, a, b) if is_foldable_arith(*op) => {
is_const_operand(a) && is_const_operand(b) && !folds_without_diagnostic(*op, a, b)
}
_ => false,
}
}
fn is_foldable_arith(op: BinOp) -> bool {
matches!(
op,
BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Mod | BinOp::Pow
)
}
fn folds_without_diagnostic(op: BinOp, a: &Expr, b: &Expr) -> bool {
if !is_silently_numeric(a) || !is_silently_numeric(b) {
return false;
}
if matches!(op, BinOp::Div | BinOp::Mod) && is_literal_zero(b) {
return false;
}
true
}
fn is_silently_numeric(e: &Expr) -> bool {
match e {
Expr::Null | Expr::Bool(_) | Expr::Int(_) | Expr::Float(_) => true,
Expr::Str(s) => is_fully_numeric(s),
Expr::Interp(parts) => match parts.as_slice() {
[] => is_fully_numeric(""),
[InterpPart::Lit(s)] => is_fully_numeric(s),
_ => false,
},
Expr::Unary(UnOp::Neg | UnOp::Pos, x) => is_silently_numeric(x),
Expr::Binary(op, a, b) if is_foldable_arith(*op) => folds_without_diagnostic(*op, a, b),
_ => false,
}
}
fn is_literal(e: &Expr) -> bool {
matches!(
e,
Expr::Null
| Expr::Bool(_)
| Expr::Int(_)
| Expr::Float(_)
| Expr::Str(_)
| Expr::Interp(_)
| Expr::Array(_)
)
}
fn is_literal_zero(e: &Expr) -> bool {
match e {
Expr::Int(0) => true,
Expr::Float(f) => *f == 0.0,
Expr::Str(s) => {
is_fully_numeric(s) && s.trim().parse::<f64>().map(|v| v == 0.0) == Ok(true)
}
_ => false,
}
}
fn is_fully_numeric(s: &str) -> bool {
let t = s.trim();
if t.is_empty() {
return false;
}
let bytes = t.as_bytes();
let mut i = 0;
if matches!(bytes[i], b'+' | b'-') {
i += 1;
}
let digits_before = {
let start = i;
while i < bytes.len() && bytes[i].is_ascii_digit() {
i += 1;
}
i - start
};
let mut digits_after = 0;
if i < bytes.len() && bytes[i] == b'.' {
i += 1;
let start = i;
while i < bytes.len() && bytes[i].is_ascii_digit() {
i += 1;
}
digits_after = i - start;
}
if digits_before + digits_after == 0 {
return false;
}
if i < bytes.len() && matches!(bytes[i], b'e' | b'E') {
i += 1;
if i < bytes.len() && matches!(bytes[i], b'+' | b'-') {
i += 1;
}
let start = i;
while i < bytes.len() && bytes[i].is_ascii_digit() {
i += 1;
}
if i == start {
return false;
}
}
i == bytes.len()
}
fn never_array(e: &Expr) -> bool {
match e {
Expr::Int(_) | Expr::Float(_) | Expr::Str(_) | Expr::Bool(_) | Expr::Null => true,
Expr::Interp(_) => true,
Expr::Binary(op, l, r) => match op {
BinOp::Add => never_array(l) || never_array(r),
BinOp::Sub
| BinOp::Mul
| BinOp::Div
| BinOp::Mod
| BinOp::Pow
| BinOp::Concat
| BinOp::BitAnd
| BinOp::BitOr
| BinOp::BitXor
| BinOp::Shl
| BinOp::Shr
| BinOp::Lt
| BinOp::Gt
| BinOp::Le
| BinOp::Ge
| BinOp::LooseEq
| BinOp::LooseNe
| BinOp::StrictEq
| BinOp::StrictNe
| BinOp::Spaceship => true,
_ => false,
},
Expr::IncDec { .. } | Expr::InstanceOf(..) | Expr::IssetOf(_) | Expr::EmptyOf(_) => true,
Expr::Unary(op, x) => match op {
UnOp::Not => true,
UnOp::Neg | UnOp::Pos | UnOp::BitNot => never_array(x),
},
_ => false,
}
}
fn slottable_name(name: &str) -> bool {
!crate::host::is_superglobal(name) && name != "this" && !name.starts_with('@')
}
fn scope_slots(params: &[Param], body: &[Stmt]) -> Vec<String> {
let mut c = SlotScan {
out: Vec::new(),
seen: FxHashSet::default(),
};
for p in params {
c.push(&p.name);
}
c.stmts(body);
c.out
}
struct SlotScan {
out: Vec<String>,
seen: FxHashSet<String>,
}
impl SlotScan {
fn push(&mut self, n: &str) {
if slottable_name(n) && self.seen.insert(n.to_string()) {
self.out.push(n.to_string());
}
}
fn stmts(&mut self, body: &[Stmt]) {
for s in body {
self.stmt(s);
}
}
fn stmt(&mut self, s: &Stmt) {
match &s.kind {
StmtKind::Echo(es) => self.exprs(es),
StmtKind::Expr(e) => self.expr(e),
StmtKind::Return(Some(e)) => self.expr(e),
StmtKind::If {
cond,
then,
elifs,
els,
} => {
self.expr(cond);
self.stmts(then);
for (c, b) in elifs {
self.expr(c);
self.stmts(b);
}
if let Some(b) = els {
self.stmts(b);
}
}
StmtKind::While { cond, body } | StmtKind::DoWhile { cond, body } => {
self.expr(cond);
self.stmts(body);
}
StmtKind::For {
init,
cond,
step,
body,
} => {
self.exprs(init);
if let Some(c) = cond {
self.expr(c);
}
self.exprs(step);
self.stmts(body);
}
StmtKind::Foreach {
arr,
key_var,
val,
body,
..
} => {
self.expr(arr);
if let Some(k) = key_var {
self.push(k);
}
match val {
ForeachVal::Var(n) => self.push(n),
ForeachVal::Pattern(e) => self.expr(e),
}
self.stmts(body);
}
StmtKind::Switch { subj, cases } => {
self.expr(subj);
for c in cases {
if let Some(e) = &c.test {
self.expr(e);
}
self.stmts(&c.body);
}
}
StmtKind::Try {
body,
catches,
finally,
} => {
self.stmts(body);
for c in catches {
if let Some(v) = &c.var {
self.push(v);
}
self.stmts(&c.body);
}
if let Some(f) = finally {
self.stmts(f);
}
}
StmtKind::Block(b) => self.stmts(b),
StmtKind::Global(names) => {
for n in names {
self.push(n);
}
}
StmtKind::StaticLocal(decls) => {
for (n, init) in decls {
self.push(n);
if let Some(e) = init {
self.expr(e);
}
}
}
StmtKind::ConstDecl(ds) => {
for (_, e) in ds {
self.expr(e);
}
}
StmtKind::Function { .. }
| StmtKind::Class(_)
| StmtKind::InlineHtml(_)
| StmtKind::Return(None)
| StmtKind::Break(_)
| StmtKind::Continue(_) => {}
}
}
fn exprs(&mut self, es: &[Expr]) {
for e in es {
self.expr(e);
}
}
fn expr(&mut self, e: &Expr) {
match e {
Expr::Var(n) => self.push(n),
Expr::Interp(parts) => {
for p in parts {
if let InterpPart::Expr(e) = p {
self.expr(e);
}
}
}
Expr::Array(elems) => {
for el in elems {
if let Some(k) = &el.key {
self.expr(k);
}
self.expr(&el.value);
}
}
Expr::Index(a, b) | Expr::ListElem(a, b) | Expr::Binary(_, a, b) => {
self.expr(a);
self.expr(b);
}
Expr::Append(a)
| Expr::Unary(_, a)
| Expr::Spread(a)
| Expr::Clone(a)
| Expr::Throw(a)
| Expr::Quiet(a)
| Expr::Print(a)
| Expr::Include(_, a)
| Expr::Eval(a)
| Expr::NamedArg(_, a)
| Expr::InstanceOf(a, _) => self.expr(a),
Expr::PropGet(a, m) | Expr::NullsafePropGet(a, m) => {
self.expr(a);
if let Some(d) = m.operand() {
self.expr(d);
}
}
Expr::Assign(a, _, b) | Expr::RefAssign(a, b) | Expr::Elvis(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::Coalesce(a, b) => {
self.expr(a);
self.expr(b);
}
Expr::IncDec { target, .. } => self.expr(target),
Expr::Call(_, args) | Expr::New(_, args) | Expr::NewAnon { args, .. } => {
self.exprs(args)
}
Expr::CallValue(f, args) => {
self.expr(f);
self.exprs(args);
}
Expr::MethodCall(r, m, args) | Expr::NullsafeMethodCall(r, m, args) => {
self.expr(r);
if let Some(d) = m.operand() {
self.expr(d);
}
self.exprs(args);
}
Expr::StaticCall(_, _, args) => self.exprs(args),
Expr::Ternary(a, b, c) => {
self.expr(a);
self.expr(b);
self.expr(c);
}
Expr::Match { subj, arms } => {
self.expr(subj);
for a in arms {
if let Some(cs) = &a.conds {
self.exprs(cs);
}
self.expr(&a.body);
}
}
Expr::Unset(es) => self.exprs(es),
Expr::Closure { uses, .. } => {
for u in uses {
self.push(&u.name);
}
}
_ => {}
}
}
}
fn yields_bool(e: &Expr) -> bool {
match e {
Expr::Bool(_) => true,
Expr::InstanceOf(..) => true,
Expr::Unary(UnOp::Not, _) => true,
Expr::Binary(op, ..) => matches!(
op,
BinOp::Lt
| BinOp::Gt
| BinOp::Le
| BinOp::Ge
| BinOp::LooseEq
| BinOp::LooseNe
| BinOp::StrictEq
| BinOp::StrictNe
),
_ => false,
}
}