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>,
tail: bool,
}
const DYNAMIC_ENV_FNS: &[&str] = &[
"get",
"get0",
"mget",
"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",
];
fn makes_context(name: &str) -> bool {
!R_PRIMITIVES.contains(&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()) {
*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);
}
}
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 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> {
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 } => {
if let Expr::Ident(name) = fun.as_ref() {
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 matches!(name.as_str(), "quote" | "bquote") && args.len() == 1 {
if let Some(inner) = args[0].value.clone() {
return self.expr(b, "e_call(&inner));
}
}
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.as_ref() {
Expr::Ident(name) => thunk_lazy_args(name, args),
_ => None,
};
let args: &[Arg] = thunked.as_deref().unwrap_or(args);
let promised = match fun.as_ref() {
_ 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.as_ref() {
Expr::Ident(name) => makes_context(name),
_ => true,
};
if opens {
b.emit(Op::CallBuiltin(ops::OPEN_CALL, 1), 0);
}
match fun.as_ref() {
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,
};
let pkg_nse = matches!(
fun.as_ref(),
Expr::Ident(n) if matches!(n.as_str(),
"library" | "require" | "requireNamespace" | "loadNamespace")
);
if pkg_nse {
if let Some(Arg {
name,
value: Some(Expr::Ident(sym)),
}) = args.first()
{
let mut rewritten = args.to_vec();
rewritten[0] = Arg {
name: name.clone(),
value: Some(Expr::Str(sym.clone())),
};
self.args(b, &rewritten)?;
b.emit(Op::CallBuiltin(call_op, 3), 0);
return Ok(());
}
}
let is_table = matches!(fun.as_ref(), Expr::Ident(n) if n == "table");
if is_table {
if let Some(Arg {
name: None,
value: Some(Expr::Ident(sym)),
}) = args.first()
{
let mut rewritten = args.to_vec();
rewritten.push(Arg {
name: Some(".dnn".into()),
value: Some(Expr::Str(sym.clone())),
});
self.args(b, &rewritten)?;
b.emit(Op::CallBuiltin(call_op, 3), 0);
return Ok(());
}
}
let is_bind =
matches!(fun.as_ref(), Expr::Ident(n) if n == "rbind" || n == "cbind");
let has_dots = args
.iter()
.any(|a| matches!(a.value, Some(Expr::Dots)) || a.value.is_none());
if is_bind && !has_dots && !args.is_empty() {
let label = |f: &dyn Fn(&Expr) -> Option<String>| Arg {
name: None,
value: Some(Expr::Call {
fun: Box::new(Expr::Ident("c".into())),
args: args
.iter()
.map(|a| Arg {
name: None,
value: Some(match a.value.as_ref().and_then(f) {
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(&|e| match e {
Expr::Ident(s) => Some(s.clone()),
_ => None,
})
});
rewritten.push(Arg {
name: Some(".deparse.txt".into()),
..label(&|e| Some(deparse_expr(e)))
});
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);
}
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)?;
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);
}
}
}
},
Expr::Special { name, lhs, rhs } => {
self.expr(b, lhs)?;
self.expr(b, rhs)?;
self.kstr(b, name);
b.emit(Op::CallBuiltin(ops::SPECIAL, 3), 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)?;
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);
}
}
}
Expr::If { cond, then, els } => {
self.expr(b, cond)?;
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 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)?;
b.emit(Op::CallBuiltin(ops::TRUTHY, 1), 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() {
return Err("no loop for break/next, jumping to top level".into());
}
let j = b.emit(Op::Jump(0), 0);
self.loops.last_mut().unwrap().breaks.push(j);
b.emit(Op::CallBuiltin(ops::CONST_NULL, 0), 0);
}
Expr::Next => {
if self.loops.is_empty() {
return Err("no loop for break/next, jumping to top level".into());
}
let j = b.emit(Op::Jump(0), 0);
self.loops.last_mut().unwrap().continues.push(j);
b.emit(Op::CallBuiltin(ops::CONST_NULL, 0), 0);
}
Expr::Assign {
target,
value,
super_assign,
} => self.assign(b, target, value, *super_assign)?,
}
Ok(())
}
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> {
self.expr(b, lhs)?;
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, 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 saved = std::mem::take(&mut self.loops);
let mut fb = ChunkBuilder::new();
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.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);
}
_ => {
self.rebuild(b, target, value, sup)?;
}
}
Ok(())
}
fn rebuild(
&mut self,
b: &mut ChunkBuilder,
target: &Expr,
value: &Expr,
sup: bool,
) -> Result<(), String> {
match target {
Expr::Index { kind, obj, args } => {
self.expr(b, obj)?;
self.mark_shared_intermediate(b, obj);
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()),
}
self.expr(b, value)?;
b.emit(Op::CallBuiltin(ops::DOLLAR_SET, 3), 0);
}
IndexKind::Single => {
self.args(b, args)?;
self.expr(b, value)?;
b.emit(Op::CallBuiltin(ops::INDEX_SET, 3), 0);
}
IndexKind::Double => {
self.args(b, args)?;
self.expr(b, value)?;
b.emit(Op::CallBuiltin(ops::INDEX2_SET, 3), 0);
}
}
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);
self.expr(b, &inner)?;
self.args(b, &args[1..])?;
self.expr(b, value)?;
b.emit(Op::CallBuiltin(ops::REPLACE, 4), 0);
self.assign_stack(b, &inner, sup)
}
other => Err(format!("invalid assignment target: {other:?}")),
}
}
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);
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.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);
b.emit(Op::CallBuiltin(ops::REPLACE, 4), 0);
self.assign_stack(b, &inner, sup)
}
other => Err(format!("invalid nested assignment target: {other:?}")),
}
}
}
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,
}
}
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) -> Expr {
Expr::Call {
fun: Box::new(Expr::Ident(".rlang_quote".into())),
args: vec![Arg {
name: None,
value: Some(Expr::Str(deparse_lines(inner))),
}],
}
}
fn promise_args(args: &[Arg]) -> Option<Vec<Arg>> {
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) => {
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(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, 4) if *id == ops::REPLACE)));
}
#[test]
fn break_outside_a_loop_is_a_compile_error() {
assert!(compile(&parse("break").unwrap()).is_err());
}
}