//! This module implements a compiler for compiling the rnix AST
//! representation to Tvix bytecode.
//!
//! A note on `unwrap()`: This module contains a lot of calls to
//! `unwrap()` or `expect(...)` on data structures returned by `rnix`.
//! The reason for this is that rnix uses the same data structures to
//! represent broken and correct ASTs, so all typed AST variants have
//! the ability to represent an incorrect node.
//!
//! However, at the time that the AST is passed to the compiler we
//! have verified that `rnix` considers the code to be correct, so all
//! variants are fulfilled. In cases where the invariant is guaranteed
//! by the code in this module, `debug_assert!` has been used to catch
//! mistakes early during development.
use path_clean::PathClean;
use rnix::types::{BinOpKind, EntryHolder, TokenWrapper, TypedNode, Wrapper};
use std::path::{Path, PathBuf};
use crate::chunk::Chunk;
use crate::errors::{Error, EvalResult};
use crate::opcode::{CodeIdx, OpCode};
use crate::value::Value;
use crate::warnings::{EvalWarning, WarningKind};
/// Represents the result of compiling a piece of Nix code. If
/// compilation was successful, the resulting bytecode can be passed
/// to the VM.
pub struct CompilationResult {
pub chunk: Chunk,
pub warnings: Vec<EvalWarning>,
}
// Represents a single local already known to the compiler.
struct Local {
// Definition name, which can be different kinds of tokens (plain
// string or identifier). Nix does not allow dynamic names inside
// of `let`-expressions.
name: String,
// Scope depth of this local.
depth: usize,
// Phantom locals are not actually accessible by users (e.g.
// intermediate values used for `with`).
phantom: bool,
}
/// Represents a stack offset containing keys which are currently
/// in-scope through a with expression.
#[derive(Debug)]
struct With {
depth: usize,
}
/// Represents a scope known during compilation, which can be resolved
/// directly to stack indices.
///
/// TODO(tazjin): `with`-stack
/// TODO(tazjin): flag "specials" (e.g. note depth if builtins are
/// overridden)
#[derive(Default)]
struct Scope {
locals: Vec<Local>,
// How many scopes "deep" are these locals?
scope_depth: usize,
// Stack indices of attribute sets currently in scope through
// `with`.
with_stack: Vec<With>,
// Certain symbols are considered to be "poisoning" the scope when
// defined. This is because users are allowed to override symbols
// like 'true' or 'null'.
//
// To support this efficiently, the depth at which a poisoning
// occured is tracked here.
poisoned_true: usize,
poisoned_false: usize,
poisoned_null: usize,
}
struct Compiler {
chunk: Chunk,
scope: Scope,
warnings: Vec<EvalWarning>,
root_dir: PathBuf,
}
impl Compiler {
fn compile(&mut self, node: rnix::SyntaxNode) -> EvalResult<()> {
match node.kind() {
// Root of a file contains no content, it's just a marker
// type.
rnix::SyntaxKind::NODE_ROOT => self.compile(node.first_child().expect("TODO")),
// Literals contain a single token consisting of the
// literal itself.
rnix::SyntaxKind::NODE_LITERAL => {
let value = rnix::types::Value::cast(node).unwrap();
self.compile_literal(value)
}
rnix::SyntaxKind::NODE_STRING => {
let op = rnix::types::Str::cast(node).unwrap();
self.compile_string(op)
}
// The interpolation & dynamic nodes are just wrappers
// around the inner value of a fragment, they only require
// unwrapping.
rnix::SyntaxKind::NODE_STRING_INTERPOL | rnix::SyntaxKind::NODE_DYNAMIC => {
self.compile(node.first_child().expect("TODO (should not be possible)"))
}
rnix::SyntaxKind::NODE_BIN_OP => {
let op = rnix::types::BinOp::cast(node).expect("TODO (should not be possible)");
self.compile_binop(op)
}
rnix::SyntaxKind::NODE_UNARY_OP => {
let op = rnix::types::UnaryOp::cast(node).expect("TODO: (should not be possible)");
self.compile_unary_op(op)
}
rnix::SyntaxKind::NODE_PAREN => {
let node = rnix::types::Paren::cast(node).unwrap();
self.compile(node.inner().unwrap())
}
rnix::SyntaxKind::NODE_IDENT => {
let node = rnix::types::Ident::cast(node).unwrap();
self.compile_ident(node)
}
rnix::SyntaxKind::NODE_ATTR_SET => {
let node = rnix::types::AttrSet::cast(node).unwrap();
self.compile_attr_set(node)
}
rnix::SyntaxKind::NODE_SELECT => {
let node = rnix::types::Select::cast(node).unwrap();
self.compile_select(node)
}
rnix::SyntaxKind::NODE_OR_DEFAULT => {
let node = rnix::types::OrDefault::cast(node).unwrap();
self.compile_or_default(node)
}
rnix::SyntaxKind::NODE_LIST => {
let node = rnix::types::List::cast(node).unwrap();
self.compile_list(node)
}
rnix::SyntaxKind::NODE_IF_ELSE => {
let node = rnix::types::IfElse::cast(node).unwrap();
self.compile_if_else(node)
}
rnix::SyntaxKind::NODE_LET_IN => {
let node = rnix::types::LetIn::cast(node).unwrap();
self.compile_let_in(node)
}
rnix::SyntaxKind::NODE_WITH => {
let node = rnix::types::With::cast(node).unwrap();
self.compile_with(node)
}
kind => panic!("visiting unsupported node: {:?}", kind),
}
}
/// Compiles nodes the same way that `Self::compile` does, with
/// the exception of identifiers which are added literally to the
/// stack as string values.
///
/// This is needed for correctly accessing attribute sets.
fn compile_with_literal_ident(&mut self, node: rnix::SyntaxNode) -> EvalResult<()> {
if node.kind() == rnix::SyntaxKind::NODE_IDENT {
let ident = rnix::types::Ident::cast(node).unwrap();
self.emit_literal_ident(&ident);
return Ok(());
}
self.compile(node)
}
fn compile_literal(&mut self, node: rnix::types::Value) -> EvalResult<()> {
match node.to_value().unwrap() {
rnix::NixValue::Float(f) => {
let idx = self.chunk.push_constant(Value::Float(f));
self.chunk.push_op(OpCode::OpConstant(idx));
Ok(())
}
rnix::NixValue::Integer(i) => {
let idx = self.chunk.push_constant(Value::Integer(i));
self.chunk.push_op(OpCode::OpConstant(idx));
Ok(())
}
// These nodes are yielded by literal URL values.
rnix::NixValue::String(s) => {
self.warnings.push(EvalWarning {
node: node.node().clone(),
kind: WarningKind::DeprecatedLiteralURL,
});
let idx = self.chunk.push_constant(Value::String(s.into()));
self.chunk.push_op(OpCode::OpConstant(idx));
Ok(())
}
rnix::NixValue::Path(anchor, path) => self.compile_path(anchor, path),
}
}
fn compile_path(&mut self, anchor: rnix::value::Anchor, path: String) -> EvalResult<()> {
let path = match anchor {
rnix::value::Anchor::Absolute => Path::new(&path).to_owned(),
rnix::value::Anchor::Home => {
let mut buf = dirs::home_dir().ok_or_else(|| {
Error::PathResolution("failed to determine home directory".into())
})?;
buf.push(&path);
buf
}
rnix::value::Anchor::Relative => {
let mut buf = self.root_dir.clone();
buf.push(path);
buf
}
// This confusingly named variant is actually
// angle-bracket lookups, which in C++ Nix desugar
// to calls to `__findFile` (implicitly in the
// current scope).
rnix::value::Anchor::Store => todo!("resolve <...> lookups at runtime"),
};
// TODO: Use https://github.com/rust-lang/rfcs/issues/2208
// once it is available
let value = Value::Path(path.clean());
let idx = self.chunk.push_constant(value);
self.chunk.push_op(OpCode::OpConstant(idx));
Ok(())
}
fn compile_string(&mut self, string: rnix::types::Str) -> EvalResult<()> {
let mut count = 0;
// The string parts are produced in literal order, however
// they need to be reversed on the stack in order to
// efficiently create the real string in case of
// interpolation.
for part in string.parts().into_iter().rev() {
count += 1;
match part {
// Interpolated expressions are compiled as normal and
// dealt with by the VM before being assembled into
// the final string.
rnix::StrPart::Ast(node) => self.compile(node)?,
rnix::StrPart::Literal(lit) => {
let idx = self.chunk.push_constant(Value::String(lit.into()));
self.chunk.push_op(OpCode::OpConstant(idx));
}
}
}
if count != 1 {
self.chunk.push_op(OpCode::OpInterpolate(count));
}
Ok(())
}
fn compile_binop(&mut self, op: rnix::types::BinOp) -> EvalResult<()> {
// Short-circuiting and other strange operators, which are
// under the same node type as NODE_BIN_OP, but need to be
// handled separately (i.e. before compiling the expressions
// used for standard binary operators).
match op.operator().unwrap() {
BinOpKind::And => return self.compile_and(op),
BinOpKind::Or => return self.compile_or(op),
BinOpKind::Implication => return self.compile_implication(op),
BinOpKind::IsSet => return self.compile_is_set(op),
_ => {}
};
self.compile(op.lhs().unwrap())?;
self.compile(op.rhs().unwrap())?;
match op.operator().unwrap() {
BinOpKind::Add => self.chunk.push_op(OpCode::OpAdd),
BinOpKind::Sub => self.chunk.push_op(OpCode::OpSub),
BinOpKind::Mul => self.chunk.push_op(OpCode::OpMul),
BinOpKind::Div => self.chunk.push_op(OpCode::OpDiv),
BinOpKind::Update => self.chunk.push_op(OpCode::OpAttrsUpdate),
BinOpKind::Equal => self.chunk.push_op(OpCode::OpEqual),
BinOpKind::Less => self.chunk.push_op(OpCode::OpLess),
BinOpKind::LessOrEq => self.chunk.push_op(OpCode::OpLessOrEq),
BinOpKind::More => self.chunk.push_op(OpCode::OpMore),
BinOpKind::MoreOrEq => self.chunk.push_op(OpCode::OpMoreOrEq),
BinOpKind::Concat => self.chunk.push_op(OpCode::OpConcat),
BinOpKind::NotEqual => {
self.chunk.push_op(OpCode::OpEqual);
self.chunk.push_op(OpCode::OpInvert)
}
// Handled by separate branch above.
BinOpKind::And | BinOpKind::Implication | BinOpKind::Or | BinOpKind::IsSet => {
unreachable!()
}
};
Ok(())
}
fn compile_unary_op(&mut self, op: rnix::types::UnaryOp) -> EvalResult<()> {
self.compile(op.value().unwrap())?;
use rnix::types::UnaryOpKind;
let opcode = match op.operator() {
UnaryOpKind::Invert => OpCode::OpInvert,
UnaryOpKind::Negate => OpCode::OpNegate,
};
self.chunk.push_op(opcode);
Ok(())
}
fn compile_ident(&mut self, node: rnix::types::Ident) -> EvalResult<()> {
match node.as_str() {
// TODO(tazjin): Nix technically allows code like
//
// let null = 1; in null
// => 1
//
// which we do *not* want to check at runtime. Once
// scoping is introduced, the compiler should carry some
// optimised information about any "weird" stuff that's
// happened to the scope (such as overrides of these
// literals, or builtins).
"true" if self.scope.poisoned_true == 0 => self.chunk.push_op(OpCode::OpTrue),
"false" if self.scope.poisoned_false == 0 => self.chunk.push_op(OpCode::OpFalse),
"null" if self.scope.poisoned_null == 0 => self.chunk.push_op(OpCode::OpNull),
name => {
// Note: `with` and some other special scoping
// features are not yet implemented.
match self.resolve_local(name) {
Some(idx) => self.chunk.push_op(OpCode::OpGetLocal(idx)),
None => {
if self.scope.with_stack.is_empty() {
return Err(Error::UnknownStaticVariable(node));
}
// Variable needs to be dynamically resolved
// at runtime.
let idx = self.chunk.push_constant(Value::String(name.into()));
self.chunk.push_op(OpCode::OpConstant(idx));
self.chunk.push_op(OpCode::OpResolveWith)
}
}
}
};
Ok(())
}
// Compile attribute set literals into equivalent bytecode.
//
// This is complicated by a number of features specific to Nix
// attribute sets, most importantly:
//
// 1. Keys can be dynamically constructed through interpolation.
// 2. Keys can refer to nested attribute sets.
// 3. Attribute sets can (optionally) be recursive.
fn compile_attr_set(&mut self, node: rnix::types::AttrSet) -> EvalResult<()> {
if node.recursive() {
todo!("recursive attribute sets are not yet implemented")
}
let mut count = 0;
// Inherits have to be evaluated before entering the scope of
// a potentially recursive attribute sets (i.e. we always
// inherit "from the outside").
for inherit in node.inherits() {
match inherit.from() {
Some(from) => {
for ident in inherit.idents() {
count += 1;
// First emit the identifier itself
self.emit_literal_ident(&ident);
// Then emit the node that we're inheriting
// from.
//
// TODO: Likely significant optimisation
// potential in having a multi-select
// instruction followed by a merge, rather
// than pushing/popping the same attrs
// potentially a lot of times.
self.compile(from.inner().unwrap())?;
self.emit_literal_ident(&ident);
self.chunk.push_op(OpCode::OpAttrsSelect);
}
}
None => {
for ident in inherit.idents() {
count += 1;
self.emit_literal_ident(&ident);
match self.resolve_local(ident.as_str()) {
Some(idx) => self.chunk.push_op(OpCode::OpGetLocal(idx)),
None => return Err(Error::UnknownStaticVariable(ident)),
};
}
}
}
}
for kv in node.entries() {
count += 1;
// Because attribute set literals can contain nested keys,
// there is potentially more than one key fragment. If
// this is the case, a special operation to construct a
// runtime value representing the attribute path is
// emitted.
let mut key_count = 0;
for fragment in kv.key().unwrap().path() {
key_count += 1;
match fragment.kind() {
rnix::SyntaxKind::NODE_IDENT => {
let ident = rnix::types::Ident::cast(fragment).unwrap();
// TODO(tazjin): intern!
let idx = self
.chunk
.push_constant(Value::String(ident.as_str().into()));
self.chunk.push_op(OpCode::OpConstant(idx));
}
// For all other expression types, we simply
// compile them as normal. The operation should
// result in a string value, which is checked at
// runtime on construction.
_ => self.compile(fragment)?,
}
}
// We're done with the key if there was only one fragment,
// otherwise we need to emit an instruction to construct
// the attribute path.
if key_count > 1 {
self.chunk.push_op(OpCode::OpAttrPath(key_count));
}
// The value is just compiled as normal so that its
// resulting value is on the stack when the attribute set
// is constructed at runtime.
self.compile(kv.value().unwrap())?;
}
self.chunk.push_op(OpCode::OpAttrs(count));
Ok(())
}
fn compile_select(&mut self, node: rnix::types::Select) -> EvalResult<()> {
// Push the set onto the stack
self.compile(node.set().unwrap())?;
// Push the key and emit the access instruction.
//
// This order matters because the key needs to be evaluated
// first to fail in the correct order on type errors.
self.compile_with_literal_ident(node.index().unwrap())?;
self.chunk.push_op(OpCode::OpAttrsSelect);
Ok(())
}
// Compile list literals into equivalent bytecode. List
// construction is fairly simple, consisting of pushing code for
// each literal element and an instruction with the element count.
//
// The VM, after evaluating the code for each element, simply
// constructs the list from the given number of elements.
fn compile_list(&mut self, node: rnix::types::List) -> EvalResult<()> {
let mut count = 0;
for item in node.items() {
count += 1;
self.compile(item)?;
}
self.chunk.push_op(OpCode::OpList(count));
Ok(())
}
// Compile conditional expressions using jumping instructions in the VM.
//
// ┌────────────────────┐
// │ 0 [ conditional ] │
// │ 1 JUMP_IF_FALSE →┼─┐
// │ 2 [ main body ] │ │ Jump to else body if
// ┌┼─3─← JUMP │ │ condition is false.
// Jump over else body ││ 4 [ else body ]←┼─┘
// if condition is true.└┼─5─→ ... │
// └────────────────────┘
fn compile_if_else(&mut self, node: rnix::types::IfElse) -> EvalResult<()> {
self.compile(node.condition().unwrap())?;
let then_idx = self.chunk.push_op(OpCode::OpJumpIfFalse(0));
self.chunk.push_op(OpCode::OpPop); // discard condition value
self.compile(node.body().unwrap())?;
let else_idx = self.chunk.push_op(OpCode::OpJump(0));
self.patch_jump(then_idx); // patch jump *to* else_body
self.chunk.push_op(OpCode::OpPop); // discard condition value
self.compile(node.else_body().unwrap())?;
self.patch_jump(else_idx); // patch jump *over* else body
Ok(())
}
fn compile_and(&mut self, node: rnix::types::BinOp) -> EvalResult<()> {
debug_assert!(
matches!(node.operator(), Some(BinOpKind::And)),
"compile_and called with wrong operator kind: {:?}",
node.operator(),
);
// Leave left-hand side value on the stack.
self.compile(node.lhs().unwrap())?;
// If this value is false, jump over the right-hand side - the
// whole expression is false.
let end_idx = self.chunk.push_op(OpCode::OpJumpIfFalse(0));
// Otherwise, remove the previous value and leave the
// right-hand side on the stack. Its result is now the value
// of the whole expression.
self.chunk.push_op(OpCode::OpPop);
self.compile(node.rhs().unwrap())?;
self.patch_jump(end_idx);
self.chunk.push_op(OpCode::OpAssertBool);
Ok(())
}
fn compile_or(&mut self, node: rnix::types::BinOp) -> EvalResult<()> {
debug_assert!(
matches!(node.operator(), Some(BinOpKind::Or)),
"compile_or called with wrong operator kind: {:?}",
node.operator(),
);
// Leave left-hand side value on the stack
self.compile(node.lhs().unwrap())?;
// Opposite of above: If this value is **true**, we can
// short-circuit the right-hand side.
let end_idx = self.chunk.push_op(OpCode::OpJumpIfTrue(0));
self.chunk.push_op(OpCode::OpPop);
self.compile(node.rhs().unwrap())?;
self.patch_jump(end_idx);
self.chunk.push_op(OpCode::OpAssertBool);
Ok(())
}
fn compile_implication(&mut self, node: rnix::types::BinOp) -> EvalResult<()> {
debug_assert!(
matches!(node.operator(), Some(BinOpKind::Implication)),
"compile_implication called with wrong operator kind: {:?}",
node.operator(),
);
// Leave left-hand side value on the stack and invert it.
self.compile(node.lhs().unwrap())?;
self.chunk.push_op(OpCode::OpInvert);
// Exactly as `||` (because `a -> b` = `!a || b`).
let end_idx = self.chunk.push_op(OpCode::OpJumpIfTrue(0));
self.chunk.push_op(OpCode::OpPop);
self.compile(node.rhs().unwrap())?;
self.patch_jump(end_idx);
self.chunk.push_op(OpCode::OpAssertBool);
Ok(())
}
fn compile_is_set(&mut self, node: rnix::types::BinOp) -> EvalResult<()> {
debug_assert!(
matches!(node.operator(), Some(BinOpKind::IsSet)),
"compile_is_set called with wrong operator kind: {:?}",
node.operator(),
);
// Put the attribute set on the stack.
self.compile(node.lhs().unwrap())?;
// If the key is a NODE_SELECT, the check is deeper than one
// level and requires special handling.
//
// Otherwise, the right hand side is the (only) key expression
// itself and can be compiled directly.
let mut next = node.rhs().unwrap();
let mut fragments = vec![];
loop {
if matches!(next.kind(), rnix::SyntaxKind::NODE_SELECT) {
// Keep nesting deeper until we encounter something
// different than `NODE_SELECT` on the left side. This is
// required because `rnix` parses nested keys as select
// expressions, instead of as a key expression.
//
// The parsed tree will nest something like `a.b.c.d.e.f`
// as (((((a, b), c), d), e), f).
fragments.push(next.last_child().unwrap());
next = next.first_child().unwrap();
} else {
self.compile_with_literal_ident(next)?;
for fragment in fragments.into_iter().rev() {
self.chunk.push_op(OpCode::OpAttrOrNotFound);
self.compile_with_literal_ident(fragment)?;
}
self.chunk.push_op(OpCode::OpAttrsIsSet);
break;
}
}
Ok(())
}
/// Compile an `or` expression into a chunk of conditional jumps.
///
/// If at any point during attribute set traversal a key is
/// missing, the `OpAttrOrNotFound` instruction will leave a
/// special sentinel value on the stack.
///
/// After each access, a conditional jump evaluates the top of the
/// stack and short-circuits to the default value if it sees the
/// sentinel.
///
/// Code like `{ a.b = 1; }.a.c or 42` yields this bytecode and
/// runtime stack:
///
/// ```notrust
/// Bytecode Runtime stack
/// ┌────────────────────────────┐ ┌─────────────────────────┐
/// │ ... │ │ ... │
/// │ 5 OP_ATTRS(1) │ → │ 5 [ { a.b = 1; } ] │
/// │ 6 OP_CONSTANT("a") │ → │ 6 [ { a.b = 1; } "a" ] │
/// │ 7 OP_ATTR_OR_NOT_FOUND │ → │ 7 [ { b = 1; } ] │
/// │ 8 JUMP_IF_NOT_FOUND(13) │ → │ 8 [ { b = 1; } ] │
/// │ 9 OP_CONSTANT("C") │ → │ 9 [ { b = 1; } "c" ] │
/// │ 10 OP_ATTR_OR_NOT_FOUND │ → │ 10 [ NOT_FOUND ] │
/// │ 11 JUMP_IF_NOT_FOUND(13) │ → │ 11 [ ] │
/// │ 12 JUMP(14) │ │ .. jumped over │
/// │ 13 CONSTANT(42) │ → │ 12 [ 42 ] │
/// │ 14 ... │ │ .. .... │
/// └────────────────────────────┘ └─────────────────────────┘
/// ```
fn compile_or_default(&mut self, node: rnix::types::OrDefault) -> EvalResult<()> {
let select = node.index().unwrap();
let mut next = select.set().unwrap();
let mut fragments = vec![select.index().unwrap()];
let mut jumps = vec![];
loop {
if matches!(next.kind(), rnix::SyntaxKind::NODE_SELECT) {
fragments.push(next.last_child().unwrap());
next = next.first_child().unwrap();
continue;
} else {
self.compile(next)?;
}
for fragment in fragments.into_iter().rev() {
self.compile_with_literal_ident(fragment)?;
self.chunk.push_op(OpCode::OpAttrOrNotFound);
jumps.push(self.chunk.push_op(OpCode::OpJumpIfNotFound(0)));
}
break;
}
let final_jump = self.chunk.push_op(OpCode::OpJump(0));
for jump in jumps {
self.patch_jump(jump);
}
// Compile the default value expression and patch the final
// jump to point *beyond* it.
self.compile(node.default().unwrap())?;
self.patch_jump(final_jump);
Ok(())
}
// Compile a standard `let ...; in ...` statement.
//
// Unless in a non-standard scope, the encountered values are
// simply pushed on the stack and their indices noted in the
// entries vector.
fn compile_let_in(&mut self, node: rnix::types::LetIn) -> EvalResult<()> {
self.begin_scope();
for inherit in node.inherits() {
match inherit.from() {
// Within a `let` binding, inheriting from the outer
// scope is practically a no-op.
None => {
self.warnings.push(EvalWarning {
node: inherit.node().clone(),
kind: WarningKind::UselessInherit,
});
continue;
}
Some(from) => {
for ident in inherit.idents() {
// TODO: Optimised multi-select instruction?
self.compile(from.inner().unwrap())?;
self.emit_literal_ident(&ident);
self.chunk.push_op(OpCode::OpAttrsSelect);
self.push_local(ident.as_str());
}
}
}
}
for entry in node.entries() {
let key = entry.key().unwrap();
let mut path = normalise_ident_path(key.path())?;
if path.len() != 1 {
todo!("nested bindings in let expressions :(")
}
self.compile(entry.value().unwrap())?;
self.push_local(path.pop().unwrap());
}
// Deal with the body, then clean up the locals afterwards.
self.compile(node.body().unwrap())?;
self.end_scope();
Ok(())
}
// Compile `with` expressions by emitting instructions that
// pop/remove the indices of attribute sets that are implicitly in
// scope through `with` on the "with-stack".
fn compile_with(&mut self, node: rnix::types::With) -> EvalResult<()> {
// TODO: Detect if the namespace is just an identifier, and
// resolve that directly (thus avoiding duplication on the
// stack).
self.compile(node.namespace().unwrap())?;
self.push_phantom();
self.scope.with_stack.push(With {
depth: self.scope.scope_depth,
});
self.chunk
.push_op(OpCode::OpPushWith(self.scope.locals.len() - 1));
self.compile(node.body().unwrap())
}
// Emit the literal string value of an identifier. Required for
// several operations related to attribute sets, where identifiers
// are used as string keys.
fn emit_literal_ident(&mut self, ident: &rnix::types::Ident) {
let idx = self
.chunk
.push_constant(Value::String(ident.as_str().into()));
self.chunk.push_op(OpCode::OpConstant(idx));
}
fn patch_jump(&mut self, idx: CodeIdx) {
let offset = self.chunk.code.len() - 1 - idx.0;
match &mut self.chunk.code[idx.0] {
OpCode::OpJump(n)
| OpCode::OpJumpIfFalse(n)
| OpCode::OpJumpIfTrue(n)
| OpCode::OpJumpIfNotFound(n) => {
*n = offset;
}
op => panic!("attempted to patch unsupported op: {:?}", op),
}
}
fn begin_scope(&mut self) {
self.scope.scope_depth += 1;
}
fn end_scope(&mut self) {
let mut scope = &mut self.scope;
debug_assert!(scope.scope_depth != 0, "can not end top scope");
// If this scope poisoned any builtins or special identifiers,
// they need to be reset.
if scope.poisoned_true == scope.scope_depth {
scope.poisoned_true = 0;
}
if scope.poisoned_false == scope.scope_depth {
scope.poisoned_false = 0;
}
if scope.poisoned_null == scope.scope_depth {
scope.poisoned_null = 0;
}
scope.scope_depth -= 1;
// When ending a scope, all corresponding locals need to be
// removed, but the value of the body needs to remain on the
// stack. This is implemented by a separate instruction.
let mut pops = 0;
// TL;DR - iterate from the back while things belonging to the
// ended scope still exist.
while !scope.locals.is_empty()
&& scope.locals[scope.locals.len() - 1].depth > scope.scope_depth
{
pops += 1;
scope.locals.pop();
}
if pops > 0 {
self.chunk.push_op(OpCode::OpCloseScope(pops));
}
while !scope.with_stack.is_empty()
&& scope.with_stack[scope.with_stack.len() - 1].depth > scope.scope_depth
{
self.chunk.push_op(OpCode::OpPopWith);
scope.with_stack.pop();
}
}
fn push_local<S: Into<String>>(&mut self, name: S) {
// Set up scope poisoning if required.
let name = name.into();
match name.as_str() {
"true" if self.scope.poisoned_true == 0 => {
self.scope.poisoned_true = self.scope.scope_depth
}
"false" if self.scope.poisoned_false == 0 => {
self.scope.poisoned_false = self.scope.scope_depth
}
"null" if self.scope.poisoned_null == 0 => {
self.scope.poisoned_null = self.scope.scope_depth
}
_ => {}
};
self.scope.locals.push(Local {
name: name.into(),
depth: self.scope.scope_depth,
phantom: false,
});
}
fn push_phantom(&mut self) {
self.scope.locals.push(Local {
name: "".into(),
depth: self.scope.scope_depth,
phantom: true,
});
}
fn resolve_local(&mut self, name: &str) -> Option<usize> {
let scope = &self.scope;
for (idx, local) in scope.locals.iter().enumerate().rev() {
if !local.phantom && local.name == name {
return Some(idx);
}
}
None
}
}
/// Convert a single identifier path fragment to a string if possible,
/// or raise an error about the node being dynamic.
fn ident_fragment_to_string(node: rnix::SyntaxNode) -> EvalResult<String> {
match node.kind() {
rnix::SyntaxKind::NODE_IDENT => {
Ok(rnix::types::Ident::cast(node).unwrap().as_str().to_string())
}
rnix::SyntaxKind::NODE_STRING => {
let s = rnix::types::Str::cast(node).unwrap();
let mut parts = s.parts();
if parts.len() == 1 {
if let rnix::value::StrPart::Literal(lit) = parts.pop().unwrap() {
return Ok(lit);
}
}
return Err(Error::DynamicKeyInLet(s.node().clone()));
}
// The dynamic node type is just a wrapper and we recurse to
// its inner node. C++ Nix does not care about the dynamic
// wrapper when determining whether the node itself is
// dynamic, it depends solely on the expression inside (i.e.
// `let ${"a"} = 1; in a` is valid)
rnix::SyntaxKind::NODE_DYNAMIC => {
ident_fragment_to_string(rnix::types::Dynamic::cast(node).unwrap().inner().unwrap())
}
_ => Err(Error::DynamicKeyInLet(node)),
}
}
// Normalises identifier fragments into a single string vector for
// `let`-expressions; fails if fragments requiring dynamic computation
// are encountered.
fn normalise_ident_path<I: Iterator<Item = rnix::SyntaxNode>>(path: I) -> EvalResult<Vec<String>> {
path.map(ident_fragment_to_string).collect()
}
pub fn compile(ast: rnix::AST, location: Option<PathBuf>) -> EvalResult<CompilationResult> {
let mut root_dir = match location {
Some(dir) => Ok(dir),
None => std::env::current_dir().map_err(|e| {
Error::PathResolution(format!("could not determine current directory: {}", e))
}),
}?;
// If the path passed from the caller points to a file, the
// filename itself needs to be truncated as this must point to a
// directory.
if root_dir.is_file() {
root_dir.pop();
}
let mut c = Compiler {
root_dir,
chunk: Chunk::default(),
warnings: vec![],
scope: Default::default(),
};
c.compile(ast.node())?;
Ok(CompilationResult {
chunk: c.chunk,
warnings: c.warnings,
})
}
