use crate::ast::*;
use crate::deparse::{deparse_expr, deparse_lines};
use crate::host::{ops, ClosureDef};
use fusevm::{Chunk, ChunkBuilder, Op, Value};
pub struct Program {
pub main: Chunk,
pub closures: Vec<ClosureDef>,
}
struct LoopCtx {
continues: Vec<usize>,
breaks: Vec<usize>,
}
#[derive(Default)]
struct Compiler {
closures: Vec<ClosureDef>,
loops: Vec<LoopCtx>,
tmp: usize,
locals: std::collections::HashSet<String>,
native_nums: std::collections::HashSet<String>,
assign_text: String,
tail: bool,
lazy_loop: bool,
op_sites: Vec<(usize, String)>,
}
const DYNAMIC_ENV_FNS: &[&str] = &[
"get",
"get0",
"mget",
"match.fun",
"getS3method",
"subset",
"assign",
"exists",
"environment",
"environmentName",
"eval",
"evalq",
"local",
"with",
"within",
"do.call",
"Recall",
"sys.call",
"sys.function",
"sys.frame",
"match.call",
"match.arg",
"parent.frame",
"parent.env",
"ls",
"rm",
"remove",
"attach",
"detach",
"substitute",
"quote",
"bquote",
"missing",
"on.exit",
"delayedAssign",
"makeActiveBinding",
"new.env",
"globalenv",
"as.environment",
"list2env",
"eapply",
"Reduce",
"Filter",
"Map",
"do.call",
"apply",
"sapply",
"lapply",
"vapply",
"mapply",
"tapply",
"outer",
];
const R_PRIMITIVES: &[&str] = &[
"-",
":",
"::",
":::",
"!",
"!=",
"...elt",
"...length",
"...names",
".C",
".cache_class",
".Call",
".Call.graphics",
".class2",
".External",
".External.graphics",
".External2",
".Fortran",
".Internal",
".isMethodsDispatchOn",
".Primitive",
".primTrace",
".primUntrace",
".subset",
".subset2",
"(",
"[",
"[[",
"[[<-",
"[<-",
"{",
"@",
"@<-",
"*",
"/",
"&",
"&&",
"%*%",
"%/%",
"%%",
"^",
"+",
"<",
"<-",
"<<-",
"<=",
"=",
"==",
">",
">=",
"|",
"||",
"~",
"$",
"$<-",
"abs",
"acos",
"acosh",
"all",
"any",
"anyNA",
"Arg",
"as.call",
"as.character",
"as.complex",
"as.double",
"as.environment",
"as.integer",
"as.logical",
"as.numeric",
"as.raw",
"asin",
"asinh",
"atan",
"atanh",
"attr",
"attr<-",
"attributes",
"attributes<-",
"baseenv",
"break",
"browser",
"c",
"call",
"ceiling",
"class",
"class<-",
"Conj",
"cos",
"cosh",
"cospi",
"crossprod",
"cummax",
"cummin",
"cumprod",
"cumsum",
"declare",
"digamma",
"dim",
"dim<-",
"dimnames",
"dimnames<-",
"emptyenv",
"enc2native",
"enc2utf8",
"environment<-",
"Exec",
"exp",
"expm1",
"expression",
"floor",
"for",
"forceAndCall",
"function",
"gamma",
"gc.time",
"globalenv",
"if",
"Im",
"interactive",
"invisible",
"is.array",
"is.atomic",
"is.call",
"is.character",
"is.complex",
"is.double",
"is.environment",
"is.expression",
"is.finite",
"is.function",
"is.infinite",
"is.integer",
"is.language",
"is.list",
"is.logical",
"is.matrix",
"is.na",
"is.name",
"is.nan",
"is.null",
"is.numeric",
"is.object",
"is.pairlist",
"is.raw",
"is.recursive",
"is.single",
"is.symbol",
"isS4",
"lazyLoadDBfetch",
"length",
"length<-",
"levels<-",
"lgamma",
"list",
"log",
"log10",
"log1p",
"log2",
"max",
"min",
"missing",
"Mod",
"names",
"names<-",
"nargs",
"next",
"nzchar",
"oldClass",
"oldClass<-",
"on.exit",
"pos.to.env",
"proc.time",
"prod",
"quote",
"range",
"Re",
"rep",
"repeat",
"retracemem",
"return",
"round",
"seq_along",
"seq_len",
"seq.int",
"sign",
"signif",
"sin",
"sinh",
"sinpi",
"sqrt",
"standardGeneric",
"storage.mode<-",
"substitute",
"sum",
"switch",
"Tailcall",
"tan",
"tanh",
"tanpi",
"tcrossprod",
"tracemem",
"trigamma",
"trunc",
"unCfillPOSIXlt",
"unclass",
"untracemem",
"UseMethod",
"while",
"xtfrm",
];
pub(crate) fn is_r_primitive(name: &str) -> bool {
R_PRIMITIVES.contains(&name)
}
fn makes_context(name: &str) -> bool {
!is_r_primitive(name) && !name.starts_with(".rlang_")
}
fn slot_locals(exprs: &[Expr]) -> std::collections::HashSet<String> {
let mut targets = std::collections::HashSet::new();
let mut blocked = std::collections::HashSet::new();
let mut safe = true;
for e in exprs {
scan_slots(e, &mut safe, &mut targets, &mut blocked);
}
if !safe {
return std::collections::HashSet::new();
}
targets.retain(|n| !blocked.contains(n));
targets
}
fn root_ident(e: &Expr) -> Option<&str> {
match e {
Expr::Ident(n) | Expr::Str(n) => Some(n),
Expr::Paren(x) => root_ident(x),
Expr::Index { obj, .. } => root_ident(obj),
Expr::Call { args, .. } => args
.first()
.and_then(|a| a.value.as_ref())
.and_then(root_ident),
_ => None,
}
}
fn scan_slots(
e: &Expr,
safe: &mut bool,
targets: &mut std::collections::HashSet<String>,
blocked: &mut std::collections::HashSet<String>,
) {
if !*safe {
return;
}
let mut go = |x: &Expr, s: &mut bool| scan_slots(x, s, targets, blocked);
match e {
Expr::Function { .. } | Expr::Formula { .. } => *safe = false,
Expr::Assign {
target,
value,
super_assign,
} => {
if *super_assign {
*safe = false;
return;
}
match target.as_ref() {
Expr::Ident(n) | Expr::Str(n) => {
targets.insert(n.clone());
}
other => {
if let Some(r) = root_ident(other) {
blocked.insert(r.to_string());
}
scan_slots(other, safe, targets, blocked);
}
}
scan_slots(value, safe, targets, blocked);
}
Expr::For { var, seq, body } => {
targets.insert(var.clone());
scan_slots(seq, safe, targets, blocked);
scan_slots(body, safe, targets, blocked);
}
Expr::Call { fun, args } => {
if let Expr::Ident(name) = fun.as_ref() {
if DYNAMIC_ENV_FNS.contains(&name.as_str()) || thunk_lazy_args(name, args).is_some()
{
*safe = false;
return;
}
blocked.insert(name.clone());
}
scan_slots(fun, safe, targets, blocked);
for a in args {
if let Some(v) = &a.value {
scan_slots(v, safe, targets, blocked);
}
}
}
Expr::If { cond, then, els } => {
go(cond, safe);
go(then, safe);
if let Some(x) = els {
go(x, safe);
}
}
Expr::While { cond, body } => {
go(cond, safe);
go(body, safe);
}
Expr::Repeat(b) => go(b, safe),
Expr::Paren(x) => scan_slots(x, safe, targets, blocked),
Expr::Block(xs) => {
for x in xs {
scan_slots(x, safe, targets, blocked);
}
}
Expr::Binary { lhs, rhs, .. } | Expr::Special { lhs, rhs, .. } => {
go(lhs, safe);
go(rhs, safe);
}
Expr::Unary { operand, .. } => go(operand, safe),
Expr::Index { obj, args, .. } => {
go(obj, safe);
for a in args {
if let Some(v) = &a.value {
scan_slots(v, safe, targets, blocked);
}
}
}
_ => {}
}
}
pub fn compile(exprs: &[Expr]) -> Result<Program, String> {
compile_inner(exprs, true)
}
pub fn compile_no_slots(exprs: &[Expr]) -> Result<Program, String> {
compile_inner(exprs, false)
}
fn compile_inner(exprs: &[Expr], use_slots: bool) -> Result<Program, String> {
let mut c = Compiler::default();
if use_slots {
c.locals = slot_locals(exprs);
c.native_nums = native_num_slots(exprs);
}
let mut b = ChunkBuilder::new();
if exprs.is_empty() {
b.emit(Op::CallBuiltin(ops::CONST_NULL, 0), 0);
}
for (i, e) in exprs.iter().enumerate() {
let slot_assign = matches!(e, Expr::Assign { target, super_assign: false, .. }
if matches!(target.as_ref(), Expr::Ident(n) | Expr::Str(n) if c.locals.contains(n)));
if slot_assign {
c.stmt(&mut b, e)?;
} else {
c.tail = true;
c.expr(&mut b, e)?;
b.emit(Op::CallBuiltin(ops::AUTOPRINT, 1), 0);
}
b.emit(Op::CallBuiltin(ops::WARN_FLUSH, 0), 0);
b.emit(Op::Pop, 0);
if !slot_assign && i + 1 < exprs.len() {
b.emit(Op::Pop, 0);
}
}
c.finish_chunk(&mut b, Vec::new());
Ok(Program {
main: b.build(),
closures: c.closures,
})
}
pub fn shift_closure_ids(prog: Program, base: usize) -> Program {
if base == 0 {
return prog;
}
let shift = |chunk: &mut Chunk| {
for i in 0..chunk.ops.len() {
let is_mkclosure = matches!(
chunk.ops.get(i + 1),
Some(Op::CallBuiltin(id, 1)) if *id == ops::MKCLOSURE
);
if !is_mkclosure {
continue;
}
if let Some(Op::LoadInt(n)) = chunk.ops.get_mut(i) {
*n += base as i64;
}
}
rehash(chunk);
};
let mut main = prog.main;
shift(&mut main);
let closures = prog
.closures
.into_iter()
.map(|mut c| {
shift(&mut c.chunk);
c
})
.collect();
Program { main, closures }
}
fn rehash(chunk: &mut Chunk) {
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
let mut h = DefaultHasher::new();
chunk.ops.hash(&mut h);
chunk.constants.hash(&mut h);
chunk.op_hash = h.finish();
}
impl Compiler {
fn kstr(&mut self, b: &mut ChunkBuilder, s: &str) {
let idx = b.add_constant(Value::str(s));
b.emit(Op::LoadConst(idx), 0);
}
fn finish_chunk(&mut self, b: &mut ChunkBuilder, outer: Vec<(usize, String)>) {
let sites = std::mem::replace(&mut self.op_sites, outer);
if !sites.is_empty() {
let _ = b.try_add_constant(crate::host::op_sites_constant(sites));
}
}
fn tmp_name(&mut self, b: &mut ChunkBuilder, tag: &str) -> u16 {
self.tmp += 1;
b.add_name(&format!("__{tag}{}", self.tmp))
}
fn seq(&mut self, b: &mut ChunkBuilder, body: &[Expr]) -> Result<(), String> {
let tail = std::mem::take(&mut self.tail);
if body.is_empty() {
b.emit(Op::CallBuiltin(ops::CONST_NULL, 0), 0);
return Ok(());
}
for (i, e) in body.iter().enumerate() {
if i + 1 < body.len() {
self.stmt(b, e)?;
} else {
self.tail = tail;
self.expr(b, e)?;
}
}
Ok(())
}
fn mark_visible(&mut self, b: &mut ChunkBuilder, tail: bool) {
if tail {
b.emit(Op::CallBuiltin(ops::SET_VISIBLE, 1), 0);
}
}
fn stmt(&mut self, b: &mut ChunkBuilder, e: &Expr) -> Result<(), String> {
if let Expr::Assign {
target,
value,
super_assign: false,
} = e
{
if let Expr::Ident(n) | Expr::Str(n) = target.as_ref() {
if self.locals.contains(n) {
self.expr(b, value)?;
let slot = b.add_name(n);
b.emit(Op::SetVar(slot), 0);
return Ok(());
}
}
}
self.expr(b, e)?;
b.emit(Op::Pop, 0);
Ok(())
}
fn expr(&mut self, b: &mut ChunkBuilder, e: &Expr) -> Result<(), String> {
if let Some(msg) = crate::host::stack_exhausted() {
return Err(msg);
}
let tail = std::mem::take(&mut self.tail);
match e {
Expr::Num(n) => {
b.emit(Op::LoadFloat(*n), 0);
self.mark_visible(b, tail);
}
Expr::Int(n) => {
b.emit(Op::LoadInt(*n), 0);
self.mark_visible(b, tail);
}
Expr::Str(s) => {
self.kstr(b, s);
b.emit(Op::CallBuiltin(ops::CONST_STR, 1), 0);
}
Expr::Bool(v) => {
b.emit(if *v { Op::LoadTrue } else { Op::LoadFalse }, 0);
b.emit(Op::CallBuiltin(ops::CONST_LGL, 1), 0);
}
Expr::Null => {
b.emit(Op::CallBuiltin(ops::CONST_NULL, 0), 0);
}
Expr::Na(kind) => {
let tag = match kind {
NaKind::Logical => 0,
NaKind::Integer => 1,
NaKind::Real => 2,
NaKind::Character => 3,
};
b.emit(Op::LoadInt(tag), 0);
b.emit(Op::CallBuiltin(ops::CONST_NA, 1), 0);
}
Expr::Inf => {
b.emit(Op::LoadFloat(f64::INFINITY), 0);
b.emit(Op::CallBuiltin(ops::CONST_DBL, 1), 0);
}
Expr::NaN => {
b.emit(Op::LoadFloat(f64::NAN), 0);
b.emit(Op::CallBuiltin(ops::CONST_DBL, 1), 0);
}
Expr::Ident(name) => {
if self.locals.contains(name) {
let slot = b.add_name(name);
b.emit(Op::GetVar(slot), 0);
} else {
self.kstr(b, name);
b.emit(Op::CallBuiltin(ops::GETVAR, 1), 0);
}
}
Expr::Dots => {
b.emit(Op::CallBuiltin(ops::DOTS, 0), 0);
}
Expr::Function { params, body } => {
let id = self.closure(params, body)?;
b.emit(Op::LoadInt(id as i64), 0);
b.emit(Op::CallBuiltin(ops::MKCLOSURE, 1), 0);
}
Expr::Block(body) => {
self.tail = tail;
self.seq(b, body)?
}
Expr::Paren(inner) => {
self.expr(b, inner)?;
b.emit(Op::CallBuiltin(ops::SET_VISIBLE, 1), 0);
}
Expr::Call { fun, args } => self.call_expr(b, e, fun, args)?,
Expr::Formula { lhs, rhs } => {
let src = match lhs {
Some(l) => format!("{} ~ {}", deparse_expr(l), deparse_expr(rhs)),
None => format!("~ {}", deparse_expr(rhs)),
};
let call = Expr::Call {
fun: Box::new(Expr::Ident(".rlang_formula".into())),
args: vec![Arg {
name: None,
value: Some(Expr::Str(src)),
}],
};
self.expr(b, &call)?;
}
Expr::Binary { op, lhs, rhs } => match op {
BinOp::And2 | BinOp::Or2 => self.short_circuit(b, op, lhs, rhs)?,
_ => {
self.expr(b, lhs)?;
self.expr(b, rhs)?;
let ip = match native_binop(op) {
Some(nop) => b.emit(nop, 0),
None => {
self.kstr(b, binop_name(op));
b.emit(Op::CallBuiltin(ops::BINOP, 3), 0)
}
};
self.op_sites.push((ip, deparse_lines(e)));
}
},
Expr::Special { name, lhs, rhs } => {
self.expr(b, lhs)?;
self.expr(b, rhs)?;
self.kstr(b, name);
self.kstr(b, &deparse_lines(e));
b.emit(Op::CallBuiltin(ops::SPECIAL, 4), 0);
}
Expr::Unary { op, operand } => {
self.expr(b, operand)?;
self.kstr(
b,
match op {
UnOp::Neg => "-",
UnOp::Plus => "+",
UnOp::Not => "!",
},
);
b.emit(Op::CallBuiltin(ops::UNOP, 2), 0);
}
Expr::Index { kind, obj, args } => {
self.expr(b, obj)?;
let ip = match kind {
IndexKind::Dollar | IndexKind::At => {
match args.first().and_then(|a| a.value.clone()) {
Some(Expr::Str(n)) => self.kstr(b, &n),
_ => return Err("malformed $ access".into()),
}
b.emit(Op::CallBuiltin(ops::DOLLAR, 2), 0)
}
IndexKind::Single => {
self.args(b, args)?;
b.emit(Op::CallBuiltin(ops::INDEX, 2), 0)
}
IndexKind::Double => {
self.args(b, args)?;
b.emit(Op::CallBuiltin(ops::INDEX2, 2), 0)
}
};
self.op_sites.push((ip, deparse_lines(e)));
}
Expr::If { cond, then, els } => {
self.expr(b, cond)?;
self.kstr(b, &deparse_lines(e));
b.emit(Op::CallBuiltin(ops::TRUTHY, 2), 0);
let jf = b.emit(Op::JumpIfFalse(0), 0);
self.tail = tail;
self.expr(b, then)?;
let jend = b.emit(Op::Jump(0), 0);
let else_at = b.current_pos();
b.patch_jump(jf, else_at);
self.tail = tail;
match els {
Some(e) => self.expr(b, e)?,
None => {
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
}
}
let end = b.current_pos();
b.patch_jump(jend, end);
}
Expr::While { cond, body } => {
self.loops.push(LoopCtx {
continues: Vec::new(),
breaks: Vec::new(),
});
let start = b.current_pos();
self.expr(b, cond)?;
self.kstr(b, &deparse_lines(e));
b.emit(Op::CallBuiltin(ops::TRUTHY, 2), 0);
let jf = b.emit(Op::JumpIfFalse(0), 0);
self.stmt(b, body)?;
b.emit(Op::Jump(start), 0);
let end = b.current_pos();
b.patch_jump(jf, end);
self.close_loop(b, start, end);
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
}
Expr::Repeat(body) => {
self.loops.push(LoopCtx {
continues: Vec::new(),
breaks: Vec::new(),
});
let start = b.current_pos();
self.stmt(b, body)?;
b.emit(Op::Jump(start), 0);
let end = b.current_pos();
self.close_loop(b, start, end);
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
}
Expr::For { var, seq, body } => self.for_loop(b, var, seq, body)?,
Expr::Break => {
if self.loops.is_empty() && !self.lazy_loop {
return self.no_loop_error(b);
}
self.leave_loop(b, true);
b.emit(Op::CallBuiltin(ops::CONST_NULL, 0), 0);
}
Expr::Next => {
if self.loops.is_empty() && !self.lazy_loop {
return self.no_loop_error(b);
}
self.leave_loop(b, false);
b.emit(Op::CallBuiltin(ops::CONST_NULL, 0), 0);
}
Expr::Assign {
target,
value,
super_assign,
} => self.assign(b, target, value, *super_assign)?,
}
Ok(())
}
#[inline(never)]
fn call_expr(
&mut self,
b: &mut ChunkBuilder,
e: &Expr,
fun: &Expr,
args: &[Arg],
) -> Result<(), String> {
if let Expr::Ident(name) = fun {
if name == "switch" && !args.is_empty() {
return self.switch_expr(b, args);
}
if name == "local" && args.len() == 1 {
if let Some(body) = args[0].value.clone() {
return self.expr(b, &call_thunk(body));
}
}
if name == "local" && args.len() == 2 {
let named = |n: &str| args.iter().position(|a| a.name.as_deref() == Some(n));
let expr_at = named("expr").unwrap_or(usize::from(named("envir") == Some(0)));
if let (Some(inner), Some(scope)) =
(args[expr_at].value.clone(), args[1 - expr_at].value.clone())
{
let call = vec![
Arg {
name: None,
value: Some(quote_call(&inner, false)),
},
Arg {
name: None,
value: Some(scope),
},
];
return self.expr(
b,
&Expr::Call {
fun: Box::new(Expr::Ident("eval".into())),
args: call,
},
);
}
}
if matches!(name.as_str(), "with" | "evalq") && args.len() >= 2 {
let (expr_at, scope_at) = if name == "with" { (1, 0) } else { (0, 1) };
if let Some(inner) = args[expr_at].value.clone() {
let mut call = vec![
Arg {
name: None,
value: Some(quote_call(&inner, false)),
},
Arg {
name: None,
value: args[scope_at].value.clone(),
},
];
call.extend(args[2..].iter().cloned());
return self.expr(
b,
&Expr::Call {
fun: Box::new(Expr::Ident("eval".into())),
args: call,
},
);
}
}
if name == "delayedAssign" && args.len() >= 2 {
let tag = |a: &Arg, n: &str| a.name.as_deref() == Some(n);
let mut rest: Vec<Arg> = args.to_vec();
let pick = |rest: &mut Vec<Arg>, n: &str, pos: usize| -> Option<Arg> {
if let Some(i) = rest.iter().position(|a| tag(a, n)) {
return Some(rest.remove(i));
}
let unnamed: Vec<usize> = rest
.iter()
.enumerate()
.filter(|(_, a)| a.name.is_none())
.map(|(i, _)| i)
.collect();
unnamed.get(pos).map(|&i| rest.remove(i))
};
let x = pick(&mut rest, "x", 0);
let value = pick(&mut rest, "value", 0);
let _eval_env = pick(&mut rest, "eval.env", 0);
let assign_env = pick(&mut rest, "assign.env", 0);
if let (Some(x), Some(value)) = (x, value) {
if let Some(v) = value.value {
let mut call = vec![
Arg {
name: None,
value: x.value,
},
Arg {
name: None,
value: Some(Expr::Call {
fun: Box::new(Expr::Ident(".rlang_promise".into())),
args: vec![Arg {
name: None,
value: Some(thunk(v)),
}],
}),
},
];
if let Some(env) = assign_env {
call.push(Arg {
name: Some("envir".into()),
value: env.value,
});
}
self.expr(
b,
&Expr::Call {
fun: Box::new(Expr::Ident("assign".into())),
args: call,
},
)?;
b.emit(Op::Pop, 0);
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
return Ok(());
}
}
}
if matches!(name.as_str(), "quote" | "bquote") && args.len() == 1 {
if let Some(inner) = args[0].value.clone() {
return self.expr(b, "e_call(&inner, name == "bquote"));
}
}
if name == "missing" && args.len() == 1 {
if let Some(Expr::Ident(sym)) = args[0].value.clone() {
let mut call = args.to_vec();
call[0] = Arg {
name: None,
value: Some(Expr::Str(sym)),
};
return self.expr(
b,
&Expr::Call {
fun: Box::new(Expr::Ident("missing".into())),
args: call,
},
);
}
}
if name == "substitute" && !args.is_empty() {
if let Some(inner) = args[0].value.clone() {
let mut call = args.to_vec();
call[0] = Arg {
name: None,
value: Some(Expr::Str(deparse_lines(&inner))),
};
return self.expr(
b,
&Expr::Call {
fun: Box::new(Expr::Ident(".rlang_substitute".into())),
args: call,
},
);
}
}
}
let thunked = match fun {
Expr::Ident(name) => thunk_lazy_args(name, args),
_ => None,
};
let args: &[Arg] = thunked.as_deref().unwrap_or(args);
let nse_names = match fun {
Expr::Ident(n) => match n.as_str() {
"library" | "require" | "requireNamespace" | "loadNamespace" => Some(1),
"rm" | "remove" => Some(usize::MAX),
_ => None,
},
_ => None,
};
let named_args: Option<Vec<Arg>> = nse_names.map(|first_n| {
args.iter()
.enumerate()
.map(|(i, a)| match &a.value {
Some(Expr::Ident(sym)) if i < first_n && (first_n == 1 || a.name.is_none()) => {
Arg {
name: a.name.clone(),
value: Some(Expr::Str(sym.clone())),
}
}
_ => a.clone(),
})
.collect()
});
let args: &[Arg] = named_args.as_deref().unwrap_or(args);
let table_dnn: Option<Vec<String>> = match fun {
Expr::Ident(n)
if n == "table" && !args.iter().any(|a| matches!(a.value, Some(Expr::Dots))) =>
{
Some(
args.iter()
.filter(|a| a.name.is_none())
.map(|a| match &a.value {
Some(Expr::Ident(sym)) => sym.clone(),
_ => String::new(),
})
.collect(),
)
}
_ => None,
};
let bind_labels: Option<Vec<BindLabel>> = match fun {
Expr::Ident(n)
if (n == "rbind" || n == "cbind")
&& !args.is_empty()
&& !args
.iter()
.any(|a| matches!(a.value, Some(Expr::Dots)) || a.value.is_none()) =>
{
Some(
args.iter()
.map(|a| {
let e = a.value.as_ref().expect("checked above");
let sym = match e {
Expr::Ident(s) => Some(s.clone()),
_ => None,
};
(sym, deparse_expr(e))
})
.collect(),
)
}
_ => None,
};
let promised = match fun {
_ if !self.locals.is_empty() => None,
Expr::Ident(name) if !makes_context(name) => None,
Expr::Ident(name) if name.starts_with(".rlang_") => None,
_ => promise_args(args),
};
let args: &[Arg] = promised.as_deref().unwrap_or(args);
self.kstr(b, &deparse_lines(e));
let opens = match fun {
Expr::Ident(name) => makes_context(name),
_ => true,
};
if opens {
b.emit(Op::CallBuiltin(ops::OPEN_CALL, 1), 0);
}
match fun {
Expr::Ident(name) => {
self.kstr(b, name);
b.emit(Op::CallBuiltin(ops::GETFUN, 1), 0);
}
other => self.expr(b, other)?,
}
let call_op = match opens {
true => ops::CALL_OPENED,
false => ops::CALL,
};
if let Some(names) = table_dnn {
let mut rewritten = args.to_vec();
let dnn = match names.len() {
1 if names[0].is_empty() => None,
1 => Some(Expr::Str(names[0].clone())),
_ => Some(Expr::Call {
fun: Box::new(Expr::Ident("c".into())),
args: names
.into_iter()
.map(|n| Arg {
name: None,
value: Some(Expr::Str(n)),
})
.collect(),
}),
};
if let Some(dnn) = dnn {
rewritten.push(Arg {
name: Some(".dnn".into()),
value: Some(dnn),
});
}
self.args(b, &rewritten)?;
b.emit(Op::CallBuiltin(call_op, 3), 0);
return Ok(());
}
if let Some(labels) = bind_labels {
let label = |f: &dyn Fn(&BindLabel) -> Option<String>| Arg {
name: None,
value: Some(Expr::Call {
fun: Box::new(Expr::Ident("c".into())),
args: labels
.iter()
.map(|l| Arg {
name: None,
value: Some(match f(l) {
Some(s) => Expr::Str(s),
None => Expr::Na(NaKind::Character),
}),
})
.collect(),
}),
};
let mut rewritten = args.to_vec();
rewritten.push(Arg {
name: Some(".deparse.sym".into()),
..label(&|(sym, _)| sym.clone())
});
rewritten.push(Arg {
name: Some(".deparse.txt".into()),
..label(&|(_, txt)| Some(txt.clone()))
});
self.args(b, &rewritten)?;
b.emit(Op::CallBuiltin(call_op, 3), 0);
return Ok(());
}
self.args(b, args)?;
b.emit(Op::CallBuiltin(call_op, 3), 0);
let defers = thunked.is_some() && !matches!(fun, Expr::Ident(n) if n == "on.exit");
if defers && (!self.loops.is_empty() || self.lazy_loop) {
self.dispatch_loop_signal(b);
}
Ok(())
}
fn leave_loop(&mut self, b: &mut ChunkBuilder, is_break: bool) {
match self.loops.last_mut() {
Some(ctx) => {
let j = b.emit(Op::Jump(0), 0);
if is_break {
ctx.breaks.push(j);
} else {
ctx.continues.push(j);
}
}
None => {
b.emit(Op::LoadInt(if is_break { 1 } else { 2 }), 0);
b.emit(Op::CallBuiltin(ops::LOOP_SIGNAL, 1), 0);
}
}
}
fn dispatch_loop_signal(&mut self, b: &mut ChunkBuilder) {
b.emit(Op::CallBuiltin(ops::TAKE_LOOP_SIGNAL, 0), 0);
let mut exits = Vec::new();
for code in [1, 2] {
b.emit(Op::Dup, 0);
b.emit(Op::LoadInt(code), 0);
b.emit(Op::NumEq, 0);
exits.push(b.emit(Op::JumpIfTrue(0), 0));
}
b.emit(Op::Pop, 0);
let done = b.emit(Op::Jump(0), 0);
for (j, is_break) in exits.into_iter().zip([true, false]) {
let here = b.current_pos();
b.patch_jump(j, here);
b.emit(Op::Pop, 0);
b.emit(Op::Pop, 0);
self.leave_loop(b, is_break);
}
let end = b.current_pos();
b.patch_jump(done, end);
}
fn runtime_error(&mut self, b: &mut ChunkBuilder, msg: &str) -> Result<(), String> {
self.expr(
b,
&Expr::Call {
fun: Box::new(Expr::Ident("stop".into())),
args: vec![Arg {
name: None,
value: Some(Expr::Str(msg.into())),
}],
},
)
}
fn no_loop_error(&mut self, b: &mut ChunkBuilder) -> Result<(), String> {
self.runtime_error(b, "no loop for break/next, jumping to top level")
}
fn close_loop(&mut self, b: &mut ChunkBuilder, cont: usize, end: usize) {
let ctx = self.loops.pop().expect("close_loop without a loop");
for j in ctx.breaks {
b.patch_jump(j, end);
}
for j in ctx.continues {
b.patch_jump(j, cont);
}
}
fn for_loop(
&mut self,
b: &mut ChunkBuilder,
var: &str,
seq: &Expr,
body: &Expr,
) -> Result<(), String> {
if self.locals.contains(var) {
if let Expr::Binary {
op: BinOp::Colon,
lhs,
rhs,
} = seq
{
return self.for_range(b, var, lhs, rhs, body);
}
}
let v_seq = self.tmp_name(b, "seq");
let v_len = self.tmp_name(b, "len");
let v_i = self.tmp_name(b, "i");
self.expr(b, seq)?;
b.emit(Op::SetVar(v_seq), 0);
b.emit(Op::GetVar(v_seq), 0);
b.emit(Op::CallBuiltin(ops::SEQ_LEN, 1), 0);
b.emit(Op::SetVar(v_len), 0);
b.emit(Op::LoadInt(0), 0);
b.emit(Op::SetVar(v_i), 0);
self.loops.push(LoopCtx {
continues: Vec::new(),
breaks: Vec::new(),
});
let start = b.current_pos();
b.emit(Op::GetVar(v_i), 0);
b.emit(Op::GetVar(v_len), 0);
b.emit(Op::NumLt, 0);
let jf = b.emit(Op::JumpIfFalse(0), 0);
if self.locals.contains(var) {
b.emit(Op::GetVar(v_seq), 0);
b.emit(Op::GetVar(v_i), 0);
b.emit(Op::CallBuiltin(ops::SEQ_ELEM, 2), 0);
let slot = b.add_name(var);
b.emit(Op::SetVar(slot), 0);
} else {
self.kstr(b, var);
b.emit(Op::GetVar(v_seq), 0);
b.emit(Op::GetVar(v_i), 0);
b.emit(Op::CallBuiltin(ops::SEQ_ELEM, 2), 0);
b.emit(Op::CallBuiltin(ops::SETVAR, 2), 0);
b.emit(Op::Pop, 0);
}
self.stmt(b, body)?;
let cont = b.current_pos();
b.emit(Op::GetVar(v_i), 0);
b.emit(Op::LoadInt(1), 0);
b.emit(Op::Add, 0);
b.emit(Op::SetVar(v_i), 0);
b.emit(Op::Jump(start), 0);
let end = b.current_pos();
b.patch_jump(jf, end);
self.close_loop(b, cont, end);
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
Ok(())
}
fn for_range(
&mut self,
b: &mut ChunkBuilder,
var: &str,
lhs: &Expr,
rhs: &Expr,
body: &Expr,
) -> Result<(), String> {
let v_a = self.tmp_name(b, "ra");
let v_b = self.tmp_name(b, "rb");
let v_from = self.tmp_name(b, "rfrom");
let v_step = self.tmp_name(b, "rstep");
let v_len = self.tmp_name(b, "rlen");
let v_c = self.tmp_name(b, "rc");
let islot = b.add_name(var);
let folded = match (const_num(lhs), const_num(rhs)) {
(Some(a), Some(bv)) => {
let whole = a == a.trunc() && bv == bv.trunc();
let step_up = !matches!(a.partial_cmp(&bv), Some(std::cmp::Ordering::Greater));
let count = ((bv - a).abs() + 1e-10).floor() as i64 + 1;
if whole {
b.emit(Op::LoadInt(a as i64), 0);
b.emit(Op::SetVar(v_from), 0);
b.emit(Op::LoadInt(if step_up { 1 } else { -1 }), 0);
b.emit(Op::SetVar(v_step), 0);
} else {
b.emit(Op::LoadFloat(a), 0);
b.emit(Op::SetVar(v_from), 0);
b.emit(Op::LoadFloat(if step_up { 1.0 } else { -1.0 }), 0);
b.emit(Op::SetVar(v_step), 0);
}
b.emit(Op::LoadInt(count), 0);
b.emit(Op::SetVar(v_len), 0);
true
}
_ => false,
};
let native_bound = !folded
&& int_literal(lhs).is_some()
&& matches!(rhs, Expr::Ident(n) if self.native_nums.contains(n));
if native_bound {
let a = int_literal(lhs).unwrap();
self.expr(b, rhs)?; b.emit(Op::SetVar(v_b), 0);
b.emit(Op::LoadInt(a), 0);
b.emit(Op::SetVar(v_from), 0);
b.emit(Op::GetVar(v_from), 0);
b.emit(Op::GetVar(v_b), 0);
b.emit(Op::NumLe, 0);
let to_desc = b.emit(Op::JumpIfFalse(0), 0);
b.emit(Op::LoadInt(1), 0);
b.emit(Op::SetVar(v_step), 0);
let to_after = b.emit(Op::Jump(0), 0);
let desc = b.current_pos();
b.patch_jump(to_desc, desc);
b.emit(Op::LoadInt(-1), 0);
b.emit(Op::SetVar(v_step), 0);
let after = b.current_pos();
b.patch_jump(to_after, after);
b.emit(Op::GetVar(v_b), 0);
b.emit(Op::GetVar(v_from), 0);
b.emit(Op::Sub, 0);
b.emit(Op::AbsFloat, 0);
b.emit(Op::LoadFloat(1e-10), 0);
b.emit(Op::Add, 0);
b.emit(Op::FloorFloat, 0);
b.emit(Op::TruncInt, 0);
b.emit(Op::LoadInt(1), 0);
b.emit(Op::Add, 0);
b.emit(Op::SetVar(v_len), 0);
} else if !folded {
self.expr(b, lhs)?;
b.emit(Op::SetVar(v_a), 0);
self.expr(b, rhs)?;
b.emit(Op::SetVar(v_b), 0);
for (op, dst) in [
(ops::RANGE_FROM, v_from),
(ops::RANGE_STEP, v_step),
(ops::RANGE_LEN, v_len),
] {
b.emit(Op::GetVar(v_a), 0);
b.emit(Op::GetVar(v_b), 0);
b.emit(Op::CallBuiltin(op, 2), 0);
b.emit(Op::SetVar(dst), 0);
}
}
b.emit(Op::LoadInt(0), 0);
b.emit(Op::SetVar(v_c), 0);
self.loops.push(LoopCtx {
continues: Vec::new(),
breaks: Vec::new(),
});
let start = b.current_pos();
b.emit(Op::GetVar(v_c), 0);
b.emit(Op::GetVar(v_len), 0);
b.emit(Op::NumLt, 0);
let jf = b.emit(Op::JumpIfFalse(0), 0);
b.emit(Op::GetVar(v_from), 0);
b.emit(Op::GetVar(v_c), 0);
b.emit(Op::GetVar(v_step), 0);
b.emit(Op::Mul, 0);
b.emit(Op::Add, 0);
b.emit(Op::SetVar(islot), 0);
self.stmt(b, body)?;
let cont = b.current_pos();
b.emit(Op::GetVar(v_c), 0);
b.emit(Op::LoadInt(1), 0);
b.emit(Op::Add, 0);
b.emit(Op::SetVar(v_c), 0);
b.emit(Op::Jump(start), 0);
let end = b.current_pos();
b.patch_jump(jf, end);
self.close_loop(b, cont, end);
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
Ok(())
}
fn short_circuit(
&mut self,
b: &mut ChunkBuilder,
op: &BinOp,
lhs: &Expr,
rhs: &Expr,
) -> Result<(), String> {
let sym = if matches!(op, BinOp::And2) {
"&&"
} else {
"||"
};
self.expr(b, lhs)?;
self.kstr(b, &format!("x{sym}"));
b.emit(Op::CallBuiltin(ops::LOGIC2_ARG, 2), 0);
b.emit(Op::Dup, 0);
let probe = if matches!(op, BinOp::And2) {
ops::IS_FALSE
} else {
ops::IS_TRUE
};
b.emit(Op::CallBuiltin(probe, 1), 0);
let done = b.emit(Op::JumpIfTrue(0), 0);
self.expr(b, rhs)?;
self.kstr(b, &format!("y{sym}"));
b.emit(Op::CallBuiltin(ops::LOGIC2_ARG, 2), 0);
self.kstr(b, binop_name(op));
b.emit(Op::CallBuiltin(ops::BINOP, 3), 0);
let end = b.current_pos();
b.patch_jump(done, end);
Ok(())
}
fn args(&mut self, b: &mut ChunkBuilder, args: &[Arg]) -> Result<(), String> {
for a in args {
match &a.name {
Some(n) => self.kstr(b, n),
None => {
b.emit(Op::LoadUndef, 0);
}
}
match &a.value {
Some(v) => self.expr(b, v)?,
None => {
b.emit(Op::LoadUndef, 0);
}
}
}
let argc = u8::try_from(args.len() * 2)
.map_err(|_| "too many arguments in one call (limit 127)".to_string())?;
b.emit(Op::CallBuiltin(ops::MKARGS, argc), 0);
Ok(())
}
fn switch_expr(&mut self, b: &mut ChunkBuilder, args: &[Arg]) -> Result<(), String> {
let expr = args[0]
.value
.as_ref()
.ok_or("switch: missing EXPR argument")?;
let branches = &args[1..];
let m = branches.len();
self.expr(b, expr)?;
for br in branches {
self.kstr(b, br.name.as_deref().unwrap_or(""));
}
let argc = u8::try_from(1 + m).map_err(|_| "switch: too many branches".to_string())?;
b.emit(Op::CallBuiltin(ops::SWITCH_INDEX, argc), 0);
let mut jt = Vec::with_capacity(m);
for k in 0..m {
b.emit(Op::Dup, 0);
b.emit(Op::LoadInt(k as i64), 0);
b.emit(Op::NumEq, 0);
jt.push(b.emit(Op::JumpIfTrue(0), 0));
}
b.emit(Op::Pop, 0);
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
let mut end_jumps = vec![b.emit(Op::Jump(0), 0)];
let mut value_start = vec![0usize; m];
let mut fallthrough: Vec<(usize, usize)> = Vec::new();
for k in 0..m {
let body_start = b.current_pos();
b.patch_jump(jt[k], body_start);
b.emit(Op::Pop, 0); value_start[k] = b.current_pos();
match branches[k].value.as_ref() {
Some(v) => {
self.expr(b, v)?;
end_jumps.push(b.emit(Op::Jump(0), 0));
}
None => {
if k + 1 < m {
fallthrough.push((k, b.emit(Op::Jump(0), 0)));
} else {
b.emit(Op::CallBuiltin(ops::NULL_INVISIBLE, 0), 0);
end_jumps.push(b.emit(Op::Jump(0), 0));
}
}
}
}
for (k, j) in fallthrough {
b.patch_jump(j, value_start[k + 1]);
}
let end = b.current_pos();
for j in end_jumps {
b.patch_jump(j, end);
}
Ok(())
}
fn closure(&mut self, params: &[Param], body: &Expr) -> Result<usize, String> {
let lazy = params.first().is_some_and(|p| p.name == LAZY_MARK);
let params = ¶ms[usize::from(lazy)..];
let saved = std::mem::take(&mut self.loops);
let in_loop = lazy && (!saved.is_empty() || self.lazy_loop);
let saved_lazy = std::mem::replace(&mut self.lazy_loop, in_loop);
let mut fb = ChunkBuilder::new();
let outer_sites = std::mem::take(&mut self.op_sites);
for p in params {
let Some(default) = &p.default else { continue };
self.kstr(&mut fb, &p.name);
fb.emit(Op::CallBuiltin(ops::MISSING, 1), 0);
let skip = fb.emit(Op::JumpIfFalse(0), 0);
self.kstr(&mut fb, &p.name);
let promised = promise_args(&[Arg {
name: None,
value: Some(default.clone()),
}])
.and_then(|mut wrapped| wrapped.remove(0).value);
self.expr(&mut fb, promised.as_ref().unwrap_or(default))?;
fb.emit(Op::CallBuiltin(ops::SETVAR, 2), 0);
fb.emit(Op::Pop, 0);
let here = fb.current_pos();
fb.patch_jump(skip, here);
}
self.tail = true;
self.expr(&mut fb, body)?;
self.loops = saved;
self.lazy_loop = saved_lazy;
self.finish_chunk(&mut fb, outer_sites);
self.closures.push(ClosureDef {
params: params.iter().map(|p| p.name.clone()).collect(),
chunk: fb.build(),
src: crate::deparse::deparse_closure(params, body),
});
Ok(self.closures.len() - 1)
}
fn assign(
&mut self,
b: &mut ChunkBuilder,
target: &Expr,
value: &Expr,
sup: bool,
) -> Result<(), String> {
match target {
Expr::Ident(name) | Expr::Str(name) if !sup && self.locals.contains(name) => {
self.expr(b, value)?;
b.emit(Op::Dup, 0);
let slot = b.add_name(name);
b.emit(Op::SetVar(slot), 0);
}
Expr::Ident(name) | Expr::Str(name) => {
self.kstr(b, name);
self.expr(b, value)?;
let op = if sup { ops::SETSUPER } else { ops::SETVAR };
b.emit(Op::CallBuiltin(op, 2), 0);
}
_ => {
let whole = Expr::Assign {
target: Box::new(target.clone()),
value: Box::new(value.clone()),
super_assign: sup,
};
let outer = std::mem::replace(
&mut self.assign_text,
crate::deparse::deparse_first_line(&whole),
);
let out = self.complex_assign(b, target, value, sup);
self.assign_text = outer;
out?;
}
}
Ok(())
}
fn complex_assign(
&mut self,
b: &mut ChunkBuilder,
target: &Expr,
value: &Expr,
sup: bool,
) -> Result<(), String> {
if !matches!(target, Expr::Index { .. } | Expr::Call { .. }) {
return self.runtime_error(b, "invalid (do_set) left-hand side to assignment");
}
self.expr(b, value)?;
b.emit(Op::Dup, 0);
self.assign_stack(b, target, sup)?;
b.emit(Op::Pop, 0);
Ok(())
}
fn mark_shared_intermediate(&mut self, b: &mut ChunkBuilder, obj: &Expr) {
if !matches!(obj, Expr::Ident(_) | Expr::Str(_)) {
b.emit(Op::CallBuiltin(ops::MARK_SHARED, 1), 0);
}
}
fn assign_stack(
&mut self,
b: &mut ChunkBuilder,
target: &Expr,
sup: bool,
) -> Result<(), String> {
match target {
Expr::Ident(name) | Expr::Str(name) => {
self.kstr(b, name);
b.emit(Op::Swap, 0);
let op = if sup { ops::SETSUPER } else { ops::SETVAR };
b.emit(Op::CallBuiltin(op, 2), 0);
Ok(())
}
Expr::Index { kind, obj, args } => {
self.expr(b, obj)?;
self.mark_shared_intermediate(b, obj);
let ip = match kind {
IndexKind::Dollar | IndexKind::At => {
match args.first().and_then(|a| a.value.clone()) {
Some(Expr::Str(n)) => self.kstr(b, &n),
_ => return Err("malformed $ assignment target".into()),
}
b.emit(Op::Rot, 0);
b.emit(Op::CallBuiltin(ops::DOLLAR_SET, 3), 0)
}
IndexKind::Single => {
self.args(b, args)?;
b.emit(Op::Rot, 0);
b.emit(Op::CallBuiltin(ops::INDEX_SET, 3), 0)
}
IndexKind::Double => {
self.args(b, args)?;
b.emit(Op::Rot, 0);
b.emit(Op::CallBuiltin(ops::INDEX2_SET, 3), 0)
}
};
self.op_sites.push((ip, self.assign_text.clone()));
self.assign_stack(b, obj, sup)
}
Expr::Call { fun, args } => {
let Expr::Ident(fname) = fun.as_ref() else {
return Err("invalid function in complex assignment".into());
};
let Some(inner) = args.first().and_then(|a| a.value.clone()) else {
return Err(format!("invalid target for {fname}<-"));
};
self.kstr(b, fname);
b.emit(Op::Swap, 0);
self.expr(b, &inner)?;
b.emit(Op::Swap, 0);
self.args(b, &args[1..])?;
b.emit(Op::Swap, 0);
let text = self.assign_text.clone();
self.kstr(b, &text);
b.emit(Op::CallBuiltin(ops::REPLACE, 5), 0);
self.assign_stack(b, &inner, sup)
}
_ => self.runtime_error(b, "target of assignment expands to non-language object"),
}
}
}
fn const_num(e: &Expr) -> Option<f64> {
match e {
Expr::Num(n) => Some(*n),
Expr::Int(n) => Some(*n as f64),
_ => None,
}
}
fn int_literal(e: &Expr) -> Option<i64> {
match e {
Expr::Int(n) => Some(*n),
Expr::Num(n) if *n == n.trunc() => Some(*n as i64),
_ => None,
}
}
fn native_num_slots(exprs: &[Expr]) -> std::collections::HashSet<String> {
let mut cand = std::collections::HashSet::new();
let mut assigns: Vec<(String, &Expr)> = Vec::new();
for e in exprs {
collect_num_assigns(e, &mut cand, &mut assigns);
}
loop {
let mut changed = false;
for (name, rhs) in &assigns {
if cand.contains(name) && !is_native_num(rhs, &cand) {
cand.remove(name);
changed = true;
}
}
if !changed {
break;
}
}
cand
}
fn collect_num_assigns<'a>(
e: &'a Expr,
cand: &mut std::collections::HashSet<String>,
assigns: &mut Vec<(String, &'a Expr)>,
) {
match e {
Expr::Assign {
target,
value,
super_assign: false,
} => {
if let Expr::Ident(n) | Expr::Str(n) = target.as_ref() {
cand.insert(n.clone());
assigns.push((n.clone(), value));
}
collect_num_assigns(value, cand, assigns);
}
Expr::For { var, seq, body } => {
if int_literal(seq_start(seq)).is_some() {
cand.insert(var.clone());
}
collect_num_assigns(body, cand, assigns);
}
Expr::If { cond, then, els } => {
collect_num_assigns(cond, cand, assigns);
collect_num_assigns(then, cand, assigns);
if let Some(x) = els {
collect_num_assigns(x, cand, assigns);
}
}
Expr::While { cond, body } => {
collect_num_assigns(cond, cand, assigns);
collect_num_assigns(body, cand, assigns);
}
Expr::Repeat(b) => collect_num_assigns(b, cand, assigns),
Expr::Paren(x) => collect_num_assigns(x, cand, assigns),
Expr::Block(xs) => {
for x in xs {
collect_num_assigns(x, cand, assigns);
}
}
_ => {}
}
}
fn seq_start(seq: &Expr) -> &Expr {
match seq {
Expr::Binary {
op: BinOp::Colon,
lhs,
..
} => lhs,
other => other,
}
}
fn is_native_num(e: &Expr, cand: &std::collections::HashSet<String>) -> bool {
match e {
Expr::Num(_) | Expr::Int(_) => true,
Expr::Ident(n) => cand.contains(n),
Expr::Binary { op, lhs, rhs } => {
matches!(
op,
BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Pow
) && is_native_num(lhs, cand)
&& is_native_num(rhs, cand)
}
Expr::Special { name, lhs, rhs } if name == "%%" || name == "%/%" => {
is_native_num(lhs, cand) && is_native_num(rhs, cand)
}
Expr::Unary { operand, .. } => is_native_num(operand, cand),
_ => false,
}
}
const LAZY_MARK: &str = ".rlang_lazy";
fn lazy_thunk(body: Expr) -> Expr {
Expr::Function {
params: vec![Param {
name: LAZY_MARK.into(),
default: None,
}],
body: Box::new(body),
}
}
fn thunk(body: Expr) -> Expr {
Expr::Function {
params: Vec::new(),
body: Box::new(body),
}
}
fn call_thunk(body: Expr) -> Expr {
Expr::Call {
fun: Box::new(thunk(body)),
args: Vec::new(),
}
}
fn quote_call(inner: &Expr, splice: bool) -> Expr {
let mut args = vec![Arg {
name: None,
value: Some(Expr::Str(deparse_lines(inner))),
}];
if splice {
args.push(Arg {
name: None,
value: Some(Expr::Bool(true)),
});
}
Expr::Call {
fun: Box::new(Expr::Ident(".rlang_quote".into())),
args,
}
}
type BindLabel = (Option<String>, String);
fn promise_args(args: &[Arg]) -> Option<Vec<Arg>> {
fn is_lazy_thunk(e: &Expr) -> bool {
matches!(e, Expr::Function { params, .. } if params.first().is_some_and(|p| p.name == LAZY_MARK))
}
fn is_literal(e: &Expr) -> bool {
matches!(
e,
Expr::Num(_) | Expr::Int(_) | Expr::Str(_) | Expr::Bool(_) | Expr::Null
)
}
let mut out = Vec::with_capacity(args.len());
let mut changed = false;
for a in args {
match &a.value {
Some(v) if !matches!(v, Expr::Dots) && !is_literal(v) && !is_lazy_thunk(v) => {
changed = true;
out.push(Arg {
name: a.name.clone(),
value: Some(Expr::Call {
fun: Box::new(Expr::Ident(".rlang_promise".into())),
args: vec![Arg {
name: None,
value: Some(thunk(v.clone())),
}],
}),
});
}
_ => out.push(a.clone()),
}
}
changed.then_some(out)
}
fn thunk_lazy_args(name: &str, args: &[Arg]) -> Option<Vec<Arg>> {
let deferred: &[&str] = match name {
"tryCatch" | "withCallingHandlers" => &["", "expr", "finally"],
"try" => &["", "expr"],
"on.exit" => &["", "expr"],
"withRestarts" => &["", "expr"],
"suppressWarnings" | "suppressMessages" | "suppressPackageStartupMessages" => &["", "expr"],
_ => return None,
};
let mut out = Vec::with_capacity(args.len());
let mut seen_positional = false;
let mut changed = false;
for a in args {
let value = a.value.clone()?;
let is_body = match &a.name {
Some(n) => deferred.contains(&n.as_str()),
None => {
let first = !seen_positional;
seen_positional = true;
first && deferred.contains(&"")
}
};
if is_body && !matches!(value, Expr::Dots) {
changed = true;
out.push(Arg {
name: a.name.clone(),
value: Some(lazy_thunk(value)),
});
} else {
out.push(a.clone());
}
}
changed.then_some(out)
}
fn native_binop(op: &BinOp) -> Option<Op> {
match op {
BinOp::Add => Some(Op::Add),
BinOp::Sub => Some(Op::Sub),
BinOp::Mul => Some(Op::Mul),
_ => None,
}
}
fn binop_name(op: &BinOp) -> &'static str {
match op {
BinOp::Add => "+",
BinOp::Sub => "-",
BinOp::Mul => "*",
BinOp::Div => "/",
BinOp::Pow => "^",
BinOp::Lt => "<",
BinOp::Gt => ">",
BinOp::Le => "<=",
BinOp::Ge => ">=",
BinOp::Eq => "==",
BinOp::Ne => "!=",
BinOp::And | BinOp::And2 => "&",
BinOp::Or | BinOp::Or2 => "|",
BinOp::Colon => ":",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::parser::parse;
fn ops_of(src: &str) -> Vec<Op> {
compile(&parse(src).unwrap()).unwrap().main.ops
}
#[test]
fn loops_lower_to_native_jumps_not_builtins() {
let ops = ops_of("for (i in 1:3) i");
assert!(ops.iter().any(|o| matches!(o, Op::NumLt)));
assert!(ops.iter().any(|o| matches!(o, Op::JumpIfFalse(_))));
assert!(ops.iter().any(|o| matches!(o, Op::Add)));
}
#[test]
fn short_circuit_and_emits_a_guard_jump() {
let ops = ops_of("a && b");
assert!(ops
.iter()
.any(|o| matches!(o, Op::CallBuiltin(id, 1) if *id == ops::IS_FALSE)));
assert!(ops.iter().any(|o| matches!(o, Op::JumpIfTrue(_))));
}
#[test]
fn nested_index_assignment_rebuilds_outward_in() {
let ops = ops_of("x$a[1] <- 9");
let ids: Vec<u16> = ops
.iter()
.filter_map(|o| match o {
Op::CallBuiltin(id, _) => Some(*id),
_ => None,
})
.collect();
let pos = |id: u16| ids.iter().position(|x| *x == id);
assert!(pos(ops::INDEX_SET) < pos(ops::DOLLAR_SET));
assert!(pos(ops::DOLLAR_SET) < pos(ops::SETVAR));
}
#[test]
fn replacement_functions_lower_to_replace() {
let ops = ops_of("names(x) <- c(\"a\")");
assert!(ops
.iter()
.any(|o| matches!(o, Op::CallBuiltin(id, 5) if *id == ops::REPLACE)));
}
#[test]
fn break_outside_a_loop_is_a_runtime_error() {
let ops = ops_of("break");
assert!(!ops.is_empty());
assert!(!ops.iter().any(|o| matches!(o, Op::Jump(_))));
}
}