about summary refs log tree commit diff
path: root/tvix/eval/src/compiler.rs
diff options
context:
space:
mode:
Diffstat (limited to 'tvix/eval/src/compiler.rs')
-rw-r--r--tvix/eval/src/compiler.rs799
1 files changed, 345 insertions, 454 deletions
diff --git a/tvix/eval/src/compiler.rs b/tvix/eval/src/compiler.rs
index 27e917c54569..dca4eec9f447 100644
--- a/tvix/eval/src/compiler.rs
+++ b/tvix/eval/src/compiler.rs
@@ -14,7 +14,8 @@
 //! mistakes early during development.
 
 use path_clean::PathClean;
-use rnix::types::{BinOpKind, EntryHolder, TokenWrapper, TypedNode, Wrapper};
+use rnix::ast::{self, AstToken, HasEntry};
+use rowan::ast::AstNode;
 use std::path::{Path, PathBuf};
 
 use crate::chunk::Chunk;
@@ -90,164 +91,85 @@ struct Compiler {
 }
 
 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)
-            }
-
-            rnix::SyntaxKind::NODE_ASSERT => {
-                let node = rnix::types::Assert::cast(node).unwrap();
-                self.compile_assert(node)
-            }
-
-            kind => panic!("visiting unsupported node: {:?}", kind),
+    fn compile(&mut self, expr: ast::Expr) -> EvalResult<()> {
+        match expr {
+            ast::Expr::Literal(literal) => self.compile_literal(literal),
+            ast::Expr::Path(path) => self.compile_path(path),
+            ast::Expr::Str(s) => self.compile_str(s),
+            ast::Expr::UnaryOp(op) => self.compile_unary_op(op),
+            ast::Expr::BinOp(op) => self.compile_binop(op),
+            ast::Expr::HasAttr(has_attr) => self.compile_has_attr(has_attr),
+            ast::Expr::List(list) => self.compile_list(list),
+            ast::Expr::AttrSet(attrs) => self.compile_attr_set(attrs),
+            ast::Expr::Select(select) => self.compile_select(select),
+            ast::Expr::Assert(assert) => self.compile_assert(assert),
+            ast::Expr::IfElse(if_else) => self.compile_if_else(if_else),
+            ast::Expr::LetIn(let_in) => self.compile_let_in(let_in),
+            ast::Expr::Ident(ident) => self.compile_ident(ident),
+            ast::Expr::With(with) => self.compile_with(with),
+
+            // Parenthesized expressions are simply unwrapped, leaving
+            // their value on the stack.
+            ast::Expr::Paren(paren) => self.compile(paren.expr().unwrap()),
+
+            ast::Expr::LegacyLet(_) => todo!("legacy let"),
+            ast::Expr::Lambda(_) => todo!("function definition"),
+            ast::Expr::Apply(_) => todo!("function application"),
+
+            ast::Expr::Root(_) => unreachable!("there cannot be more than one root"),
+            ast::Expr::Error(_) => unreachable!("compile is only called on validated trees"),
         }
     }
 
-    /// 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));
+    fn compile_literal(&mut self, node: ast::Literal) -> EvalResult<()> {
+        match node.kind() {
+            ast::LiteralKind::Float(f) => {
+                let idx = self.chunk.push_constant(Value::Float(f.value().unwrap()));
                 self.chunk.push_op(OpCode::OpConstant(idx));
                 Ok(())
             }
 
-            rnix::NixValue::Integer(i) => {
-                let idx = self.chunk.push_constant(Value::Integer(i));
+            ast::LiteralKind::Integer(i) => {
+                let idx = self.chunk.push_constant(Value::Integer(i.value().unwrap()));
                 self.chunk.push_op(OpCode::OpConstant(idx));
                 Ok(())
             }
-
-            // These nodes are yielded by literal URL values.
-            rnix::NixValue::String(s) => {
+            ast::LiteralKind::Uri(u) => {
                 self.warnings.push(EvalWarning {
-                    node: node.node().clone(),
+                    node: node.syntax().clone(),
                     kind: WarningKind::DeprecatedLiteralURL,
                 });
 
-                let idx = self.chunk.push_constant(Value::String(s.into()));
+                let idx = self
+                    .chunk
+                    .push_constant(Value::String(u.syntax().text().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"),
+    fn compile_path(&mut self, node: ast::Path) -> EvalResult<()> {
+        // TODO(tazjin): placeholder implementation while waiting for
+        // https://github.com/nix-community/rnix-parser/pull/96
+
+        let raw_path = node.to_string();
+        let path = if raw_path.starts_with('/') {
+            Path::new(&raw_path).to_owned()
+        } else if raw_path.starts_with('~') {
+            let mut buf = dirs::home_dir().ok_or_else(|| {
+                Error::PathResolution("failed to determine home directory".into())
+            })?;
+
+            buf.push(&raw_path);
+            buf
+        } else if raw_path.starts_with('.') {
+            let mut buf = self.root_dir.clone();
+            buf.push(&raw_path);
+            buf
+        } else {
+            // TODO: decide what to do with findFile
+            todo!("other path types (e.g. <...> lookups) not yet implemented")
         };
 
         // TODO: Use https://github.com/rust-lang/rfcs/issues/2208
@@ -259,23 +181,23 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_string(&mut self, string: rnix::types::Str) -> EvalResult<()> {
+    fn compile_str(&mut self, node: ast::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() {
+        for part in node.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)?,
+                ast::StrPart::Interpolation(node) => self.compile(node.expr().unwrap())?,
 
-                rnix::StrPart::Literal(lit) => {
+                ast::StrPart::Literal(lit) => {
                     let idx = self.chunk.push_constant(Value::String(lit.into()));
                     self.chunk.push_op(OpCode::OpConstant(idx));
                 }
@@ -289,20 +211,36 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_binop(&mut self, op: rnix::types::BinOp) -> EvalResult<()> {
+    fn compile_unary_op(&mut self, op: ast::UnaryOp) -> EvalResult<()> {
+        self.compile(op.expr().unwrap())?;
+
+        let opcode = match op.operator().unwrap() {
+            ast::UnaryOpKind::Invert => OpCode::OpInvert,
+            ast::UnaryOpKind::Negate => OpCode::OpNegate,
+        };
+
+        self.chunk.push_op(opcode);
+        Ok(())
+    }
+
+    fn compile_binop(&mut self, op: ast::BinOp) -> EvalResult<()> {
+        use ast::BinOpKind;
+
         // 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),
-
             _ => {}
         };
 
+        // For all other operators, the two values need to be left on
+        // the stack in the correct order before pushing the
+        // instruction for the operation itself.
         self.compile(op.lhs().unwrap())?;
         self.compile(op.rhs().unwrap())?;
 
@@ -325,7 +263,7 @@ impl Compiler {
             }
 
             // Handled by separate branch above.
-            BinOpKind::And | BinOpKind::Implication | BinOpKind::Or | BinOpKind::IsSet => {
+            BinOpKind::And | BinOpKind::Implication | BinOpKind::Or => {
                 unreachable!()
             }
         };
@@ -333,58 +271,125 @@ impl Compiler {
         Ok(())
     }
 
-    fn compile_unary_op(&mut self, op: rnix::types::UnaryOp) -> EvalResult<()> {
-        self.compile(op.value().unwrap())?;
+    fn compile_and(&mut self, node: ast::BinOp) -> EvalResult<()> {
+        debug_assert!(
+            matches!(node.operator(), Some(ast::BinOpKind::And)),
+            "compile_and called with wrong operator kind: {:?}",
+            node.operator(),
+        );
 
-        use rnix::types::UnaryOpKind;
-        let opcode = match op.operator() {
-            UnaryOpKind::Invert => OpCode::OpInvert,
-            UnaryOpKind::Negate => OpCode::OpNegate,
-        };
+        // 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);
 
-        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),
+    fn compile_or(&mut self, node: ast::BinOp) -> EvalResult<()> {
+        debug_assert!(
+            matches!(node.operator(), Some(ast::BinOpKind::Or)),
+            "compile_or called with wrong operator kind: {:?}",
+            node.operator(),
+        );
 
-            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));
-                        }
+        // Leave left-hand side value on the stack
+        self.compile(node.lhs().unwrap())?;
 
-                        // 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)
-                    }
-                }
+        // 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: ast::BinOp) -> EvalResult<()> {
+        debug_assert!(
+            matches!(node.operator(), Some(ast::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_has_attr(&mut self, node: ast::HasAttr) -> EvalResult<()> {
+        // Put the attribute set on the stack.
+        self.compile(node.expr().unwrap())?;
+        let mut count = 0;
+
+        // Push all path fragments with an operation for fetching the
+        // next nested element, for all fragments except the last one.
+        for fragment in node.attrpath().unwrap().attrs() {
+            if count > 0 {
+                self.chunk.push_op(OpCode::OpAttrOrNotFound);
             }
-        };
+            count += 1;
+            self.compile_attr(fragment)?;
+        }
+
+        // After the last fragment, emit the actual instruction that
+        // leaves a boolean on the stack.
+        self.chunk.push_op(OpCode::OpAttrsIsSet);
 
         Ok(())
     }
 
+    fn compile_attr(&mut self, node: ast::Attr) -> EvalResult<()> {
+        match node {
+            ast::Attr::Dynamic(dynamic) => self.compile(dynamic.expr().unwrap()),
+            ast::Attr::Str(s) => self.compile_str(s),
+            ast::Attr::Ident(ident) => {
+                self.emit_literal_ident(&ident);
+                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: ast::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 attribute set literals into equivalent bytecode.
     //
     // This is complicated by a number of features specific to Nix
@@ -393,8 +398,8 @@ impl Compiler {
     // 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() {
+    fn compile_attr_set(&mut self, node: ast::AttrSet) -> EvalResult<()> {
+        if node.rec_token().is_some() {
             todo!("recursive attribute sets are not yet implemented")
         }
 
@@ -420,7 +425,7 @@ impl Compiler {
                         // instruction followed by a merge, rather
                         // than pushing/popping the same attrs
                         // potentially a lot of times.
-                        self.compile(from.inner().unwrap())?;
+                        self.compile(from.expr().unwrap())?;
                         self.emit_literal_ident(&ident);
                         self.chunk.push_op(OpCode::OpAttrsSelect);
                     }
@@ -431,7 +436,7 @@ impl Compiler {
                         count += 1;
                         self.emit_literal_ident(&ident);
 
-                        match self.resolve_local(ident.as_str()) {
+                        match self.resolve_local(ident.ident_token().unwrap().text()) {
                             Some(idx) => self.chunk.push_op(OpCode::OpGetLocal(idx)),
                             None => return Err(Error::UnknownStaticVariable(ident)),
                         };
@@ -440,7 +445,7 @@ impl Compiler {
             }
         }
 
-        for kv in node.entries() {
+        for kv in node.attrpath_values() {
             count += 1;
 
             // Because attribute set literals can contain nested keys,
@@ -449,26 +454,9 @@ impl Compiler {
             // runtime value representing the attribute path is
             // emitted.
             let mut key_count = 0;
-            for fragment in kv.key().unwrap().path() {
+            for fragment in kv.attrpath().unwrap().attrs() {
                 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)?,
-                }
+                self.compile_attr(fragment)?;
             }
 
             // We're done with the key if there was only one fragment,
@@ -488,175 +476,24 @@ impl Compiler {
         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);
+    fn compile_select(&mut self, node: ast::Select) -> EvalResult<()> {
+        let set = node.expr().unwrap();
+        let path = node.attrpath().unwrap();
 
-        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)?;
+        if node.or_token().is_some() {
+            return self.compile_select_or(set, path, node.default_expr().unwrap());
         }
 
-        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())?;
+        // Push the set onto the stack
+        self.compile(set)?;
 
-        // If the key is a NODE_SELECT, the check is deeper than one
-        // level and requires special handling.
+        // Compile each key fragment and emit access instructions.
         //
-        // 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;
-            }
+        // TODO: multi-select instruction to avoid re-pushing attrs on
+        // nested selects.
+        for fragment in path.attrs() {
+            self.compile_attr(fragment)?;
+            self.chunk.push_op(OpCode::OpAttrsSelect);
         }
 
         Ok(())
@@ -691,50 +528,81 @@ impl Compiler {
     ///  │ 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()];
+    fn compile_select_or(
+        &mut self,
+        set: ast::Expr,
+        path: ast::Attrpath,
+        default: ast::Expr,
+    ) -> EvalResult<()> {
+        self.compile(set)?;
         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;
+        for fragment in path.attrs() {
+            self.compile_attr(fragment)?;
+            self.chunk.push_op(OpCode::OpAttrOrNotFound);
+            jumps.push(self.chunk.push_op(OpCode::OpJumpIfNotFound(0)));
         }
 
         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.compile(default)?;
         self.patch_jump(final_jump);
 
         Ok(())
     }
 
+    fn compile_assert(&mut self, node: ast::Assert) -> EvalResult<()> {
+        // Compile the assertion condition to leave its value on the stack.
+        self.compile(node.condition().unwrap())?;
+        self.chunk.push_op(OpCode::OpAssert);
+
+        // The runtime will abort evaluation at this point if the
+        // assertion failed, if not the body simply continues on like
+        // normal.
+        self.compile(node.body().unwrap())
+    }
+
+    // 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: ast::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(())
+    }
+
     // 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<()> {
+    fn compile_let_in(&mut self, node: ast::LetIn) -> EvalResult<()> {
         self.begin_scope();
 
         for inherit in node.inherits() {
@@ -743,7 +611,7 @@ impl Compiler {
                 // scope is practically a no-op.
                 None => {
                     self.warnings.push(EvalWarning {
-                        node: inherit.node().clone(),
+                        node: inherit.syntax().clone(),
                         kind: WarningKind::UselessInherit,
                     });
 
@@ -752,19 +620,17 @@ impl Compiler {
 
                 Some(from) => {
                     for ident in inherit.idents() {
-                        // TODO: Optimised multi-select instruction?
-                        self.compile(from.inner().unwrap())?;
+                        self.compile(from.expr().unwrap())?;
                         self.emit_literal_ident(&ident);
                         self.chunk.push_op(OpCode::OpAttrsSelect);
-                        self.declare_local(ident.as_str());
+                        self.declare_local(ident.ident_token().unwrap().text());
                     }
                 }
             }
         }
 
-        for entry in node.entries() {
-            let key = entry.key().unwrap();
-            let mut path = normalise_ident_path(key.path())?;
+        for entry in node.attrpath_values() {
+            let mut path = normalise_ident_path(entry.attrpath().unwrap().attrs())?;
 
             if path.len() != 1 {
                 todo!("nested bindings in let expressions :(")
@@ -780,10 +646,49 @@ impl Compiler {
         Ok(())
     }
 
+    fn compile_ident(&mut self, node: ast::Ident) -> EvalResult<()> {
+        match node.ident_token().unwrap().text() {
+            // 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 `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<()> {
+    fn compile_with(&mut self, node: ast::With) -> EvalResult<()> {
         // TODO: Detect if the namespace is just an identifier, and
         // resolve that directly (thus avoiding duplication on the
         // stack).
@@ -800,24 +705,14 @@ impl Compiler {
         self.compile(node.body().unwrap())
     }
 
-    fn compile_assert(&mut self, node: rnix::types::Assert) -> EvalResult<()> {
-        // Compile the assertion condition to leave its value on the stack.
-        self.compile(node.condition().unwrap())?;
-        self.chunk.push_op(OpCode::OpAssert);
-
-        // The runtime will abort evaluation at this point if the
-        // assertion failed, if not the body simply continues on like
-        // normal.
-        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) {
+    /// 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: &ast::Ident) {
         let idx = self
             .chunk
-            .push_constant(Value::String(ident.as_str().into()));
+            .push_constant(Value::String(ident.ident_token().unwrap().text().into()));
+
         self.chunk.push_op(OpCode::OpConstant(idx));
     }
 
@@ -934,48 +829,44 @@ impl Compiler {
     }
 }
 
-/// 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()));
+/// Convert a non-dynamic string expression to a string if possible,
+/// or raise an error.
+fn expr_str_to_string(expr: ast::Str) -> EvalResult<String> {
+    if expr.parts().len() == 1 {
+        if let ast::StrPart::Literal(s) = expr.parts().pop().unwrap() {
+            return Ok(s);
         }
+    }
 
-        // 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())
-        }
+    return Err(Error::DynamicKeyInLet(expr.syntax().clone()));
+}
 
-        _ => Err(Error::DynamicKeyInLet(node)),
+/// Convert a single identifier path fragment to a string if possible,
+/// or raise an error about the node being dynamic.
+fn attr_to_string(node: ast::Attr) -> EvalResult<String> {
+    match node {
+        ast::Attr::Ident(ident) => Ok(ident.ident_token().unwrap().text().into()),
+        ast::Attr::Str(s) => expr_str_to_string(s),
+
+        // The dynamic node type is just a wrapper. 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).
+        ast::Attr::Dynamic(ref dynamic) => match dynamic.expr().unwrap() {
+            ast::Expr::Str(s) => expr_str_to_string(s),
+            _ => Err(Error::DynamicKeyInLet(node.syntax().clone())),
+        },
     }
 }
 
 // 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()
+fn normalise_ident_path<I: Iterator<Item = ast::Attr>>(path: I) -> EvalResult<Vec<String>> {
+    path.map(attr_to_string).collect()
 }
 
-pub fn compile(ast: rnix::AST, location: Option<PathBuf>) -> EvalResult<CompilationResult> {
+pub fn compile(expr: ast::Expr, location: Option<PathBuf>) -> EvalResult<CompilationResult> {
     let mut root_dir = match location {
         Some(dir) => Ok(dir),
         None => std::env::current_dir().map_err(|e| {
@@ -997,7 +888,7 @@ pub fn compile(ast: rnix::AST, location: Option<PathBuf>) -> EvalResult<Compilat
         scope: Default::default(),
     };
 
-    c.compile(ast.node())?;
+    c.compile(expr)?;
 
     Ok(CompilationResult {
         chunk: c.chunk,