fix: infinite recursion on perl (WIP)

.gitignore

@@ -5,8 +5,3 @@ target/
 # Profiling
 flamegraph*.svg
 perf.data*
-profile.json.gz
-prof.json
-*.cpuprofile
-*.cpuprofile.gz
-*v8.log*

.lazy.lua

@@ -3,19 +3,13 @@ vim.lsp.config("biome", {
     on_dir(vim.fn.getcwd())
   end
 })
-vim.lsp.config("eslint", {
-  settings = {
-    eslint = {
-      options = {
-        configFile = "./nix-js/runtime-ts/eslint.config.mts"
-      }
-    }
-  }
-})
 vim.lsp.config("rust_analyzer", {
   settings = {
     ["rust-analyzer"] = {
       cargo = {
+        features = {
+          "daemon"
+        }
       }
     }
   }

Cargo.toml

@@ -1,10 +1,6 @@
 [workspace]
 resolver = "3"
 members = [
-    "fix",
+    "nix-js",
-    "boxing",
+    "nix-js-macros"
 ]
-
-[profile.profiling]
-inherits = "release"
-debug = true

Justfile

@@ -1,31 +1,15 @@
 [no-exit-message]
 @repl:
-  cargo run -- repl
+  RUST_LOG=none,nix_js=debug cargo run --bin repl
 
 [no-exit-message]
 @eval expr:
-  cargo run -- eval --expr '{{expr}}'
+  RUST_LOG=none,nix_js=debug cargo run --bin eval -- '{{expr}}'
 
 [no-exit-message]
 @replr:
-  cargo run --release -- repl
+  RUST_LOG=info cargo run --bin repl --release
 
 [no-exit-message]
 @evalr expr:
-  cargo run --release -- eval --expr '{{expr}}'
+  RUST_LOG=silent cargo run --bin eval --release -- '{{expr}}'
-
-[no-exit-message]
-@repli:
-  cargo run --release --features inspector -- --inspect-brk 127.0.0.1:9229 repl
-
-[no-exit-message]
-@evali expr:
-  cargo run --release --features inspector -- --inspect-brk 127.0.0.1:9229 eval --expr '{{expr}}'
-
-[no-exit-message]
-@replp:
-  cargo run --release --features prof -- repl
-
-[no-exit-message]
-@evalp expr:
-  cargo run --release --features prof -- eval --expr '{{expr}}'

biome.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://biomejs.dev/schemas/2.3.14/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.3.9/schema.json",
   "vcs": {
     "enabled": true,
     "clientKind": "git",
@@ -20,37 +20,10 @@
   "linter": {
     "rules": {
       "style": {
-        "useNamingConvention": {
+        "useNamingConvention": "warn"
-          "level": "warn",
-          "options": {
-            "strictCase": false,
-            "conventions": [
-              {
-                "selector": { "kind": "objectLiteralProperty" },
-                "formats": ["camelCase", "PascalCase", "CONSTANT_CASE"]
-              },
-              {
-                "selector": { "kind": "typeProperty" },
-                "formats": ["camelCase", "snake_case"]
-              }
-            ]
-          }
-        }
       }
     }
   },
-  "overrides": [
-    {
-      "includes": ["**/global.d.ts"],
-      "linter": {
-        "rules": {
-          "style": {
-            "useNamingConvention": "off"
-          }
-        }
-      }
-    }
-  ],
   "javascript": {
     "formatter": {
       "arrowParentheses": "always",

boxing/Cargo.toml

@@ -1,8 +0,0 @@
-[package]
-name = "boxing"
-version = "0.1.3"
-edition = "2021"
-description = "NaN-boxing primitives (local fork with bool fix)"
-
-[dependencies]
-sptr = "0.3"

boxing/src/lib.rs

@@ -1,2 +0,0 @@
-pub mod nan;
-mod utils;

boxing/src/nan.rs

@@ -1,7 +0,0 @@
-pub mod raw;
-
-pub use raw::RawBox;
-
-const SIGN_MASK: u64 = 0x7FFF_FFFF_FFFF_FFFF;
-const QUIET_NAN: u64 = 0x7FF8_0000_0000_0000;
-const NEG_QUIET_NAN: u64 = 0xFFF8_0000_0000_0000;

boxing/src/nan/raw.rs

@@ -1,471 +0,0 @@
-use super::{NEG_QUIET_NAN, QUIET_NAN, SIGN_MASK};
-use crate::utils::ArrayExt;
-use sptr::Strict;
-use std::fmt;
-use std::mem::ManuallyDrop;
-use std::num::NonZeroU8;
-
-pub trait RawStore: Sized {
-    fn to_val(self, value: &mut Value);
-    fn from_val(value: &Value) -> Self;
-}
-
-impl RawStore for [u8; 6] {
-    #[inline]
-    fn to_val(self, value: &mut Value) {
-        value.set_data(self);
-    }
-
-    #[inline]
-    fn from_val(value: &Value) -> Self {
-        *value.data()
-    }
-}
-
-impl RawStore for bool {
-    #[inline]
-    fn to_val(self, value: &mut Value) {
-        value.set_data([u8::from(self)].truncate_to());
-    }
-
-    #[inline]
-    fn from_val(value: &Value) -> Self {
-        value.data()[0] == 1
-    }
-}
-
-macro_rules! int_store {
-    ($ty:ty) => {
-        impl RawStore for $ty {
-            #[inline]
-            fn to_val(self, value: &mut Value) {
-                let bytes = self.to_ne_bytes();
-                value.set_data(bytes.truncate_to());
-            }
-
-            #[inline]
-            fn from_val(value: &Value) -> Self {
-                <$ty>::from_ne_bytes(value.data().truncate_to())
-            }
-        }
-    };
-}
-
-int_store!(u8);
-int_store!(u16);
-int_store!(u32);
-
-int_store!(i8);
-int_store!(i16);
-int_store!(i32);
-
-fn store_ptr<P: Strict + Copy>(value: &mut Value, ptr: P) {
-    #[cfg(target_pointer_width = "64")]
-    {
-        assert!(
-            ptr.addr() <= 0x0000_FFFF_FFFF_FFFF,
-            "Pointer too large to store in NaN box"
-        );
-
-        let val = (unsafe { value.whole_mut() } as *mut [u8; 8]).cast::<P>();
-
-        let ptr = Strict::map_addr(ptr, |addr| {
-            addr | (usize::from(value.header().into_raw()) << 48)
-        });
-
-        unsafe { val.write(ptr) };
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    {
-        let _ = (value, ptr);
-        unimplemented!("32-bit pointer storage not supported");
-    }
-}
-
-fn load_ptr<P: Strict>(value: &Value) -> P {
-    #[cfg(target_pointer_width = "64")]
-    {
-        let val = (unsafe { value.whole() } as *const [u8; 8]).cast::<P>();
-        let ptr = unsafe { val.read() };
-        Strict::map_addr(ptr, |addr| addr & 0x0000_FFFF_FFFF_FFFF)
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    {
-        let _ = value;
-        unimplemented!("32-bit pointer storage not supported");
-    }
-}
-
-impl<T> RawStore for *const T {
-    fn to_val(self, value: &mut Value) {
-        store_ptr::<*const T>(value, self);
-    }
-
-    fn from_val(value: &Value) -> Self {
-        load_ptr::<*const T>(value)
-    }
-}
-
-impl<T> RawStore for *mut T {
-    fn to_val(self, value: &mut Value) {
-        store_ptr::<*mut T>(value, self);
-    }
-
-    fn from_val(value: &Value) -> Self {
-        load_ptr::<*mut T>(value)
-    }
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-enum TagVal {
-    _P1,
-    _P2,
-    _P3,
-    _P4,
-    _P5,
-    _P6,
-    _P7,
-
-    _N1,
-    _N2,
-    _N3,
-    _N4,
-    _N5,
-    _N6,
-    _N7,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-pub struct RawTag(TagVal);
-
-impl RawTag {
-    #[inline]
-    #[must_use]
-    pub fn new(neg: bool, val: NonZeroU8) -> RawTag {
-        unsafe { Self::new_unchecked(neg, val.get() & 0x07) }
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn new_checked(neg: bool, val: u8) -> Option<RawTag> {
-        Some(RawTag(match (neg, val) {
-            (false, 1) => TagVal::_P1,
-            (false, 2) => TagVal::_P2,
-            (false, 3) => TagVal::_P3,
-            (false, 4) => TagVal::_P4,
-            (false, 5) => TagVal::_P5,
-            (false, 6) => TagVal::_P6,
-            (false, 7) => TagVal::_P7,
-
-            (true, 1) => TagVal::_N1,
-            (true, 2) => TagVal::_N2,
-            (true, 3) => TagVal::_N3,
-            (true, 4) => TagVal::_N4,
-            (true, 5) => TagVal::_N5,
-            (true, 6) => TagVal::_N6,
-            (true, 7) => TagVal::_N7,
-
-            _ => return None,
-        }))
-    }
-
-    /// # Safety
-    ///
-    /// `val` must be in the range `1..8`
-    #[inline]
-    #[must_use]
-    pub unsafe fn new_unchecked(neg: bool, val: u8) -> RawTag {
-        RawTag(match (neg, val) {
-            (false, 1) => TagVal::_P1,
-            (false, 2) => TagVal::_P2,
-            (false, 3) => TagVal::_P3,
-            (false, 4) => TagVal::_P4,
-            (false, 5) => TagVal::_P5,
-            (false, 6) => TagVal::_P6,
-            (false, 7) => TagVal::_P7,
-
-            (true, 1) => TagVal::_N1,
-            (true, 2) => TagVal::_N2,
-            (true, 3) => TagVal::_N3,
-            (true, 4) => TagVal::_N4,
-            (true, 5) => TagVal::_N5,
-            (true, 6) => TagVal::_N6,
-            (true, 7) => TagVal::_N7,
-
-            _ => unsafe { core::hint::unreachable_unchecked() },
-        })
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn is_neg(self) -> bool {
-        matches!(self.0, |TagVal::_N1| TagVal::_N2
-            | TagVal::_N3
-            | TagVal::_N4
-            | TagVal::_N5
-            | TagVal::_N6
-            | TagVal::_N7)
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn val(self) -> NonZeroU8 {
-        match self.0 {
-            TagVal::_P1 | TagVal::_N1 => NonZeroU8::MIN,
-            TagVal::_P2 | TagVal::_N2 => NonZeroU8::MIN.saturating_add(1),
-            TagVal::_P3 | TagVal::_N3 => NonZeroU8::MIN.saturating_add(2),
-            TagVal::_P4 | TagVal::_N4 => NonZeroU8::MIN.saturating_add(3),
-            TagVal::_P5 | TagVal::_N5 => NonZeroU8::MIN.saturating_add(4),
-            TagVal::_P6 | TagVal::_N6 => NonZeroU8::MIN.saturating_add(5),
-            TagVal::_P7 | TagVal::_N7 => NonZeroU8::MIN.saturating_add(6),
-        }
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn neg_val(self) -> (bool, u8) {
-        match self.0 {
-            TagVal::_P1 => (false, 1),
-            TagVal::_P2 => (false, 2),
-            TagVal::_P3 => (false, 3),
-            TagVal::_P4 => (false, 4),
-            TagVal::_P5 => (false, 5),
-            TagVal::_P6 => (false, 6),
-            TagVal::_P7 => (false, 7),
-            TagVal::_N1 => (true, 1),
-            TagVal::_N2 => (true, 2),
-            TagVal::_N3 => (true, 3),
-            TagVal::_N4 => (true, 4),
-            TagVal::_N5 => (true, 5),
-            TagVal::_N6 => (true, 6),
-            TagVal::_N7 => (true, 7),
-        }
-    }
-}
-
-impl fmt::Debug for RawTag {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("RawTag")
-            .field("neg", &self.is_neg())
-            .field("val", &self.val())
-            .finish()
-    }
-}
-
-#[derive(Copy, Clone, Debug, PartialEq)]
-#[repr(transparent)]
-struct Header(u16);
-
-impl Header {
-    #[inline]
-    fn new(tag: RawTag) -> Header {
-        let (neg, val) = tag.neg_val();
-        Header(0x7FF8 | (u16::from(neg) << 15) | u16::from(val))
-    }
-
-    #[inline]
-    fn tag(self) -> RawTag {
-        unsafe { RawTag::new_unchecked(self.get_sign(), self.get_tag()) }
-    }
-
-    #[inline]
-    fn get_sign(self) -> bool {
-        self.0 & 0x8000 != 0
-    }
-
-    #[inline]
-    fn get_tag(self) -> u8 {
-        (self.0 & 0x0007) as u8
-    }
-
-    #[inline]
-    fn into_raw(self) -> u16 {
-        self.0
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[repr(C, align(8))]
-pub struct Value {
-    #[cfg(target_endian = "big")]
-    header: Header,
-    data: [u8; 6],
-    #[cfg(target_endian = "little")]
-    header: Header,
-}
-
-impl Value {
-    #[inline]
-    pub fn new(tag: RawTag, data: [u8; 6]) -> Value {
-        Value {
-            header: Header::new(tag),
-            data,
-        }
-    }
-
-    #[inline]
-    pub fn empty(tag: RawTag) -> Value {
-        Value::new(tag, [0; 6])
-    }
-
-    pub fn store<T: RawStore>(tag: RawTag, val: T) -> Value {
-        let mut v = Value::new(tag, [0; 6]);
-        T::to_val(val, &mut v);
-        v
-    }
-
-    pub fn load<T: RawStore>(self) -> T {
-        T::from_val(&self)
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn tag(&self) -> RawTag {
-        self.header.tag()
-    }
-
-    #[inline]
-    fn header(&self) -> &Header {
-        &self.header
-    }
-
-    #[inline]
-    pub fn set_data(&mut self, val: [u8; 6]) {
-        self.data = val;
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn data(&self) -> &[u8; 6] {
-        &self.data
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn data_mut(&mut self) -> &mut [u8; 6] {
-        &mut self.data
-    }
-
-    #[inline]
-    #[must_use]
-    pub unsafe fn whole(&self) -> &[u8; 8] {
-        let ptr = (self as *const Value).cast::<[u8; 8]>();
-        unsafe { &*ptr }
-    }
-
-    #[inline]
-    #[must_use]
-    pub unsafe fn whole_mut(&mut self) -> &mut [u8; 8] {
-        let ptr = (self as *mut Value).cast::<[u8; 8]>();
-        unsafe { &mut *ptr }
-    }
-}
-
-#[repr(C)]
-pub union RawBox {
-    float: f64,
-    value: ManuallyDrop<Value>,
-    bits: u64,
-    #[cfg(target_pointer_width = "64")]
-    ptr: *const (),
-    #[cfg(target_pointer_width = "32")]
-    ptr: (u32, *const ()),
-}
-
-impl RawBox {
-    #[inline]
-    #[must_use]
-    pub fn from_float(val: f64) -> RawBox {
-        match (val.is_nan(), val.is_sign_positive()) {
-            (true, true) => RawBox {
-                float: f64::from_bits(QUIET_NAN),
-            },
-            (true, false) => RawBox {
-                float: f64::from_bits(NEG_QUIET_NAN),
-            },
-            (false, _) => RawBox { float: val },
-        }
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn from_value(value: Value) -> RawBox {
-        RawBox {
-            value: ManuallyDrop::new(value),
-        }
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn tag(&self) -> Option<RawTag> {
-        if self.is_value() {
-            Some(unsafe { self.value.tag() })
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn is_float(&self) -> bool {
-        (unsafe { !self.float.is_nan() } || unsafe { self.bits & SIGN_MASK == QUIET_NAN })
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn is_value(&self) -> bool {
-        (unsafe { self.float.is_nan() } && unsafe { self.bits & SIGN_MASK != QUIET_NAN })
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn float(&self) -> Option<&f64> {
-        if self.is_float() {
-            Some(unsafe { &self.float })
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn value(&self) -> Option<&Value> {
-        if self.is_value() {
-            Some(unsafe { &self.value })
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub fn into_float_unchecked(self) -> f64 {
-        unsafe { self.float }
-    }
-}
-
-impl Clone for RawBox {
-    #[inline]
-    fn clone(&self) -> Self {
-        RawBox {
-            ptr: unsafe { self.ptr },
-        }
-    }
-}
-
-impl fmt::Debug for RawBox {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.float() {
-            Some(val) => f.debug_tuple("RawBox::Float").field(val).finish(),
-            None => {
-                let val = self.value().expect("RawBox is neither float nor value");
-
-                f.debug_struct("RawBox::Data")
-                    .field("tag", &val.tag())
-                    .field("data", val.data())
-                    .finish()
-            }
-        }
-    }
-}

boxing/src/utils.rs

@@ -1,16 +0,0 @@
-pub trait ArrayExt<const LEN: usize> {
-    type Elem;
-
-    fn truncate_to<const M: usize>(self) -> [Self::Elem; M];
-}
-
-impl<T: Default + Copy, const N: usize> ArrayExt<N> for [T; N] {
-    type Elem = T;
-
-    fn truncate_to<const M: usize>(self) -> [Self::Elem; M] {
-        let copy_len = usize::min(N, M);
-        let mut out = [T::default(); M];
-        out[0..copy_len].copy_from_slice(&self[0..copy_len]);
-        out
-    }
-}

default.nix

@@ -9,7 +9,6 @@ let
   flake = (
     import flake-compat {
       src = ./.;
-      copySourceTreeToStore = false;
     }
   );
 in

fix/Cargo.toml

@@ -1,106 +0,0 @@
-[package]
-name = "fix"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-mimalloc = "0.1"
-
-tokio = { version = "1.41", features = [
-    "rt-multi-thread",
-    "sync",
-    "net",
-    "io-util",
-] }
-nix-compat = { git = "https://git.snix.dev/snix/snix.git", version = "0.1.0", features = [
-    "wire",
-    "async",
-] }
-
-# REPL
-anyhow = "1.0"
-rustyline = "17.0"
-
-# CLI
-clap = { version = "4", features = ["derive"] }
-
-# Logging
-tracing = "0.1"
-tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-
-derive_more = { version = "2", features = ["full"] }
-thiserror = "2"
-miette = { version = "7.4", features = ["fancy"] }
-
-hashbrown = "0.16"
-string-interner = "0.19"
-bumpalo = { version = "3.20", features = [
-    "allocator-api2",
-    "boxed",
-    "collections",
-] }
-
-rust-embed = "8.11"
-
-itertools = "0.14"
-
-regex = "1.11"
-
-nix-nar = "0.3"
-sha2 = "0.10"
-sha1 = "0.10"
-md5 = "0.8"
-hex = "0.4"
-
-base64 = "0.22"
-
-reqwest = { version = "0.13", features = [
-    "blocking",
-    "rustls",
-], default-features = false }
-tar = "0.4"
-flate2 = "1.0"
-xz2 = "0.1"
-bzip2 = "0.6"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-# spec 1.0.0
-toml = "=0.9.9"
-dirs = "6.0"
-tempfile = "3.24"
-rusqlite = { version = "0.38", features = ["bundled"] }
-
-rnix = "0.14"
-rowan = "0.16"
-
-ere = "0.2.4"
-num_enum = "0.7.5"
-tap = "1.0.1"
-
-ghost-cell = "0.2"
-colored = "3.1"
-boxing = { path = "../boxing" }
-sealed = "0.6"
-small-map = "0.1"
-smallvec = "1.15"
-
-[dependencies.gc-arena]
-git = "https://github.com/kyren/gc-arena"
-rev = "75671ae03f53718357b741ed4027560f14e90836"
-features = ["allocator-api2", "hashbrown", "smallvec"]
-
-[dev-dependencies]
-criterion = { version = "0.8", features = ["html_reports"] }
-test-log = { version = "0.2", features = ["trace"] }
-
-[[bench]]
-name = "basic_ops"
-harness = false
-
-[[bench]]
-name = "builtins"
-harness = false
-
-[[bench]]
-name = "thunk_scope"
-harness = false

fix/benches/utils.rs

@@ -1,18 +0,0 @@
-#![allow(dead_code)]
-
-use fix::error::{Result, Source};
-use fix::runtime::Runtime;
-use fix::value::Value;
-
-pub fn eval(expr: &str) -> Value {
-    Runtime::new()
-        .unwrap()
-        .eval(Source::new_eval(expr.into()).unwrap())
-        .unwrap()
-}
-
-pub fn eval_result(expr: &str) -> Result<Value> {
-    Runtime::new()
-        .unwrap()
-        .eval(Source::new_eval(expr.into()).unwrap())
-}

fix/src/codegen.rs

@@ -1,867 +0,0 @@
-use std::ops::Deref;
-
-use gc_arena::Collect;
-use hashbrown::HashMap;
-use num_enum::TryFromPrimitive;
-use rnix::TextRange;
-use string_interner::Symbol as _;
-
-use crate::ir::{ArgId, Attr, BinOpKind, Ir, Param, RawIrRef, StringId, ThunkId, UnOpKind};
-
-pub(crate) struct InstructionPtr(pub usize);
-
-#[derive(Collect)]
-#[collect(require_static)]
-pub struct Bytecode {
-    pub code: Box<[u8]>,
-    pub current_dir: String,
-}
-
-pub(crate) trait BytecodeContext {
-    fn intern_string(&mut self, s: &str) -> StringId;
-    fn register_span(&mut self, range: TextRange) -> u32;
-    fn get_code(&self) -> &[u8];
-    fn get_code_mut(&mut self) -> &mut Vec<u8>;
-}
-
-#[repr(u8)]
-#[derive(Clone, Copy, TryFromPrimitive)]
-#[allow(clippy::enum_variant_names)]
-pub enum Op {
-    PushSmi,
-    PushBigInt,
-    PushFloat,
-    PushString,
-    PushNull,
-    PushTrue,
-    PushFalse,
-
-    LoadLocal,
-    LoadOuter,
-    StoreLocal,
-    AllocLocals,
-
-    MakeThunk,
-    MakeClosure,
-    MakePatternClosure,
-
-    Call,
-    CallNoSpan,
-
-    MakeAttrs,
-    MakeAttrsDyn,
-    MakeEmptyAttrs,
-    Select,
-    SelectDefault,
-    HasAttr,
-
-    MakeList,
-
-    OpAdd,
-    OpSub,
-    OpMul,
-    OpDiv,
-    OpEq,
-    OpNeq,
-    OpLt,
-    OpGt,
-    OpLeq,
-    OpGeq,
-    OpConcat,
-    OpUpdate,
-
-    OpNeg,
-    OpNot,
-
-    ForceBool,
-    JumpIfFalse,
-    JumpIfTrue,
-    Jump,
-
-    ConcatStrings,
-    ResolvePath,
-
-    Assert,
-
-    PushWith,
-    PopWith,
-    WithLookup,
-
-    LoadBuiltins,
-    LoadBuiltin,
-
-    MkPos,
-
-    LoadReplBinding,
-    LoadScopedBinding,
-
-    Return,
-}
-
-struct ScopeInfo {
-    depth: u16,
-    arg_id: Option<ArgId>,
-    thunk_map: HashMap<ThunkId, u32>,
-}
-
-struct BytecodeEmitter<'a, Ctx: BytecodeContext> {
-    ctx: &'a mut Ctx,
-    scope_stack: Vec<ScopeInfo>,
-}
-
-pub(crate) fn compile_bytecode(ir: RawIrRef<'_>, ctx: &mut impl BytecodeContext) -> InstructionPtr {
-    let ip = ctx.get_code().len();
-    let mut emitter = BytecodeEmitter::new(ctx);
-    emitter.emit_toplevel(ir);
-    InstructionPtr(ip)
-}
-
-impl<'a, Ctx: BytecodeContext> BytecodeEmitter<'a, Ctx> {
-    fn new(ctx: &'a mut Ctx) -> Self {
-        Self {
-            ctx,
-            scope_stack: Vec::with_capacity(32),
-        }
-    }
-
-    #[inline]
-    fn emit_op(&mut self, op: Op) {
-        self.ctx.get_code_mut().push(op as u8);
-    }
-
-    #[inline]
-    fn emit_u8(&mut self, val: u8) {
-        self.ctx.get_code_mut().push(val);
-    }
-
-    #[inline]
-    fn emit_u16(&mut self, val: u16) {
-        self.ctx
-            .get_code_mut()
-            .extend_from_slice(&val.to_le_bytes());
-    }
-
-    #[inline]
-    fn emit_u32(&mut self, val: u32) {
-        self.ctx
-            .get_code_mut()
-            .extend_from_slice(&val.to_le_bytes());
-    }
-
-    #[inline]
-    fn emit_i32(&mut self, val: i32) {
-        self.ctx
-            .get_code_mut()
-            .extend_from_slice(&val.to_le_bytes());
-    }
-
-    #[inline]
-    fn emit_i64(&mut self, val: i64) {
-        self.ctx
-            .get_code_mut()
-            .extend_from_slice(&val.to_le_bytes());
-    }
-
-    #[inline]
-    fn emit_f64(&mut self, val: f64) {
-        self.ctx
-            .get_code_mut()
-            .extend_from_slice(&val.to_le_bytes());
-    }
-
-    #[inline]
-    fn emit_i32_placeholder(&mut self) -> usize {
-        let offset = self.ctx.get_code_mut().len();
-        self.ctx.get_code_mut().extend_from_slice(&[0u8; 4]);
-        offset
-    }
-    #[inline]
-    fn patch_i32(&mut self, offset: usize, val: i32) {
-        self.ctx.get_code_mut()[offset..offset + 4].copy_from_slice(&val.to_le_bytes());
-    }
-
-    #[inline]
-    fn emit_jump_placeholder(&mut self) -> usize {
-        self.emit_op(Op::Jump);
-        self.emit_i32_placeholder()
-    }
-
-    #[inline]
-    fn patch_jump_target(&mut self, placeholder_offset: usize) {
-        let current_pos = self.ctx.get_code_mut().len();
-        let relative_offset = (current_pos as i32) - (placeholder_offset as i32) - 4;
-        self.patch_i32(placeholder_offset, relative_offset);
-    }
-
-    #[inline]
-    fn emit_str_id(&mut self, id: StringId) {
-        self.ctx
-            .get_code_mut()
-            .extend_from_slice(&(id.0.to_usize() as u32).to_le_bytes());
-    }
-
-    fn current_depth(&self) -> u16 {
-        self.scope_stack.last().map_or(0, |s| s.depth)
-    }
-
-    fn resolve_thunk(&self, id: ThunkId) -> (u16, u32) {
-        for scope in self.scope_stack.iter().rev() {
-            if let Some(&local_idx) = scope.thunk_map.get(&id) {
-                let layer = self.current_depth() - scope.depth;
-                return (layer, local_idx);
-            }
-        }
-        panic!("ThunkId {:?} not found in any scope", id);
-    }
-
-    fn resolve_arg(&self, id: ArgId) -> (u16, u32) {
-        for scope in self.scope_stack.iter().rev() {
-            if scope.arg_id == Some(id) {
-                let layer = self.current_depth() - scope.depth;
-                return (layer, 0);
-            }
-        }
-        panic!("ArgId {:?} not found in any scope", id);
-    }
-
-    fn emit_load(&mut self, layer: u16, local: u32) {
-        if layer == 0 {
-            self.emit_op(Op::LoadLocal);
-            self.emit_u32(local);
-        } else {
-            self.emit_op(Op::LoadOuter);
-            self.emit_u8(layer as u8);
-            self.emit_u32(local);
-        }
-    }
-
-    fn count_with_thunks(&self, ir: RawIrRef<'_>) -> usize {
-        match ir.deref() {
-            Ir::With { thunks, body, .. } => thunks.len() + self.count_with_thunks(*body),
-            Ir::TopLevel { thunks, body } => thunks.len() + self.count_with_thunks(*body),
-            Ir::If { cond, consq, alter } => {
-                self.count_with_thunks(*cond)
-                    + self.count_with_thunks(*consq)
-                    + self.count_with_thunks(*alter)
-            }
-            Ir::BinOp { lhs, rhs, .. } => {
-                self.count_with_thunks(*lhs) + self.count_with_thunks(*rhs)
-            }
-            Ir::UnOp { rhs, .. } => self.count_with_thunks(*rhs),
-            Ir::Call { func, arg, .. } => {
-                self.count_with_thunks(*func) + self.count_with_thunks(*arg)
-            }
-            Ir::Assert {
-                assertion, expr, ..
-            } => self.count_with_thunks(*assertion) + self.count_with_thunks(*expr),
-            Ir::Select { expr, default, .. } => {
-                self.count_with_thunks(*expr) + default.map_or(0, |d| self.count_with_thunks(d))
-            }
-            Ir::HasAttr { lhs, .. } => self.count_with_thunks(*lhs),
-            Ir::ConcatStrings { parts, .. } => {
-                parts.iter().map(|p| self.count_with_thunks(*p)).sum()
-            }
-            Ir::Path(p) => self.count_with_thunks(*p),
-            Ir::List { items } => items.iter().map(|item| self.count_with_thunks(*item)).sum(),
-            Ir::AttrSet { stcs, dyns } => {
-                stcs.iter()
-                    .map(|(_, &(val, _))| self.count_with_thunks(val))
-                    .sum::<usize>()
-                    + dyns
-                        .iter()
-                        .map(|&(k, v, _)| self.count_with_thunks(k) + self.count_with_thunks(v))
-                        .sum::<usize>()
-            }
-            _ => 0,
-        }
-    }
-
-    fn collect_all_thunks<'ir>(
-        &self,
-        own_thunks: &[(ThunkId, RawIrRef<'ir>)],
-        body: RawIrRef<'ir>,
-    ) -> Vec<(ThunkId, RawIrRef<'ir>)> {
-        let mut all = Vec::from(own_thunks);
-        self.collect_with_thunks_recursive(body, &mut all);
-        let mut i = 0;
-        while i < all.len() {
-            let thunk_body = all[i].1;
-            self.collect_with_thunks_recursive(thunk_body, &mut all);
-            i += 1;
-        }
-        all
-    }
-
-    fn collect_with_thunks_recursive<'ir>(
-        &self,
-        ir: RawIrRef<'ir>,
-        out: &mut Vec<(ThunkId, RawIrRef<'ir>)>,
-    ) {
-        match ir.deref() {
-            Ir::With { thunks, body, .. } => {
-                for &(id, inner) in thunks.iter() {
-                    out.push((id, inner));
-                }
-                self.collect_with_thunks_recursive(*body, out);
-            }
-            Ir::TopLevel { thunks, body } => {
-                for &(id, inner) in thunks.iter() {
-                    out.push((id, inner));
-                }
-                self.collect_with_thunks_recursive(*body, out);
-            }
-            Ir::If { cond, consq, alter } => {
-                self.collect_with_thunks_recursive(*cond, out);
-                self.collect_with_thunks_recursive(*consq, out);
-                self.collect_with_thunks_recursive(*alter, out);
-            }
-            Ir::BinOp { lhs, rhs, .. } => {
-                self.collect_with_thunks_recursive(*lhs, out);
-                self.collect_with_thunks_recursive(*rhs, out);
-            }
-            Ir::UnOp { rhs, .. } => self.collect_with_thunks_recursive(*rhs, out),
-            Ir::Call { func, arg, .. } => {
-                self.collect_with_thunks_recursive(*func, out);
-                self.collect_with_thunks_recursive(*arg, out);
-            }
-            Ir::Assert {
-                assertion, expr, ..
-            } => {
-                self.collect_with_thunks_recursive(*assertion, out);
-                self.collect_with_thunks_recursive(*expr, out);
-            }
-            Ir::Select { expr, default, .. } => {
-                self.collect_with_thunks_recursive(*expr, out);
-                if let Some(d) = default {
-                    self.collect_with_thunks_recursive(*d, out);
-                }
-            }
-            Ir::HasAttr { lhs, .. } => self.collect_with_thunks_recursive(*lhs, out),
-            Ir::ConcatStrings { parts, .. } => {
-                for p in parts.iter() {
-                    self.collect_with_thunks_recursive(*p, out);
-                }
-            }
-            Ir::Path(p) => self.collect_with_thunks_recursive(*p, out),
-            Ir::List { items } => {
-                for item in items.iter() {
-                    self.collect_with_thunks_recursive(*item, out);
-                }
-            }
-            Ir::AttrSet { stcs, dyns } => {
-                for (_, &(val, _)) in stcs.iter() {
-                    self.collect_with_thunks_recursive(val, out);
-                }
-                for &(key, val, _) in dyns.iter() {
-                    self.collect_with_thunks_recursive(key, out);
-                    self.collect_with_thunks_recursive(val, out);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    fn push_scope(&mut self, has_arg: bool, arg_id: Option<ArgId>, thunk_ids: &[ThunkId]) {
-        let depth = self.scope_stack.len() as u16;
-        let thunk_base = if has_arg { 1u32 } else { 0u32 };
-        let thunk_map = thunk_ids
-            .iter()
-            .enumerate()
-            .map(|(i, &id)| (id, thunk_base + i as u32))
-            .collect();
-        self.scope_stack.push(ScopeInfo {
-            depth,
-            arg_id,
-            thunk_map,
-        });
-    }
-
-    fn pop_scope(&mut self) {
-        self.scope_stack.pop();
-    }
-
-    fn emit_toplevel(&mut self, ir: RawIrRef<'_>) {
-        match ir.deref() {
-            Ir::TopLevel { body, thunks } => {
-                let with_thunk_count = self.count_with_thunks(*body);
-                let total_slots = thunks.len() + with_thunk_count;
-
-                let all_thunks = self.collect_all_thunks(thunks, *body);
-                let thunk_ids: Vec<ThunkId> = all_thunks.iter().map(|&(id, _)| id).collect();
-
-                self.push_scope(false, None, &thunk_ids);
-
-                if total_slots > 0 {
-                    self.emit_op(Op::AllocLocals);
-                    self.emit_u32(total_slots as u32);
-                }
-
-                self.emit_scope_thunks(thunks);
-                self.emit_expr(*body);
-                self.emit_op(Op::Return);
-
-                self.pop_scope();
-            }
-            _ => {
-                self.push_scope(false, None, &[]);
-                self.emit_expr(ir);
-                self.emit_op(Op::Return);
-                self.pop_scope();
-            }
-        }
-    }
-
-    fn emit_scope_thunks(&mut self, thunks: &[(ThunkId, RawIrRef<'_>)]) {
-        for &(id, inner) in thunks {
-            let label = format!("e{}", id.0);
-            let label_idx = self.ctx.intern_string(&label);
-
-            let skip_patch = self.emit_jump_placeholder();
-            let entry_point = self.ctx.get_code_mut().len() as u32;
-            self.emit_expr(inner);
-            self.emit_op(Op::Return);
-            self.patch_jump_target(skip_patch);
-            self.emit_op(Op::MakeThunk);
-            self.emit_u32(entry_point);
-            self.emit_str_id(label_idx);
-            let (_, local_idx) = self.resolve_thunk(id);
-            self.emit_op(Op::StoreLocal);
-            self.emit_u32(local_idx);
-        }
-    }
-
-    fn emit_expr(&mut self, ir: RawIrRef<'_>) {
-        match ir.deref() {
-            &Ir::Int(x) => {
-                if x <= i32::MAX as i64 {
-                    self.emit_op(Op::PushSmi);
-                    self.emit_i32(x as i32);
-                } else {
-                    self.emit_op(Op::PushBigInt);
-                    self.emit_i64(x);
-                }
-            }
-            &Ir::Float(x) => {
-                self.emit_op(Op::PushFloat);
-                self.emit_f64(x);
-            }
-            &Ir::Bool(true) => self.emit_op(Op::PushTrue),
-            &Ir::Bool(false) => self.emit_op(Op::PushFalse),
-            Ir::Null => self.emit_op(Op::PushNull),
-            Ir::Str(s) => {
-                let idx = self.ctx.intern_string(s.deref());
-                self.emit_op(Op::PushString);
-                self.emit_str_id(idx);
-            }
-            &Ir::Path(p) => {
-                self.emit_expr(p);
-                self.emit_op(Op::ResolvePath);
-            }
-            &Ir::If { cond, consq, alter } => {
-                self.emit_expr(cond);
-                self.emit_op(Op::ForceBool);
-
-                self.emit_op(Op::JumpIfFalse);
-                let else_placeholder = self.emit_i32_placeholder();
-                let after_jif = self.ctx.get_code_mut().len();
-
-                self.emit_expr(consq);
-
-                self.emit_op(Op::Jump);
-                let end_placeholder = self.emit_i32_placeholder();
-                let after_jump = self.ctx.get_code_mut().len();
-
-                let else_offset = (after_jump as i32) - (after_jif as i32);
-                self.patch_i32(else_placeholder, else_offset);
-
-                self.emit_expr(alter);
-
-                let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
-                self.patch_i32(end_placeholder, end_offset);
-            }
-            &Ir::BinOp { lhs, rhs, kind } => {
-                self.emit_binop(lhs, rhs, kind);
-            }
-            &Ir::UnOp { rhs, kind } => match kind {
-                UnOpKind::Neg => {
-                    self.emit_expr(rhs);
-                    self.emit_op(Op::OpNeg);
-                }
-                UnOpKind::Not => {
-                    self.emit_expr(rhs);
-                    self.emit_op(Op::OpNot);
-                }
-            },
-            &Ir::Func {
-                body,
-                ref param,
-                arg,
-                ref thunks,
-            } => {
-                self.emit_func(arg, thunks, param, body);
-            }
-            Ir::AttrSet { stcs, dyns } => {
-                self.emit_attrset(stcs, dyns);
-            }
-            Ir::List { items } => {
-                for &item in items.iter() {
-                    self.emit_expr(item);
-                }
-                self.emit_op(Op::MakeList);
-                self.emit_u32(items.len() as u32);
-            }
-            &Ir::Call { func, arg, span } => {
-                self.emit_expr(func);
-                self.emit_expr(arg);
-                let span_id = self.ctx.register_span(span);
-                self.emit_op(Op::Call);
-                self.emit_u32(span_id);
-            }
-            &Ir::Arg(id) => {
-                let (layer, local) = self.resolve_arg(id);
-                self.emit_load(layer, local);
-            }
-            &Ir::TopLevel { body, ref thunks } => {
-                self.emit_toplevel_inner(body, thunks);
-            }
-            &Ir::Select {
-                expr,
-                ref attrpath,
-                default,
-                span,
-            } => {
-                self.emit_select(expr, attrpath, default, span);
-            }
-            &Ir::Thunk(id) => {
-                let (layer, local) = self.resolve_thunk(id);
-                self.emit_load(layer, local);
-            }
-            Ir::Builtins => {
-                self.emit_op(Op::LoadBuiltins);
-            }
-            &Ir::Builtin(name) => {
-                self.emit_op(Op::LoadBuiltin);
-                self.emit_u32(name.0.to_usize() as u32);
-            }
-            &Ir::ConcatStrings {
-                ref parts,
-                force_string,
-            } => {
-                for &part in parts.iter() {
-                    self.emit_expr(part);
-                }
-                self.emit_op(Op::ConcatStrings);
-                self.emit_u16(parts.len() as u16);
-                self.emit_u8(if force_string { 1 } else { 0 });
-            }
-            &Ir::HasAttr { lhs, ref rhs } => {
-                self.emit_has_attr(lhs, rhs);
-            }
-            Ir::Assert {
-                assertion,
-                expr,
-                assertion_raw,
-                span,
-            } => {
-                let raw_idx = self.ctx.intern_string(assertion_raw);
-                let span_id = self.ctx.register_span(*span);
-                self.emit_expr(*assertion);
-                self.emit_expr(*expr);
-                self.emit_op(Op::Assert);
-                self.emit_str_id(raw_idx);
-                self.emit_u32(span_id);
-            }
-            &Ir::CurPos(span) => {
-                let span_id = self.ctx.register_span(span);
-                self.emit_op(Op::MkPos);
-                self.emit_u32(span_id);
-            }
-            &Ir::ReplBinding(name) => {
-                self.emit_op(Op::LoadReplBinding);
-                self.emit_str_id(name);
-            }
-            &Ir::ScopedImportBinding(name) => {
-                self.emit_op(Op::LoadScopedBinding);
-                self.emit_str_id(name);
-            }
-            &Ir::With {
-                namespace,
-                body,
-                ref thunks,
-            } => {
-                self.emit_with(namespace, body, thunks);
-            }
-            &Ir::WithLookup(name) => {
-                self.emit_op(Op::WithLookup);
-                self.emit_str_id(name);
-            }
-        }
-    }
-
-    fn emit_binop(&mut self, lhs: RawIrRef<'_>, rhs: RawIrRef<'_>, kind: BinOpKind) {
-        use BinOpKind::*;
-        match kind {
-            And => {
-                self.emit_expr(lhs);
-                self.emit_op(Op::ForceBool);
-                self.emit_op(Op::JumpIfFalse);
-                let skip_placeholder = self.emit_i32_placeholder();
-                let after_jif = self.ctx.get_code_mut().len();
-
-                self.emit_expr(rhs);
-                self.emit_op(Op::ForceBool);
-                self.emit_op(Op::Jump);
-                let end_placeholder = self.emit_i32_placeholder();
-                let after_jump = self.ctx.get_code_mut().len();
-
-                let false_offset = (after_jump as i32) - (after_jif as i32);
-                self.patch_i32(skip_placeholder, false_offset);
-
-                self.emit_op(Op::PushFalse);
-
-                let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
-                self.patch_i32(end_placeholder, end_offset);
-            }
-            Or => {
-                self.emit_expr(lhs);
-                self.emit_op(Op::ForceBool);
-                self.emit_op(Op::JumpIfTrue);
-                let skip_placeholder = self.emit_i32_placeholder();
-                let after_jit = self.ctx.get_code_mut().len();
-
-                self.emit_expr(rhs);
-                self.emit_op(Op::ForceBool);
-                self.emit_op(Op::Jump);
-                let end_placeholder = self.emit_i32_placeholder();
-                let after_jump = self.ctx.get_code_mut().len();
-
-                let true_offset = (after_jump as i32) - (after_jit as i32);
-                self.patch_i32(skip_placeholder, true_offset);
-
-                self.emit_op(Op::PushTrue);
-
-                let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
-                self.patch_i32(end_placeholder, end_offset);
-            }
-            Impl => {
-                self.emit_expr(lhs);
-                self.emit_op(Op::ForceBool);
-                self.emit_op(Op::JumpIfFalse);
-                let skip_placeholder = self.emit_i32_placeholder();
-                let after_jif = self.ctx.get_code_mut().len();
-
-                self.emit_expr(rhs);
-                self.emit_op(Op::ForceBool);
-                self.emit_op(Op::Jump);
-                let end_placeholder = self.emit_i32_placeholder();
-                let after_jump = self.ctx.get_code_mut().len();
-
-                let true_offset = (after_jump as i32) - (after_jif as i32);
-                self.patch_i32(skip_placeholder, true_offset);
-
-                self.emit_op(Op::PushTrue);
-
-                let end_offset = (self.ctx.get_code_mut().len() as i32) - (after_jump as i32);
-                self.patch_i32(end_placeholder, end_offset);
-            }
-            PipeL => {
-                self.emit_expr(rhs);
-                self.emit_expr(lhs);
-                self.emit_op(Op::CallNoSpan);
-            }
-            PipeR => {
-                self.emit_expr(lhs);
-                self.emit_expr(rhs);
-                self.emit_op(Op::CallNoSpan);
-            }
-            _ => {
-                self.emit_expr(lhs);
-                self.emit_expr(rhs);
-                self.emit_op(match kind {
-                    Add => Op::OpAdd,
-                    Sub => Op::OpSub,
-                    Mul => Op::OpMul,
-                    Div => Op::OpDiv,
-                    Eq => Op::OpEq,
-                    Neq => Op::OpNeq,
-                    Lt => Op::OpLt,
-                    Gt => Op::OpGt,
-                    Leq => Op::OpLeq,
-                    Geq => Op::OpGeq,
-                    Con => Op::OpConcat,
-                    Upd => Op::OpUpdate,
-                    _ => unreachable!(),
-                });
-            }
-        }
-    }
-
-    fn emit_func(
-        &mut self,
-        arg: ArgId,
-        thunks: &[(ThunkId, RawIrRef<'_>)],
-        param: &Option<Param<'_>>,
-        body: RawIrRef<'_>,
-    ) {
-        let with_thunk_count = self.count_with_thunks(body);
-        let total_slots = thunks.len() + with_thunk_count;
-
-        let all_thunks = self.collect_all_thunks(thunks, body);
-        let thunk_ids: Vec<ThunkId> = all_thunks.iter().map(|&(id, _)| id).collect();
-
-        let skip_patch = self.emit_jump_placeholder();
-        let entry_point = self.ctx.get_code().len() as u32;
-        self.push_scope(true, Some(arg), &thunk_ids);
-        self.emit_scope_thunks(thunks);
-        self.emit_expr(body);
-        self.emit_op(Op::Return);
-        self.pop_scope();
-        self.patch_jump_target(skip_patch);
-
-        if let Some(Param {
-            required,
-            optional,
-            ellipsis,
-        }) = param
-        {
-            self.emit_op(Op::MakePatternClosure);
-            self.emit_u32(entry_point);
-            self.emit_u32(total_slots as u32);
-            self.emit_u16(required.len() as u16);
-            self.emit_u16(optional.len() as u16);
-            self.emit_u8(if *ellipsis { 1 } else { 0 });
-
-            for &(sym, _) in required.iter() {
-                self.emit_str_id(sym);
-            }
-            for &(sym, _) in optional.iter() {
-                self.emit_str_id(sym);
-            }
-            for &(sym, span) in required.iter().chain(optional.iter()) {
-                let span_id = self.ctx.register_span(span);
-                self.emit_str_id(sym);
-                self.emit_u32(span_id);
-            }
-        } else {
-            self.emit_op(Op::MakeClosure);
-            self.emit_u32(entry_point);
-            self.emit_u32(total_slots as u32);
-        }
-    }
-
-    fn emit_attrset(
-        &mut self,
-        stcs: &crate::ir::HashMap<'_, StringId, (RawIrRef<'_>, TextRange)>,
-        dyns: &[(RawIrRef<'_>, RawIrRef<'_>, TextRange)],
-    ) {
-        if stcs.is_empty() && dyns.is_empty() {
-            self.emit_op(Op::MakeEmptyAttrs);
-            return;
-        }
-
-        if !dyns.is_empty() {
-            for (&sym, &(val, _)) in stcs.iter() {
-                self.emit_op(Op::PushString);
-                self.emit_str_id(sym);
-                self.emit_expr(val);
-            }
-            for (_, &(_, span)) in stcs.iter() {
-                let span_id = self.ctx.register_span(span);
-                self.emit_op(Op::PushSmi);
-                self.emit_u32(span_id);
-            }
-            for &(key, val, span) in dyns.iter() {
-                self.emit_expr(key);
-                self.emit_expr(val);
-                let span_id = self.ctx.register_span(span);
-                self.emit_op(Op::PushSmi);
-                self.emit_u32(span_id);
-            }
-            self.emit_op(Op::MakeAttrsDyn);
-            self.emit_u32(stcs.len() as u32);
-            self.emit_u32(dyns.len() as u32);
-        } else {
-            for (&sym, &(val, _)) in stcs.iter() {
-                self.emit_op(Op::PushString);
-                self.emit_str_id(sym);
-                self.emit_expr(val);
-            }
-            for (_, &(_, span)) in stcs.iter() {
-                let span_id = self.ctx.register_span(span);
-                self.emit_op(Op::PushSmi);
-                self.emit_u32(span_id);
-            }
-            self.emit_op(Op::MakeAttrs);
-            self.emit_u32(stcs.len() as u32);
-        }
-    }
-
-    fn emit_select(
-        &mut self,
-        expr: RawIrRef<'_>,
-        attrpath: &[Attr<RawIrRef<'_>>],
-        default: Option<RawIrRef<'_>>,
-        span: TextRange,
-    ) {
-        self.emit_expr(expr);
-        for attr in attrpath.iter() {
-            match *attr {
-                Attr::Str(sym, _) => {
-                    self.emit_op(Op::PushString);
-                    self.emit_str_id(sym);
-                }
-                Attr::Dynamic(expr, _) => {
-                    self.emit_expr(expr);
-                }
-            }
-        }
-
-        if let Some(default) = default {
-            self.emit_expr(default);
-            let span_id = self.ctx.register_span(span);
-            self.emit_op(Op::SelectDefault);
-            self.emit_u16(attrpath.len() as u16);
-            self.emit_u32(span_id);
-        } else {
-            let span_id = self.ctx.register_span(span);
-            self.emit_op(Op::Select);
-            self.emit_u16(attrpath.len() as u16);
-            self.emit_u32(span_id);
-        }
-    }
-
-    fn emit_has_attr(&mut self, lhs: RawIrRef<'_>, rhs: &[Attr<RawIrRef<'_>>]) {
-        self.emit_expr(lhs);
-        for attr in rhs.iter() {
-            match *attr {
-                Attr::Str(sym, _) => {
-                    self.emit_op(Op::PushString);
-                    self.emit_str_id(sym);
-                }
-                Attr::Dynamic(expr, _) => {
-                    self.emit_expr(expr);
-                }
-            }
-        }
-        self.emit_op(Op::HasAttr);
-        self.emit_u16(rhs.len() as u16);
-    }
-
-    fn emit_with(
-        &mut self,
-        namespace: RawIrRef<'_>,
-        body: RawIrRef<'_>,
-        thunks: &[(ThunkId, RawIrRef<'_>)],
-    ) {
-        self.emit_expr(namespace);
-        self.emit_op(Op::PushWith);
-        self.emit_scope_thunks(thunks);
-        self.emit_expr(body);
-        self.emit_op(Op::PopWith);
-    }
-
-    fn emit_toplevel_inner(&mut self, body: RawIrRef<'_>, thunks: &[(ThunkId, RawIrRef<'_>)]) {
-        self.emit_scope_thunks(thunks);
-        self.emit_expr(body);
-    }
-}

fix/src/derivation.rs

@@ -1,142 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-
-pub struct OutputInfo {
-    pub path: String,
-    pub hash_algo: String,
-    pub hash: String,
-}
-
-pub struct DerivationData {
-    pub name: String,
-    pub outputs: BTreeMap<String, OutputInfo>,
-    pub input_drvs: BTreeMap<String, BTreeSet<String>>,
-    pub input_srcs: BTreeSet<String>,
-    pub platform: String,
-    pub builder: String,
-    pub args: Vec<String>,
-    pub env: BTreeMap<String, String>,
-}
-
-fn escape_string(s: &str) -> String {
-    let mut result = String::with_capacity(s.len() + 2);
-    result.push('"');
-    for c in s.chars() {
-        match c {
-            '"' => result.push_str("\\\""),
-            '\\' => result.push_str("\\\\"),
-            '\n' => result.push_str("\\n"),
-            '\r' => result.push_str("\\r"),
-            '\t' => result.push_str("\\t"),
-            _ => result.push(c),
-        }
-    }
-    result.push('"');
-    result
-}
-
-fn quote_string(s: &str) -> String {
-    format!("\"{}\"", s)
-}
-
-impl DerivationData {
-    pub fn generate_aterm(&self) -> String {
-        let mut output_entries = Vec::new();
-        for (name, info) in &self.outputs {
-            output_entries.push(format!(
-                "({},{},{},{})",
-                quote_string(name),
-                quote_string(&info.path),
-                quote_string(&info.hash_algo),
-                quote_string(&info.hash),
-            ));
-        }
-        let outputs = output_entries.join(",");
-
-        let mut input_drv_entries = Vec::new();
-        for (drv_path, output_names) in &self.input_drvs {
-            let sorted_outs: Vec<String> = output_names.iter().map(|s| quote_string(s)).collect();
-            let out_list = format!("[{}]", sorted_outs.join(","));
-            input_drv_entries.push(format!("({},{})", quote_string(drv_path), out_list));
-        }
-        let input_drvs = input_drv_entries.join(",");
-
-        let input_srcs: Vec<String> = self.input_srcs.iter().map(|s| quote_string(s)).collect();
-        let input_srcs = input_srcs.join(",");
-
-        let args: Vec<String> = self.args.iter().map(|s| escape_string(s)).collect();
-        let args = args.join(",");
-
-        let mut env_entries: Vec<String> = Vec::new();
-        for (k, v) in &self.env {
-            env_entries.push(format!("({},{})", escape_string(k), escape_string(v)));
-        }
-
-        format!(
-            "Derive([{}],[{}],[{}],{},{},[{}],[{}])",
-            outputs,
-            input_drvs,
-            input_srcs,
-            quote_string(&self.platform),
-            escape_string(&self.builder),
-            args,
-            env_entries.join(","),
-        )
-    }
-
-    pub fn generate_aterm_modulo(&self, input_drv_hashes: &BTreeMap<String, String>) -> String {
-        let mut output_entries = Vec::new();
-        for (name, info) in &self.outputs {
-            output_entries.push(format!(
-                "({},{},{},{})",
-                quote_string(name),
-                quote_string(&info.path),
-                quote_string(&info.hash_algo),
-                quote_string(&info.hash),
-            ));
-        }
-        let outputs = output_entries.join(",");
-
-        let mut input_drv_entries = Vec::new();
-        for (drv_hash, outputs_csv) in input_drv_hashes {
-            let mut sorted_outs: Vec<&str> = outputs_csv.split(',').collect();
-            sorted_outs.sort();
-            let out_list: Vec<String> = sorted_outs.iter().map(|s| quote_string(s)).collect();
-            let out_list = format!("[{}]", out_list.join(","));
-            input_drv_entries.push(format!("({},{})", quote_string(drv_hash), out_list));
-        }
-        let input_drvs = input_drv_entries.join(",");
-
-        let input_srcs: Vec<String> = self.input_srcs.iter().map(|s| quote_string(s)).collect();
-        let input_srcs = input_srcs.join(",");
-
-        let args: Vec<String> = self.args.iter().map(|s| escape_string(s)).collect();
-        let args = args.join(",");
-
-        let mut env_entries: Vec<String> = Vec::new();
-        for (k, v) in &self.env {
-            env_entries.push(format!("({},{})", escape_string(k), escape_string(v)));
-        }
-
-        format!(
-            "Derive([{}],[{}],[{}],{},{},[{}],[{}])",
-            outputs,
-            input_drvs,
-            input_srcs,
-            quote_string(&self.platform),
-            escape_string(&self.builder),
-            args,
-            env_entries.join(","),
-        )
-    }
-
-    pub fn collect_references(&self) -> Vec<String> {
-        let mut refs = BTreeSet::new();
-        for src in &self.input_srcs {
-            refs.insert(src.clone());
-        }
-        for drv_path in self.input_drvs.keys() {
-            refs.insert(drv_path.clone());
-        }
-        refs.into_iter().collect()
-    }
-}

fix/src/disassembler.rs

@@ -1,372 +0,0 @@
-use std::fmt::Write;
-
-use colored::Colorize;
-use num_enum::TryFromPrimitive;
-
-use crate::codegen::{Bytecode, Op};
-
-pub(crate) trait DisassemblerContext {
-    fn lookup_string(&self, id: u32) -> &str;
-}
-
-pub(crate) struct Disassembler<'a, Ctx> {
-    code: &'a [u8],
-    ctx: &'a Ctx,
-    pos: usize,
-}
-
-impl<'a, Ctx: DisassemblerContext> Disassembler<'a, Ctx> {
-    pub fn new(bytecode: &'a Bytecode, ctx: &'a Ctx) -> Self {
-        Self {
-            code: &bytecode.code,
-            ctx,
-            pos: 0,
-        }
-    }
-
-    fn read_u8(&mut self) -> u8 {
-        let b = self.code[self.pos];
-        self.pos += 1;
-        b
-    }
-
-    fn read_u16(&mut self) -> u16 {
-        let bytes = self.code[self.pos..self.pos + 2]
-            .try_into()
-            .expect("no enough bytes");
-        self.pos += 2;
-        u16::from_le_bytes(bytes)
-    }
-
-    fn read_u32(&mut self) -> u32 {
-        let bytes = self.code[self.pos..self.pos + 4]
-            .try_into()
-            .expect("no enough bytes");
-        self.pos += 4;
-        u32::from_le_bytes(bytes)
-    }
-
-    fn read_i32(&mut self) -> i32 {
-        let bytes = self.code[self.pos..self.pos + 4]
-            .try_into()
-            .expect("no enough bytes");
-        self.pos += 4;
-        i32::from_le_bytes(bytes)
-    }
-
-    fn read_i64(&mut self) -> i64 {
-        let bytes = self.code[self.pos..self.pos + 8]
-            .try_into()
-            .expect("no enough bytes");
-        self.pos += 8;
-        i64::from_le_bytes(bytes)
-    }
-
-    fn read_f64(&mut self) -> f64 {
-        let bytes = self.code[self.pos..self.pos + 8]
-            .try_into()
-            .expect("no enough bytes");
-        self.pos += 8;
-        f64::from_le_bytes(bytes)
-    }
-
-    pub fn disassemble(&mut self) -> String {
-        self.disassemble_impl(false)
-    }
-
-    pub fn disassemble_colored(&mut self) -> String {
-        self.disassemble_impl(true)
-    }
-
-    fn disassemble_impl(&mut self, color: bool) -> String {
-        let mut out = String::new();
-        if color {
-            let _ = writeln!(out, "{}", "=== Bytecode Disassembly ===".bold().white());
-            let _ = writeln!(
-                out,
-                "{} {}",
-                "Length:".white(),
-                format!("{} bytes", self.code.len()).cyan()
-            );
-        } else {
-            let _ = writeln!(out, "=== Bytecode Disassembly ===");
-            let _ = writeln!(out, "Length: {} bytes", self.code.len());
-        }
-
-        while self.pos < self.code.len() {
-            let start_pos = self.pos;
-            let op_byte = self.read_u8();
-            let (mnemonic, args) = self.decode_instruction(op_byte, start_pos);
-
-            let bytes_slice = &self.code[start_pos + 1..self.pos];
-
-            for (i, chunk) in bytes_slice.chunks(4).enumerate() {
-                let bytes_str = {
-                    let mut temp = String::new();
-                    if i == 0 {
-                        let _ = write!(&mut temp, "{:02x}", self.code[start_pos]);
-                    } else {
-                        let _ = write!(&mut temp, "  ");
-                    }
-                    for b in chunk.iter() {
-                        let _ = write!(&mut temp, " {:02x}", b);
-                    }
-                    temp
-                };
-
-                if i == 0 {
-                    if color {
-                        let sep = if args.is_empty() { "" } else { " " };
-                        let _ = writeln!(
-                            out,
-                            "{}  {:<14} | {}{}{}",
-                            format!("{:04x}", start_pos).dimmed(),
-                            bytes_str.green(),
-                            mnemonic.yellow().bold(),
-                            sep,
-                            args.cyan()
-                        );
-                    } else {
-                        let op_str = if args.is_empty() {
-                            mnemonic.to_string()
-                        } else {
-                            format!("{} {}", mnemonic, args)
-                        };
-                        let _ = writeln!(out, "{:04x}  {:<14} | {}", start_pos, bytes_str, op_str);
-                    }
-                } else {
-                    let extra_width = start_pos.ilog2() >> 4;
-                    if color {
-                        let _ = write!(out, "    ");
-                        for _ in 0..extra_width {
-                            let _ = write!(out, " ");
-                        }
-                        let _ = writeln!(out, "  {:<14} |", bytes_str.green());
-                    } else {
-                        let _ = write!(out, "    ");
-                        for _ in 0..extra_width {
-                            let _ = write!(out, " ");
-                        }
-                        let _ = writeln!(out, "  {:<14} |", bytes_str);
-                    }
-                }
-            }
-        }
-        out
-    }
-
-    fn decode_instruction(&mut self, op_byte: u8, current_pc: usize) -> (&'static str, String) {
-        let op = Op::try_from_primitive(op_byte).expect("invalid op code");
-
-        match op {
-            Op::PushSmi => {
-                let val = self.read_i32();
-                ("PushSmi", format!("{}", val))
-            }
-            Op::PushBigInt => {
-                let val = self.read_i64();
-                ("PushBigInt", format!("{}", val))
-            }
-            Op::PushFloat => {
-                let val = self.read_f64();
-                ("PushFloat", format!("{}", val))
-            }
-            Op::PushString => {
-                let idx = self.read_u32();
-                let s = self.ctx.lookup_string(idx);
-                let len = s.len();
-                let mut s_fmt = format!("{:?}", s);
-                if s_fmt.len() > 60 {
-                    s_fmt.truncate(57);
-                    #[allow(clippy::unwrap_used)]
-                    write!(s_fmt, "...\" (total {len} bytes)").unwrap();
-                }
-                ("PushString", format!("@{} {}", idx, s_fmt))
-            }
-            Op::PushNull => ("PushNull", String::new()),
-            Op::PushTrue => ("PushTrue", String::new()),
-            Op::PushFalse => ("PushFalse", String::new()),
-
-            Op::LoadLocal => {
-                let idx = self.read_u32();
-                ("LoadLocal", format!("[{}]", idx))
-            }
-            Op::LoadOuter => {
-                let depth = self.read_u8();
-                let idx = self.read_u32();
-                ("LoadOuter", format!("depth={} [{}]", depth, idx))
-            }
-            Op::StoreLocal => {
-                let idx = self.read_u32();
-                ("StoreLocal", format!("[{}]", idx))
-            }
-            Op::AllocLocals => {
-                let count = self.read_u32();
-                ("AllocLocals", format!("count={}", count))
-            }
-
-            Op::MakeThunk => {
-                let offset = self.read_u32();
-                let label_idx = self.read_u32();
-                let label = self.ctx.lookup_string(label_idx);
-                ("MakeThunk", format!("-> {:04x} label={}", offset, label))
-            }
-            Op::MakeClosure => {
-                let offset = self.read_u32();
-                let slots = self.read_u32();
-                ("MakeClosure", format!("-> {:04x} slots={}", offset, slots))
-            }
-            Op::MakePatternClosure => {
-                let offset = self.read_u32();
-                let slots = self.read_u32();
-                let req_count = self.read_u16();
-                let opt_count = self.read_u16();
-                let ellipsis = self.read_u8() != 0;
-
-                let mut arg_str = format!(
-                    "-> {:04x} slots={} req={} opt={} ...={})",
-                    offset, slots, req_count, opt_count, ellipsis
-                );
-
-                arg_str.push_str(" Args=[");
-                for _ in 0..req_count {
-                    let idx = self.read_u32();
-                    arg_str.push_str(&format!("Req({}) ", self.ctx.lookup_string(idx)));
-                }
-                for _ in 0..opt_count {
-                    let idx = self.read_u32();
-                    arg_str.push_str(&format!("Opt({}) ", self.ctx.lookup_string(idx)));
-                }
-
-                let total_args = req_count + opt_count;
-                for _ in 0..total_args {
-                    let _name_idx = self.read_u32();
-                    let _span_id = self.read_u32();
-                }
-                arg_str.push(']');
-
-                ("MakePatternClosure", arg_str)
-            }
-
-            Op::Call => {
-                let span_id = self.read_u32();
-                ("Call", format!("span={}", span_id))
-            }
-            Op::CallNoSpan => ("CallNoSpan", String::new()),
-
-            Op::MakeAttrs => {
-                let count = self.read_u32();
-                ("MakeAttrs", format!("size={}", count))
-            }
-            Op::MakeAttrsDyn => {
-                let static_count = self.read_u32();
-                let dyn_count = self.read_u32();
-                (
-                    "MakeAttrsDyn",
-                    format!("static={} dyn={}", static_count, dyn_count),
-                )
-            }
-            Op::MakeEmptyAttrs => ("MakeEmptyAttrs", String::new()),
-
-            Op::Select => {
-                let path_len = self.read_u16();
-                let span_id = self.read_u32();
-                ("Select", format!("path_len={} span={}", path_len, span_id))
-            }
-            Op::SelectDefault => {
-                let path_len = self.read_u16();
-                let span_id = self.read_u32();
-                (
-                    "SelectDefault",
-                    format!("path_len={} span={}", path_len, span_id),
-                )
-            }
-            Op::HasAttr => {
-                let path_len = self.read_u16();
-                ("HasAttr", format!("path_len={}", path_len))
-            }
-
-            Op::MakeList => {
-                let count = self.read_u32();
-                ("MakeList", format!("size={}", count))
-            }
-
-            Op::OpAdd => ("OpAdd", String::new()),
-            Op::OpSub => ("OpSub", String::new()),
-            Op::OpMul => ("OpMul", String::new()),
-            Op::OpDiv => ("OpDiv", String::new()),
-            Op::OpEq => ("OpEq", String::new()),
-            Op::OpNeq => ("OpNeq", String::new()),
-            Op::OpLt => ("OpLt", String::new()),
-            Op::OpGt => ("OpGt", String::new()),
-            Op::OpLeq => ("OpLeq", String::new()),
-            Op::OpGeq => ("OpGeq", String::new()),
-            Op::OpConcat => ("OpConcat", String::new()),
-            Op::OpUpdate => ("OpUpdate", String::new()),
-            Op::OpNeg => ("OpNeg", String::new()),
-            Op::OpNot => ("OpNot", String::new()),
-
-            Op::ForceBool => ("ForceBool", String::new()),
-
-            Op::JumpIfFalse => {
-                let offset = self.read_i32();
-                let target = (current_pc as isize + 1 + 4 + offset as isize) as usize;
-                (
-                    "JumpIfFalse",
-                    format!("-> {:04x} offset={}", target, offset),
-                )
-            }
-            Op::JumpIfTrue => {
-                let offset = self.read_i32();
-                let target = (current_pc as isize + 1 + 4 + offset as isize) as usize;
-                ("JumpIfTrue", format!("-> {:04x} offset={}", target, offset))
-            }
-            Op::Jump => {
-                let offset = self.read_i32();
-                let target = (current_pc as isize + 1 + 4 + offset as isize) as usize;
-                ("Jump", format!("-> {:04x} offset={}", target, offset))
-            }
-
-            Op::ConcatStrings => {
-                let count = self.read_u16();
-                let force = self.read_u8();
-                ("ConcatStrings", format!("count={} force={}", count, force))
-            }
-            Op::ResolvePath => ("ResolvePath", String::new()),
-            Op::Assert => {
-                let raw_idx = self.read_u32();
-                let span_id = self.read_u32();
-                ("Assert", format!("text_id={} span={}", raw_idx, span_id))
-            }
-            Op::PushWith => ("PushWith", String::new()),
-            Op::PopWith => ("PopWith", String::new()),
-            Op::WithLookup => {
-                let idx = self.read_u32();
-                let name = self.ctx.lookup_string(idx);
-                ("WithLookup", format!("{:?}", name))
-            }
-
-            Op::LoadBuiltins => ("LoadBuiltins", String::new()),
-            Op::LoadBuiltin => {
-                let idx = self.read_u32();
-                let name = self.ctx.lookup_string(idx);
-                ("LoadBuiltin", format!("{:?}", name))
-            }
-            Op::MkPos => {
-                let span_id = self.read_u32();
-                ("MkPos", format!("id={}", span_id))
-            }
-            Op::LoadReplBinding => {
-                let idx = self.read_u32();
-                let name = self.ctx.lookup_string(idx);
-                ("LoadReplBinding", format!("{:?}", name))
-            }
-            Op::LoadScopedBinding => {
-                let idx = self.read_u32();
-                let name = self.ctx.lookup_string(idx);
-                ("LoadScopedBinding", format!("{:?}", name))
-            }
-            Op::Return => ("Return", String::new()),
-        }
-    }
-}

fix/src/fetcher/cache.rs

@@ -1,29 +0,0 @@
-use std::fs;
-use std::path::PathBuf;
-
-#[derive(Debug)]
-pub struct FetcherCache {
-    base_dir: PathBuf,
-}
-
-impl FetcherCache {
-    pub fn new() -> Result<Self, std::io::Error> {
-        let base_dir = dirs::cache_dir()
-            .unwrap_or_else(|| PathBuf::from("/tmp"))
-            .join("fix")
-            .join("fetchers");
-
-        fs::create_dir_all(&base_dir)?;
-
-        Ok(Self { base_dir })
-    }
-
-    fn git_cache_dir(&self) -> PathBuf {
-        self.base_dir.join("git")
-    }
-
-    pub fn get_git_bare(&self, url: &str) -> PathBuf {
-        let key = crate::nix_utils::sha256_hex(url.as_bytes());
-        self.git_cache_dir().join(key)
-    }
-}

fix/src/ir.rs

@@ -1,688 +0,0 @@
-use std::{
-    hash::{Hash, Hasher},
-    ops::Deref,
-};
-
-use bumpalo::{Bump, boxed::Box, collections::Vec};
-use gc_arena::Collect;
-use ghost_cell::{GhostCell, GhostToken};
-use rnix::{TextRange, ast};
-use string_interner::symbol::SymbolU32;
-
-pub type HashMap<'ir, K, V> = hashbrown::HashMap<K, V, hashbrown::DefaultHashBuilder, &'ir Bump>;
-
-#[repr(transparent)]
-#[derive(Clone, Copy)]
-pub struct IrRef<'id, 'ir>(&'ir GhostCell<'id, Ir<'ir, Self>>);
-
-impl<'id, 'ir> IrRef<'id, 'ir> {
-    pub fn new(ir: &'ir GhostCell<'id, Ir<'ir, Self>>) -> Self {
-        Self(ir)
-    }
-
-    pub fn alloc(bump: &'ir Bump, ir: Ir<'ir, Self>) -> Self {
-        Self(bump.alloc(GhostCell::new(ir)))
-    }
-
-    pub fn borrow<'a>(&'a self, token: &'a GhostToken<'id>) -> &'a Ir<'ir, Self> {
-        self.0.borrow(token)
-    }
-
-    /// Freeze a mutable IR reference into a read-only one, consuming the
-    /// `GhostToken` to prevent any further mutation.
-    ///
-    /// # Safety
-    /// The transmute is sound because:
-    /// - `GhostCell<'id, T>` is `#[repr(transparent)]` over `T`
-    /// - `IrRef<'id, 'ir>` is `#[repr(transparent)]` over
-    ///   `&'ir GhostCell<'id, Ir<'ir, Self>>`
-    /// - `RawIrRef<'ir>` is `#[repr(transparent)]` over `&'ir Ir<'ir, Self>`
-    /// - `Ir<'ir, Ref>` is `#[repr(C)]` and both ref types are pointer-sized
-    ///
-    /// Consuming the `GhostToken` guarantees no `borrow_mut` calls can occur
-    /// afterwards, so the shared `&Ir` references from `RawIrRef::Deref` can
-    /// never alias with mutable references.
-    pub fn freeze(self, _token: GhostToken<'id>) -> RawIrRef<'ir> {
-        unsafe { std::mem::transmute(self) }
-    }
-}
-
-#[repr(transparent)]
-#[derive(Clone, Copy)]
-pub struct RawIrRef<'ir>(&'ir Ir<'ir, Self>);
-
-impl<'ir> Deref for RawIrRef<'ir> {
-    type Target = Ir<'ir, RawIrRef<'ir>>;
-    fn deref(&self) -> &Self::Target {
-        self.0
-    }
-}
-
-#[repr(C)]
-pub enum Ir<'ir, Ref> {
-    Int(i64),
-    Float(f64),
-    Bool(bool),
-    Null,
-    Str(Box<'ir, String>),
-    AttrSet {
-        stcs: HashMap<'ir, StringId, (Ref, TextRange)>,
-        dyns: Vec<'ir, (Ref, Ref, TextRange)>,
-    },
-    List {
-        items: Vec<'ir, Ref>,
-    },
-    Path(Ref),
-    ConcatStrings {
-        parts: Vec<'ir, Ref>,
-        force_string: bool,
-    },
-
-    // OPs
-    UnOp {
-        rhs: Ref,
-        kind: UnOpKind,
-    },
-    BinOp {
-        lhs: Ref,
-        rhs: Ref,
-        kind: BinOpKind,
-    },
-    HasAttr {
-        lhs: Ref,
-        rhs: Vec<'ir, Attr<Ref>>,
-    },
-    Select {
-        expr: Ref,
-        attrpath: Vec<'ir, Attr<Ref>>,
-        default: Option<Ref>,
-        span: TextRange,
-    },
-
-    // Conditionals
-    If {
-        cond: Ref,
-        consq: Ref,
-        alter: Ref,
-    },
-    Assert {
-        assertion: Ref,
-        expr: Ref,
-        assertion_raw: String,
-        span: TextRange,
-    },
-
-    With {
-        namespace: Ref,
-        body: Ref,
-        thunks: Vec<'ir, (ThunkId, Ref)>,
-    },
-    WithLookup(StringId),
-
-    // Function related
-    Func {
-        body: Ref,
-        param: Option<Param<'ir>>,
-        arg: ArgId,
-        thunks: Vec<'ir, (ThunkId, Ref)>,
-    },
-    Arg(ArgId),
-    Call {
-        func: Ref,
-        arg: Ref,
-        span: TextRange,
-    },
-
-    // Builtins
-    Builtins,
-    Builtin(StringId),
-
-    // Misc
-    TopLevel {
-        body: Ref,
-        thunks: Vec<'ir, (ThunkId, Ref)>,
-    },
-    Thunk(ThunkId),
-    CurPos(TextRange),
-    ReplBinding(StringId),
-    ScopedImportBinding(StringId),
-}
-
-#[repr(transparent)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ThunkId(pub usize);
-
-#[repr(transparent)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Collect)]
-#[collect(require_static)]
-pub struct StringId(pub SymbolU32);
-
-#[repr(transparent)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct ArgId(pub u32);
-
-#[repr(transparent)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct SpanId(pub u32);
-
-/// Represents a key in an attribute path.
-#[allow(unused)]
-#[derive(Debug)]
-pub enum Attr<Ref> {
-    /// A dynamic attribute key, which is an expression that must evaluate to a string.
-    /// Example: `attrs.${key}`
-    Dynamic(Ref, TextRange),
-    /// A static attribute key.
-    /// Example: `attrs.key`
-    Str(StringId, TextRange),
-}
-
-/// The kinds of binary operations supported in Nix.
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
-pub enum BinOpKind {
-    // Arithmetic
-    Add,
-    Sub,
-    Div,
-    Mul,
-
-    // Comparison
-    Eq,
-    Neq,
-    Lt,
-    Gt,
-    Leq,
-    Geq,
-
-    // Logical
-    And,
-    Or,
-    Impl,
-
-    // Set/String/Path operations
-    Con, // List concatenation (`++`)
-    Upd, // AttrSet update (`//`)
-
-    // Not standard, but part of rnix AST
-    PipeL,
-    PipeR,
-}
-
-impl From<ast::BinOpKind> for BinOpKind {
-    fn from(op: ast::BinOpKind) -> Self {
-        use BinOpKind::*;
-        use ast::BinOpKind as kind;
-        match op {
-            kind::Concat => Con,
-            kind::Update => Upd,
-            kind::Add => Add,
-            kind::Sub => Sub,
-            kind::Mul => Mul,
-            kind::Div => Div,
-            kind::And => And,
-            kind::Equal => Eq,
-            kind::Implication => Impl,
-            kind::Less => Lt,
-            kind::LessOrEq => Leq,
-            kind::More => Gt,
-            kind::MoreOrEq => Geq,
-            kind::NotEqual => Neq,
-            kind::Or => Or,
-            kind::PipeLeft => PipeL,
-            kind::PipeRight => PipeR,
-        }
-    }
-}
-
-/// The kinds of unary operations.
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
-pub enum UnOpKind {
-    Neg, // Negation (`-`)
-    Not, // Logical not (`!`)
-}
-
-impl From<ast::UnaryOpKind> for UnOpKind {
-    fn from(value: ast::UnaryOpKind) -> Self {
-        match value {
-            ast::UnaryOpKind::Invert => UnOpKind::Not,
-            ast::UnaryOpKind::Negate => UnOpKind::Neg,
-        }
-    }
-}
-
-/// Describes the parameters of a function.
-#[derive(Debug)]
-pub struct Param<'ir> {
-    pub required: Vec<'ir, (StringId, TextRange)>,
-    pub optional: Vec<'ir, (StringId, TextRange)>,
-    pub ellipsis: bool,
-}
-
-#[derive(Clone, Copy)]
-pub(crate) struct IrKey<'id, 'ir, 'a>(pub IrRef<'id, 'ir>, pub &'a GhostToken<'id>);
-
-impl std::hash::Hash for IrKey<'_, '_, '_> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        ir_content_hash(self.0, self.1, state);
-    }
-}
-
-impl PartialEq for IrKey<'_, '_, '_> {
-    fn eq(&self, other: &Self) -> bool {
-        ir_content_eq(self.0, other.0, self.1)
-    }
-}
-
-impl Eq for IrKey<'_, '_, '_> {}
-
-fn attr_content_hash<'id>(
-    attr: &Attr<IrRef<'id, '_>>,
-    token: &GhostToken<'id>,
-    state: &mut impl Hasher,
-) {
-    core::mem::discriminant(attr).hash(state);
-    match attr {
-        Attr::Dynamic(expr, _) => ir_content_hash(*expr, token, state),
-        Attr::Str(sym, _) => sym.hash(state),
-    }
-}
-
-fn attr_content_eq<'id, 'ir>(
-    a: &Attr<IrRef<'id, 'ir>>,
-    b: &Attr<IrRef<'id, 'ir>>,
-    token: &GhostToken<'id>,
-) -> bool {
-    match (a, b) {
-        (Attr::Dynamic(ae, _), Attr::Dynamic(be, _)) => ir_content_eq(*ae, *be, token),
-        (Attr::Str(a, _), Attr::Str(b, _)) => a == b,
-        _ => false,
-    }
-}
-
-fn param_content_hash(param: &Param<'_>, state: &mut impl Hasher) {
-    param.required.len().hash(state);
-    for (sym, _) in param.required.iter() {
-        sym.hash(state);
-    }
-    param.optional.len().hash(state);
-    for (sym, _) in param.optional.iter() {
-        sym.hash(state);
-    }
-    param.ellipsis.hash(state);
-}
-
-fn param_content_eq(a: &Param<'_>, b: &Param<'_>) -> bool {
-    a.ellipsis == b.ellipsis
-        && a.required.len() == b.required.len()
-        && a.optional.len() == b.optional.len()
-        && a.required
-            .iter()
-            .zip(b.required.iter())
-            .all(|((a, _), (b, _))| a == b)
-        && a.optional
-            .iter()
-            .zip(b.optional.iter())
-            .all(|((a, _), (b, _))| a == b)
-}
-
-fn thunks_content_hash<'id>(
-    thunks: &[(ThunkId, IrRef<'id, '_>)],
-    token: &GhostToken<'id>,
-    state: &mut impl Hasher,
-) {
-    thunks.len().hash(state);
-    for &(id, ir) in thunks {
-        id.hash(state);
-        ir_content_hash(ir, token, state);
-    }
-}
-
-fn thunks_content_eq<'id, 'ir>(
-    a: &[(ThunkId, IrRef<'id, 'ir>)],
-    b: &[(ThunkId, IrRef<'id, 'ir>)],
-    token: &GhostToken<'id>,
-) -> bool {
-    a.len() == b.len()
-        && a.iter()
-            .zip(b.iter())
-            .all(|(&(ai, ae), &(bi, be))| ai == bi && ir_content_eq(ae, be, token))
-}
-
-fn ir_content_hash<'id>(ir: IrRef<'id, '_>, token: &GhostToken<'id>, state: &mut impl Hasher) {
-    let ir = ir.borrow(token);
-    core::mem::discriminant(ir).hash(state);
-    match ir {
-        Ir::Int(x) => x.hash(state),
-        Ir::Float(x) => x.to_bits().hash(state),
-        Ir::Bool(x) => x.hash(state),
-        Ir::Null => {}
-        Ir::Str(x) => x.hash(state),
-        Ir::AttrSet { stcs, dyns } => {
-            stcs.len().hash(state);
-            let mut combined: u64 = 0;
-            for (&key, &(val, _)) in stcs.iter() {
-                let mut h = std::hash::DefaultHasher::new();
-                key.hash(&mut h);
-                ir_content_hash(val, token, &mut h);
-                combined = combined.wrapping_add(h.finish());
-            }
-            combined.hash(state);
-            dyns.len().hash(state);
-            for &(k, v, _) in dyns.iter() {
-                ir_content_hash(k, token, state);
-                ir_content_hash(v, token, state);
-            }
-        }
-        Ir::List { items } => {
-            items.len().hash(state);
-            for &item in items.iter() {
-                ir_content_hash(item, token, state);
-            }
-        }
-        Ir::HasAttr { lhs, rhs } => {
-            ir_content_hash(*lhs, token, state);
-            rhs.len().hash(state);
-            for attr in rhs.iter() {
-                attr_content_hash(attr, token, state);
-            }
-        }
-        &Ir::BinOp { lhs, rhs, kind } => {
-            ir_content_hash(lhs, token, state);
-            ir_content_hash(rhs, token, state);
-            kind.hash(state);
-        }
-        &Ir::UnOp { rhs, kind } => {
-            ir_content_hash(rhs, token, state);
-            kind.hash(state);
-        }
-        Ir::Select {
-            expr,
-            attrpath,
-            default,
-            ..
-        } => {
-            ir_content_hash(*expr, token, state);
-            attrpath.len().hash(state);
-            for attr in attrpath.iter() {
-                attr_content_hash(attr, token, state);
-            }
-            default.is_some().hash(state);
-            if let Some(d) = default {
-                ir_content_hash(*d, token, state);
-            }
-        }
-        &Ir::If { cond, consq, alter } => {
-            ir_content_hash(cond, token, state);
-            ir_content_hash(consq, token, state);
-            ir_content_hash(alter, token, state);
-        }
-        &Ir::Call { func, arg, .. } => {
-            ir_content_hash(func, token, state);
-            ir_content_hash(arg, token, state);
-        }
-        Ir::Assert {
-            assertion,
-            expr,
-            assertion_raw,
-            ..
-        } => {
-            ir_content_hash(*assertion, token, state);
-            ir_content_hash(*expr, token, state);
-            assertion_raw.hash(state);
-        }
-        Ir::ConcatStrings {
-            force_string,
-            parts,
-        } => {
-            force_string.hash(state);
-            parts.len().hash(state);
-            for &part in parts.iter() {
-                ir_content_hash(part, token, state);
-            }
-        }
-        &Ir::Path(expr) => ir_content_hash(expr, token, state),
-        Ir::Func {
-            body,
-            arg,
-            param,
-            thunks,
-        } => {
-            ir_content_hash(*body, token, state);
-            arg.hash(state);
-            param.is_some().hash(state);
-            if let Some(p) = param {
-                param_content_hash(p, state);
-            }
-            thunks_content_hash(thunks, token, state);
-        }
-        Ir::TopLevel { body, thunks } => {
-            ir_content_hash(*body, token, state);
-            thunks_content_hash(thunks, token, state);
-        }
-        Ir::Arg(x) => x.hash(state),
-        Ir::Thunk(x) => x.hash(state),
-        Ir::Builtins => {}
-        Ir::Builtin(x) => x.hash(state),
-        Ir::CurPos(x) => x.hash(state),
-        Ir::ReplBinding(x) => x.hash(state),
-        Ir::ScopedImportBinding(x) => x.hash(state),
-        &Ir::With {
-            namespace,
-            body,
-            ref thunks,
-        } => {
-            ir_content_hash(namespace, token, state);
-            ir_content_hash(body, token, state);
-            thunks_content_hash(thunks, token, state);
-        }
-        Ir::WithLookup(x) => x.hash(state),
-    }
-}
-
-pub(crate) fn ir_content_eq<'id, 'ir>(
-    a: IrRef<'id, 'ir>,
-    b: IrRef<'id, 'ir>,
-    token: &GhostToken<'id>,
-) -> bool {
-    std::ptr::eq(a.0, b.0)
-        || match (a.borrow(token), b.borrow(token)) {
-            (Ir::Int(a), Ir::Int(b)) => a == b,
-            (Ir::Float(a), Ir::Float(b)) => a.to_bits() == b.to_bits(),
-            (Ir::Bool(a), Ir::Bool(b)) => a == b,
-            (Ir::Null, Ir::Null) => true,
-            (Ir::Str(a), Ir::Str(b)) => **a == **b,
-            (
-                Ir::AttrSet {
-                    stcs: a_stcs,
-                    dyns: a_dyns,
-                },
-                Ir::AttrSet {
-                    stcs: b_stcs,
-                    dyns: b_dyns,
-                },
-            ) => {
-                a_stcs.len() == b_stcs.len()
-                    && a_dyns.len() == b_dyns.len()
-                    && a_stcs.iter().all(|(&k, &(av, _))| {
-                        b_stcs
-                            .get(&k)
-                            .is_some_and(|&(bv, _)| ir_content_eq(av, bv, token))
-                    })
-                    && a_dyns
-                        .iter()
-                        .zip(b_dyns.iter())
-                        .all(|(&(ak, av, _), &(bk, bv, _))| {
-                            ir_content_eq(ak, bk, token) && ir_content_eq(av, bv, token)
-                        })
-            }
-            (Ir::List { items: a }, Ir::List { items: b }) => {
-                a.len() == b.len()
-                    && a.iter()
-                        .zip(b.iter())
-                        .all(|(&a, &b)| ir_content_eq(a, b, token))
-            }
-            (Ir::HasAttr { lhs: al, rhs: ar }, Ir::HasAttr { lhs: bl, rhs: br }) => {
-                ir_content_eq(*al, *bl, token)
-                    && ar.len() == br.len()
-                    && ar
-                        .iter()
-                        .zip(br.iter())
-                        .all(|(a, b)| attr_content_eq(a, b, token))
-            }
-            (
-                &Ir::BinOp {
-                    lhs: al,
-                    rhs: ar,
-                    kind: ak,
-                },
-                &Ir::BinOp {
-                    lhs: bl,
-                    rhs: br,
-                    kind: bk,
-                },
-            ) => ak == bk && ir_content_eq(al, bl, token) && ir_content_eq(ar, br, token),
-            (&Ir::UnOp { rhs: ar, kind: ak }, &Ir::UnOp { rhs: br, kind: bk }) => {
-                ak == bk && ir_content_eq(ar, br, token)
-            }
-            (
-                Ir::Select {
-                    expr: ae,
-                    attrpath: aa,
-                    default: ad,
-                    ..
-                },
-                Ir::Select {
-                    expr: be,
-                    attrpath: ba,
-                    default: bd,
-                    ..
-                },
-            ) => {
-                ir_content_eq(*ae, *be, token)
-                    && aa.len() == ba.len()
-                    && aa
-                        .iter()
-                        .zip(ba.iter())
-                        .all(|(a, b)| attr_content_eq(a, b, token))
-                    && match (ad, bd) {
-                        (Some(a), Some(b)) => ir_content_eq(*a, *b, token),
-                        (None, None) => true,
-                        _ => false,
-                    }
-            }
-            (
-                &Ir::If {
-                    cond: ac,
-                    consq: acs,
-                    alter: aa,
-                },
-                &Ir::If {
-                    cond: bc,
-                    consq: bcs,
-                    alter: ba,
-                },
-            ) => {
-                ir_content_eq(ac, bc, token)
-                    && ir_content_eq(acs, bcs, token)
-                    && ir_content_eq(aa, ba, token)
-            }
-            (
-                &Ir::Call {
-                    func: af, arg: aa, ..
-                },
-                &Ir::Call {
-                    func: bf, arg: ba, ..
-                },
-            ) => ir_content_eq(af, bf, token) && ir_content_eq(aa, ba, token),
-            (
-                Ir::Assert {
-                    assertion: aa,
-                    expr: ae,
-                    assertion_raw: ar,
-                    ..
-                },
-                Ir::Assert {
-                    assertion: ba,
-                    expr: be,
-                    assertion_raw: br,
-                    ..
-                },
-            ) => ar == br && ir_content_eq(*aa, *ba, token) && ir_content_eq(*ae, *be, token),
-            (
-                Ir::ConcatStrings {
-                    force_string: af,
-                    parts: ap,
-                },
-                Ir::ConcatStrings {
-                    force_string: bf,
-                    parts: bp,
-                },
-            ) => {
-                af == bf
-                    && ap.len() == bp.len()
-                    && ap
-                        .iter()
-                        .zip(bp.iter())
-                        .all(|(&a, &b)| ir_content_eq(a, b, token))
-            }
-            (&Ir::Path(a), &Ir::Path(b)) => ir_content_eq(a, b, token),
-            (
-                Ir::Func {
-                    body: ab,
-                    arg: aa,
-                    param: ap,
-                    thunks: at,
-                },
-                Ir::Func {
-                    body: bb,
-                    arg: ba,
-                    param: bp,
-                    thunks: bt,
-                },
-            ) => {
-                ir_content_eq(*ab, *bb, token)
-                    && aa == ba
-                    && match (ap, bp) {
-                        (Some(a), Some(b)) => param_content_eq(a, b),
-                        (None, None) => true,
-                        _ => false,
-                    }
-                    && thunks_content_eq(at, bt, token)
-            }
-            (
-                Ir::TopLevel {
-                    body: ab,
-                    thunks: at,
-                },
-                Ir::TopLevel {
-                    body: bb,
-                    thunks: bt,
-                },
-            ) => ir_content_eq(*ab, *bb, token) && thunks_content_eq(at, bt, token),
-            (Ir::Arg(a), Ir::Arg(b)) => a == b,
-            (Ir::Thunk(a), Ir::Thunk(b)) => a == b,
-            (Ir::Builtins, Ir::Builtins) => true,
-            (Ir::Builtin(a), Ir::Builtin(b)) => a == b,
-            (Ir::CurPos(a), Ir::CurPos(b)) => a == b,
-            (Ir::ReplBinding(a), Ir::ReplBinding(b)) => a == b,
-            (Ir::ScopedImportBinding(a), Ir::ScopedImportBinding(b)) => a == b,
-            (
-                Ir::With {
-                    namespace: a_ns,
-                    body: a_body,
-                    thunks: a_thunks,
-                },
-                Ir::With {
-                    namespace: b_ns,
-                    body: b_body,
-                    thunks: b_thunks,
-                },
-            ) => {
-                ir_content_eq(*a_ns, *b_ns, token)
-                    && ir_content_eq(*a_body, *b_body, token)
-                    && thunks_content_eq(a_thunks, b_thunks, token)
-            }
-            (Ir::WithLookup(a), Ir::WithLookup(b)) => a == b,
-            _ => false,
-        }
-}

fix/src/main.rs

@@ -1,152 +0,0 @@
-use std::path::PathBuf;
-use std::process::exit;
-
-use anyhow::Result;
-use clap::{Args, Parser, Subcommand};
-use fix::error::Source;
-use fix::runtime::Runtime;
-use hashbrown::HashSet;
-use rustyline::DefaultEditor;
-use rustyline::error::ReadlineError;
-
-#[derive(Parser)]
-#[command(name = "nix-js", about = "Nix expression evaluator")]
-struct Cli {
-    #[command(subcommand)]
-    command: Command,
-}
-
-#[derive(Subcommand)]
-enum Command {
-    Compile {
-        #[clap(flatten)]
-        source: ExprSource,
-        #[arg(long)]
-        silent: bool,
-    },
-    Eval {
-        #[clap(flatten)]
-        source: ExprSource,
-    },
-    Repl,
-}
-
-#[derive(Args)]
-#[group(required = true, multiple = false)]
-struct ExprSource {
-    #[clap(short, long)]
-    expr: Option<String>,
-    #[clap(short, long)]
-    file: Option<PathBuf>,
-}
-
-fn run_compile(runtime: &mut Runtime, src: ExprSource, silent: bool) -> Result<()> {
-    let src = if let Some(expr) = src.expr {
-        Source::new_eval(expr)?
-    } else if let Some(file) = src.file {
-        Source::new_file(file)?
-    } else {
-        unreachable!()
-    };
-    todo!()
-    /* match runtime.compile_bytecode(src) {
-        Ok(compiled) => {
-            if !silent {
-                println!("{}", runtime.disassemble_colored(&compiled));
-            }
-        }
-        Err(err) => {
-            eprintln!("{:?}", miette::Report::new(*err));
-            exit(1);
-        }
-    };
-    Ok(()) */
-}
-
-fn run_eval(runtime: &mut Runtime, src: ExprSource) -> Result<()> {
-    let src = if let Some(expr) = src.expr {
-        Source::new_eval(expr)?
-    } else if let Some(file) = src.file {
-        Source::new_file(file)?
-    } else {
-        unreachable!()
-    };
-    match runtime.eval_deep(src) {
-        Ok(value) => {
-            println!("{}", value.display_compat());
-        }
-        Err(err) => {
-            eprintln!("{:?}", miette::Report::new(*err));
-            exit(1);
-        }
-    };
-    Ok(())
-}
-
-fn run_repl(runtime: &mut Runtime) -> Result<()> {
-    let mut rl = DefaultEditor::new()?;
-    let mut scope = HashSet::new();
-    const RE: ere::Regex<3> = ere::compile_regex!("^[ \t]*([a-zA-Z_][a-zA-Z0-9_'-]*)[ \t]*(.*)$");
-    loop {
-        let readline = rl.readline("nix-js-repl> ");
-        match readline {
-            Ok(line) => {
-                if line.trim().is_empty() {
-                    continue;
-                }
-                let _ = rl.add_history_entry(line.as_str());
-                if let Some([Some(_), Some(ident), Some(rest)]) = RE.exec(&line) {
-                    if let Some(expr) = rest.strip_prefix('=') {
-                        let expr = expr.trim_start();
-                        if expr.is_empty() {
-                            eprintln!("Error: missing expression after '='");
-                            continue;
-                        }
-                        match runtime.add_binding(ident, expr, &mut scope) {
-                            Ok(value) => println!("{} = {}", ident, value),
-                            Err(err) => eprintln!("{:?}", miette::Report::new(*err)),
-                        }
-                    } else {
-                        let src = Source::new_repl(line)?;
-                        match runtime.eval_repl(src, &scope) {
-                            Ok(value) => println!("{value}"),
-                            Err(err) => eprintln!("{:?}", miette::Report::new(*err)),
-                        }
-                    }
-                } else {
-                    let src = Source::new_repl(line)?;
-                    match runtime.eval_repl(src, &scope) {
-                        Ok(value) => println!("{value}"),
-                        Err(err) => eprintln!("{:?}", miette::Report::new(*err)),
-                    }
-                }
-            }
-            Err(ReadlineError::Interrupted) => {
-                println!();
-            }
-            Err(ReadlineError::Eof) => {
-                println!("CTRL-D");
-                break;
-            }
-            Err(err) => {
-                eprintln!("Error: {err:?}");
-                break;
-            }
-        }
-    }
-    Ok(())
-}
-
-fn main() -> Result<()> {
-    fix::logging::init_logging();
-
-    let cli = Cli::parse();
-
-    let mut runtime = Runtime::new()?;
-
-    match cli.command {
-        Command::Compile { source, silent } => run_compile(&mut runtime, source, silent),
-        Command::Eval { source } => run_eval(&mut runtime, source),
-        Command::Repl => run_repl(&mut runtime),
-    }
-}

fix/src/nix_utils.rs

@@ -1,21 +0,0 @@
-use nix_compat::store_path::compress_hash;
-use sha2::{Digest as _, Sha256};
-
-pub fn sha256_hex(data: &[u8]) -> String {
-    let mut hasher = Sha256::new();
-    hasher.update(data);
-    hex::encode(hasher.finalize())
-}
-
-pub fn make_store_path(store_dir: &str, ty: &str, hash_hex: &str, name: &str) -> String {
-    let s = format!("{}:sha256:{}:{}:{}", ty, hash_hex, store_dir, name);
-
-    let mut hasher = Sha256::new();
-    hasher.update(s.as_bytes());
-    let hash: [u8; 32] = hasher.finalize().into();
-
-    let compressed = compress_hash::<20>(&hash);
-    let encoded = nix_compat::nixbase32::encode(&compressed);
-
-    format!("{}/{}-{}", store_dir, encoded, name)
-}

fix/src/runtime.rs

@@ -1,531 +0,0 @@
-use std::hash::BuildHasher;
-
-use bumpalo::Bump;
-use gc_arena::{Arena, Rootable, arena::CollectionPhase};
-use ghost_cell::{GhostCell, GhostToken};
-use hashbrown::{DefaultHashBuilder, HashMap, HashSet, HashTable};
-use rnix::TextRange;
-use string_interner::DefaultStringInterner;
-
-use crate::codegen::{BytecodeContext, InstructionPtr};
-use crate::downgrade::{Downgrade as _, DowngradeContext};
-use crate::error::{Error, Result, Source};
-use crate::ir::{ArgId, Ir, IrKey, IrRef, RawIrRef, StringId, ThunkId, ir_content_eq};
-use crate::runtime::builtins::new_builtins_env;
-use crate::store::{DaemonStore, StoreConfig};
-use crate::value::Symbol;
-
-mod builtins;
-mod stack;
-mod value;
-mod vm;
-use vm::{Action, VM};
-
-pub struct Runtime {
-    bytecode: Vec<u8>,
-    global_env: HashMap<StringId, Ir<'static, RawIrRef<'static>>>,
-    sources: Vec<Source>,
-    store: DaemonStore,
-    spans: Vec<(usize, TextRange)>,
-    thunk_count: usize,
-    strings: DefaultStringInterner,
-    arena: Arena<Rootable![VM<'_>]>,
-}
-
-impl Runtime {
-    const COLLECTOR_GRANULARITY: f64 = 1024.0;
-
-    pub fn new() -> Result<Self> {
-        let mut strings = DefaultStringInterner::new();
-        let global_env = new_builtins_env(&mut strings);
-
-        let config = StoreConfig::from_env();
-        let store = DaemonStore::connect(&config.daemon_socket)?;
-
-        Ok(Self {
-            global_env,
-            store,
-            strings,
-            thunk_count: 0,
-            bytecode: Vec::new(),
-            sources: Vec::new(),
-            spans: Vec::new(),
-            arena: Arena::new(|mc| VM::new(mc)),
-        })
-    }
-
-    pub fn eval(&mut self, source: Source) -> Result<crate::value::Value> {
-        let root = self.downgrade(source, None)?;
-        let ip = crate::codegen::compile_bytecode(root.as_ref(), self);
-        self.run(ip)
-    }
-
-    pub fn eval_shallow(&mut self, _source: Source) -> Result<crate::value::Value> {
-        todo!()
-    }
-
-    pub fn eval_deep(&mut self, source: Source) -> Result<crate::value::Value> {
-        // FIXME: deep
-        let root = self.downgrade(source, None)?;
-        let ip = crate::codegen::compile_bytecode(root.as_ref(), self);
-        self.run(ip)
-    }
-
-    pub fn eval_repl(
-        &mut self,
-        source: Source,
-        scope: &HashSet<StringId>,
-    ) -> Result<crate::value::Value> {
-        // FIXME: shallow
-        let root = self.downgrade(source, Some(Scope::Repl(scope)))?;
-        let ip = crate::codegen::compile_bytecode(root.as_ref(), self);
-        self.run(ip)
-    }
-
-    pub fn add_binding(
-        &mut self,
-        _ident: &str,
-        _expr: &str,
-        _scope: &mut HashSet<StringId>,
-    ) -> Result<crate::value::Value> {
-        todo!()
-    }
-
-    fn downgrade_ctx<'a, 'bump, 'id>(
-        &'a mut self,
-        bump: &'bump Bump,
-        token: GhostToken<'id>,
-        extra_scope: Option<Scope<'a>>,
-    ) -> DowngradeCtx<'a, 'id, 'bump> {
-        let Runtime {
-            global_env,
-            sources,
-            thunk_count,
-            strings,
-            ..
-        } = self;
-        DowngradeCtx {
-            bump,
-            token,
-            strings,
-            source: sources.last().unwrap().clone(),
-            scopes: [Scope::Global(global_env)].into_iter().chain(extra_scope.into_iter()).collect(),
-            with_scope_count: 0,
-            arg_count: 0,
-            thunk_count,
-            thunk_scopes: vec![ThunkScope::new_in(bump)],
-        }
-    }
-
-    fn downgrade<'a>(&'a mut self, source: Source, extra_scope: Option<Scope<'a>>) -> Result<OwnedIr> {
-        tracing::debug!("Parsing Nix expression");
-
-        self.sources.push(source.clone());
-
-        let root = rnix::Root::parse(&source.src);
-        handle_parse_error(root.errors(), source).map_or(Ok(()), Err)?;
-
-        tracing::debug!("Downgrading Nix expression");
-        let expr = root
-            .tree()
-            .expr()
-            .ok_or_else(|| Error::parse_error("unexpected EOF".into()))?;
-        let bump = Bump::new();
-        GhostToken::new(|token| {
-            let ir = self
-                .downgrade_ctx(&bump, token, extra_scope)
-                .downgrade_toplevel(expr)?;
-            let ir = unsafe { std::mem::transmute::<RawIrRef<'_>, RawIrRef<'static>>(ir) };
-            Ok(OwnedIr { _bump: bump, ir })
-        })
-    }
-
-    fn run(&mut self, ip: InstructionPtr) -> Result<crate::value::Value> {
-        let mut pc = ip.0;
-        loop {
-            let Runtime {
-                bytecode,
-                strings,
-                arena,
-                ..
-            } = self;
-            let action =
-                arena.mutate_root(|mc, root| root.run_batch(bytecode, &mut pc, mc, strings));
-            match action {
-                Action::NeedGc => {
-                    if self.arena.collection_phase() == CollectionPhase::Sweeping {
-                        self.arena.collect_debt();
-                    } else if let Some(marked) = self.arena.mark_debt() {
-                        marked.start_sweeping();
-                    }
-                }
-                Action::Done(done) => {
-                    break done;
-                }
-                Action::Continue => (),
-                Action::IoRequest(_) => todo!(),
-            }
-        }
-    }
-}
-
-fn parse_error_span(error: &rnix::ParseError) -> Option<rnix::TextRange> {
-    use rnix::ParseError::*;
-    match error {
-        Unexpected(range)
-        | UnexpectedExtra(range)
-        | UnexpectedWanted(_, range, _)
-        | UnexpectedDoubleBind(range)
-        | DuplicatedArgs(range, _) => Some(*range),
-        _ => None,
-    }
-}
-
-fn handle_parse_error<'a>(
-    errors: impl IntoIterator<Item = &'a rnix::ParseError>,
-    source: Source,
-) -> Option<Box<Error>> {
-    for err in errors {
-        if let Some(span) = parse_error_span(err) {
-            return Some(
-                Error::parse_error(err.to_string())
-                    .with_source(source)
-                    .with_span(span),
-            );
-        }
-    }
-    None
-}
-
-struct DowngradeCtx<'ctx, 'id, 'ir> {
-    bump: &'ir Bump,
-    token: GhostToken<'id>,
-    strings: &'ctx mut DefaultStringInterner,
-    source: Source,
-    scopes: Vec<Scope<'ctx>>,
-    with_scope_count: u32,
-    arg_count: u32,
-    thunk_count: &'ctx mut usize,
-    thunk_scopes: Vec<ThunkScope<'id, 'ir>>,
-}
-
-fn should_thunk<'id>(ir: IrRef<'id, '_>, token: &GhostToken<'id>) -> bool {
-    !matches!(
-        ir.borrow(token),
-        Ir::Builtin(_)
-            | Ir::Builtins
-            | Ir::Int(_)
-            | Ir::Float(_)
-            | Ir::Bool(_)
-            | Ir::Null
-            | Ir::Str(_)
-            | Ir::Thunk(_)
-    )
-}
-
-impl<'ctx, 'id, 'ir> DowngradeCtx<'ctx, 'id, 'ir> {
-    fn new(
-        bump: &'ir Bump,
-        token: GhostToken<'id>,
-        symbols: &'ctx mut DefaultStringInterner,
-        global: &'ctx HashMap<StringId, Ir<'static, RawIrRef<'static>>>,
-        extra_scope: Option<Scope<'ctx>>,
-        thunk_count: &'ctx mut usize,
-        source: Source,
-    ) -> Self {
-        Self {
-            bump,
-            token,
-            strings: symbols,
-            source,
-            scopes: std::iter::once(Scope::Global(global))
-                .chain(extra_scope)
-                .collect(),
-            thunk_count,
-            arg_count: 0,
-            with_scope_count: 0,
-            thunk_scopes: vec![ThunkScope::new_in(bump)],
-        }
-    }
-}
-
-impl<'ctx: 'ir, 'id, 'ir> DowngradeContext<'id, 'ir> for DowngradeCtx<'ctx, 'id, 'ir> {
-    fn new_expr(&self, expr: Ir<'ir, IrRef<'id, 'ir>>) -> IrRef<'id, 'ir> {
-        IrRef::new(self.bump.alloc(GhostCell::new(expr)))
-    }
-
-    fn new_arg(&mut self) -> ArgId {
-        self.arg_count += 1;
-        ArgId(self.arg_count - 1)
-    }
-
-    fn maybe_thunk(&mut self, ir: IrRef<'id, 'ir>) -> IrRef<'id, 'ir> {
-        if !should_thunk(ir, &self.token) {
-            return ir;
-        }
-
-        let cached = self
-            .thunk_scopes
-            .last()
-            .expect("no active cache scope")
-            .lookup_cache(ir, &self.token);
-
-        if let Some(id) = cached {
-            return IrRef::alloc(self.bump, Ir::Thunk(id));
-        }
-
-        let id = ThunkId(*self.thunk_count);
-        *self.thunk_count = self.thunk_count.checked_add(1).expect("thunk id overflow");
-        self.thunk_scopes
-            .last_mut()
-            .expect("no active cache scope")
-            .add_binding(id, ir, &self.token);
-        IrRef::alloc(self.bump, Ir::Thunk(id))
-    }
-
-    fn new_sym(&mut self, sym: String) -> StringId {
-        StringId(self.strings.get_or_intern(sym))
-    }
-
-    fn get_sym(&self, id: StringId) -> Symbol<'_> {
-        self.strings.resolve(id.0).expect("no symbol found").into()
-    }
-
-    fn lookup(&self, sym: StringId, span: TextRange) -> Result<IrRef<'id, 'ir>> {
-        for scope in self.scopes.iter().rev() {
-            match scope {
-                &Scope::Global(global_scope) => {
-                    if let Some(expr) = global_scope.get(&sym) {
-                        let ir = match expr {
-                            Ir::Builtins => Ir::Builtins,
-                            Ir::Builtin(s) => Ir::Builtin(*s),
-                            Ir::Bool(b) => Ir::Bool(*b),
-                            Ir::Null => Ir::Null,
-                            _ => unreachable!("globals should only contain leaf IR nodes"),
-                        };
-                        return Ok(self.new_expr(ir));
-                    }
-                }
-                &Scope::Repl(repl_bindings) => {
-                    if repl_bindings.contains(&sym) {
-                        return Ok(self.new_expr(Ir::ReplBinding(sym)));
-                    }
-                }
-                Scope::ScopedImport(scoped_bindings) => {
-                    if scoped_bindings.contains(&sym) {
-                        return Ok(self.new_expr(Ir::ScopedImportBinding(sym)));
-                    }
-                }
-                Scope::Let(let_scope) => {
-                    if let Some(&expr) = let_scope.get(&sym) {
-                        return Ok(self.new_expr(Ir::Thunk(expr)));
-                    }
-                }
-                &Scope::Param(param_sym, id) => {
-                    if param_sym == sym {
-                        return Ok(self.new_expr(Ir::Arg(id)));
-                    }
-                }
-            }
-        }
-
-        if self.with_scope_count > 0 {
-            Ok(self.new_expr(Ir::WithLookup(sym)))
-        } else {
-            Err(Error::downgrade_error(
-                format!("'{}' not found", self.get_sym(sym)),
-                self.get_current_source(),
-                span,
-            ))
-        }
-    }
-
-    fn get_current_source(&self) -> Source {
-        self.source.clone()
-    }
-
-    fn with_let_scope<F, R>(&mut self, keys: &[StringId], f: F) -> Result<R>
-    where
-        F: FnOnce(&mut Self) -> Result<(bumpalo::collections::Vec<'ir, IrRef<'id, 'ir>>, R)>,
-    {
-        let base = *self.thunk_count;
-        *self.thunk_count = self
-            .thunk_count
-            .checked_add(keys.len())
-            .expect("thunk id overflow");
-        let iter = keys.iter().enumerate().map(|(offset, &key)| {
-            (
-                key,
-                ThunkId(unsafe { base.checked_add(offset).unwrap_unchecked() }),
-            )
-        });
-        self.scopes.push(Scope::Let(iter.collect()));
-        let (vals, ret) = {
-            let mut guard = ScopeGuard { ctx: self };
-            f(guard.as_ctx())?
-        };
-        assert_eq!(keys.len(), vals.len());
-        let scope = self.thunk_scopes.last_mut().expect("no active thunk scope");
-        scope.extend_bindings((base..base + keys.len()).map(ThunkId).zip(vals));
-        Ok(ret)
-    }
-
-    fn with_param_scope<F, R>(&mut self, param: StringId, arg: ArgId, f: F) -> R
-    where
-        F: FnOnce(&mut Self) -> R,
-    {
-        self.scopes.push(Scope::Param(param, arg));
-        let mut guard = ScopeGuard { ctx: self };
-        f(guard.as_ctx())
-    }
-
-    fn with_with_scope<F, R>(&mut self, f: F) -> R
-    where
-        F: FnOnce(&mut Self) -> R,
-    {
-        self.with_scope_count += 1;
-        let ret = f(self);
-        self.with_scope_count -= 1;
-        ret
-    }
-
-    fn with_thunk_scope<F, R>(
-        &mut self,
-        f: F,
-    ) -> (
-        R,
-        bumpalo::collections::Vec<'ir, (ThunkId, IrRef<'id, 'ir>)>,
-    )
-    where
-        F: FnOnce(&mut Self) -> R,
-    {
-        self.thunk_scopes.push(ThunkScope::new_in(self.bump));
-        let ret = f(self);
-        (
-            ret,
-            self.thunk_scopes
-                .pop()
-                .expect("no thunk scope left???")
-                .bindings,
-        )
-    }
-
-    fn bump(&self) -> &'ir bumpalo::Bump {
-        self.bump
-    }
-}
-
-impl<'id, 'ir, 'ctx: 'ir> DowngradeCtx<'ctx, 'id, 'ir> {
-    fn downgrade_toplevel(mut self, root: rnix::ast::Expr) -> Result<RawIrRef<'ir>> {
-        let body = root.downgrade(&mut self)?;
-        let thunks = self
-            .thunk_scopes
-            .pop()
-            .expect("no thunk scope left???")
-            .bindings;
-        let ir = IrRef::alloc(self.bump, Ir::TopLevel { body, thunks });
-        Ok(ir.freeze(self.token))
-    }
-}
-
-struct ThunkScope<'id, 'ir> {
-    bindings: bumpalo::collections::Vec<'ir, (ThunkId, IrRef<'id, 'ir>)>,
-    cache: HashTable<(IrRef<'id, 'ir>, ThunkId)>,
-    hasher: DefaultHashBuilder,
-}
-
-impl<'id, 'ir> ThunkScope<'id, 'ir> {
-    fn new_in(bump: &'ir Bump) -> Self {
-        Self {
-            bindings: bumpalo::collections::Vec::new_in(bump),
-            cache: HashTable::new(),
-            hasher: DefaultHashBuilder::default(),
-        }
-    }
-
-    fn lookup_cache(&self, key: IrRef<'id, 'ir>, token: &GhostToken<'id>) -> Option<ThunkId> {
-        let hash = self.hasher.hash_one(IrKey(key, token));
-        self.cache
-            .find(hash, |&(ir, _)| ir_content_eq(key, ir, token))
-            .map(|&(_, id)| id)
-    }
-
-    fn add_binding(&mut self, id: ThunkId, ir: IrRef<'id, 'ir>, token: &GhostToken<'id>) {
-        self.bindings.push((id, ir));
-        let hash = self.hasher.hash_one(IrKey(ir, token));
-        self.cache.insert_unique(hash, (ir, id), |&(ir, _)| {
-            self.hasher.hash_one(IrKey(ir, token))
-        });
-    }
-
-    fn extend_bindings(&mut self, iter: impl IntoIterator<Item = (ThunkId, IrRef<'id, 'ir>)>) {
-        self.bindings.extend(iter);
-    }
-}
-
-enum Scope<'ctx> {
-    Global(&'ctx HashMap<StringId, Ir<'static, RawIrRef<'static>>>),
-    Repl(&'ctx HashSet<StringId>),
-    ScopedImport(HashSet<StringId>),
-    Let(HashMap<StringId, ThunkId>),
-    Param(StringId, ArgId),
-}
-
-struct ScopeGuard<'a, 'ctx, 'id, 'ir> {
-    ctx: &'a mut DowngradeCtx<'ctx, 'id, 'ir>,
-}
-
-impl Drop for ScopeGuard<'_, '_, '_, '_> {
-    fn drop(&mut self) {
-        self.ctx.scopes.pop();
-    }
-}
-
-impl<'id, 'ir, 'ctx> ScopeGuard<'_, 'ctx, 'id, 'ir> {
-    fn as_ctx(&mut self) -> &mut DowngradeCtx<'ctx, 'id, 'ir> {
-        self.ctx
-    }
-}
-
-struct OwnedIr {
-    _bump: Bump,
-    ir: RawIrRef<'static>,
-}
-
-impl OwnedIr {
-    unsafe fn new(ir: RawIrRef<'_>, bump: Bump) -> Self {
-        Self {
-            _bump: bump,
-            ir: unsafe { std::mem::transmute::<RawIrRef<'_>, RawIrRef<'static>>(ir) }
-        }
-    }
-
-    fn as_ref(&self) -> RawIrRef<'_> {
-        self.ir
-    }
-}
-
-impl BytecodeContext for Runtime {
-    fn intern_string(&mut self, s: &str) -> StringId {
-        StringId(self.strings.get_or_intern(s))
-    }
-
-    fn register_span(&mut self, range: TextRange) -> u32 {
-        let id = self.spans.len();
-        let source_id = self
-            .sources
-            .len()
-            .checked_sub(1)
-            .expect("current_source not set");
-        self.spans.push((source_id, range));
-        id as u32
-    }
-
-    fn get_code(&self) -> &[u8] {
-        &self.bytecode
-    }
-
-    fn get_code_mut(&mut self) -> &mut Vec<u8> {
-        &mut self.bytecode
-    }
-}

fix/src/runtime/builtins.rs

@@ -1,51 +0,0 @@
-use hashbrown::HashMap;
-use string_interner::DefaultStringInterner;
-
-use crate::ir::{Ir, RawIrRef, StringId};
-
-pub(super) fn new_builtins_env(
-    interner: &mut DefaultStringInterner,
-) -> HashMap<StringId, Ir<'static, RawIrRef<'static>>> {
-    let mut builtins = HashMap::new();
-    let builtins_sym = StringId(interner.get_or_intern("builtins"));
-    builtins.insert(builtins_sym, Ir::Builtins);
-
-    let free_globals = [
-        "abort",
-        "baseNameOf",
-        "break",
-        "dirOf",
-        "derivation",
-        "derivationStrict",
-        "fetchGit",
-        "fetchMercurial",
-        "fetchTarball",
-        "fetchTree",
-        "fromTOML",
-        "import",
-        "isNull",
-        "map",
-        "placeholder",
-        "removeAttrs",
-        "scopedImport",
-        "throw",
-        "toString",
-    ];
-    let consts = [
-        ("true", Ir::Bool(true)),
-        ("false", Ir::Bool(false)),
-        ("null", Ir::Null),
-    ];
-
-    for name in free_globals {
-        let name = StringId(interner.get_or_intern(name));
-        let value = Ir::Builtin(name);
-        builtins.insert(name, value);
-    }
-    for (name, value) in consts {
-        let name = StringId(interner.get_or_intern(name));
-        builtins.insert(name, value);
-    }
-
-    builtins
-}

fix/src/runtime/corepkgs/derivation.nix

@@ -1,31 +0,0 @@
-drvAttrs@{
-  outputs ? [ "out" ],
-  ...
-}:
-
-let
-
-  strict = derivationStrict drvAttrs;
-
-  commonAttrs =
-    drvAttrs
-    // (builtins.listToAttrs outputsList)
-    // {
-      all = map (x: x.value) outputsList;
-      inherit drvAttrs;
-    };
-
-  outputToAttrListElement = outputName: {
-    name = outputName;
-    value = commonAttrs // {
-      outPath = builtins.getAttr outputName strict;
-      drvPath = strict.drvPath;
-      type = "derivation";
-      inherit outputName;
-    };
-  };
-
-  outputsList = map outputToAttrListElement outputs;
-
-in
-(builtins.head outputsList).value

fix/src/runtime/stack.rs

@@ -1,89 +0,0 @@
-use std::mem::MaybeUninit;
-
-use gc_arena::Collect;
-use smallvec::SmallVec;
-
-// FIXME: Drop???
-pub(super) struct Stack<const N: usize, T> {
-    inner: Box<[MaybeUninit<T>; N]>,
-    len: usize,
-}
-
-unsafe impl<'gc, const N: usize, T: Collect<'gc> + 'gc> Collect<'gc> for Stack<N, T> {
-    const NEEDS_TRACE: bool = true;
-    fn trace<U: gc_arena::collect::Trace<'gc>>(&self, cc: &mut U) {
-        for item in self.inner[..self.len].iter() {
-            unsafe {
-                item.assume_init_ref().trace(cc);
-            }
-        }
-    }
-}
-
-impl<const N: usize, T> Default for Stack<N, T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<const N: usize, T> Stack<N, T> {
-    pub(super) fn new() -> Self {
-        Self {
-            inner: Box::new([const { MaybeUninit::uninit() }; N]),
-            len: 0,
-        }
-    }
-
-    pub(super) fn push(&mut self, val: T) -> Result<(), T> {
-        if self.len == N {
-            return Err(val);
-        }
-        unsafe {
-            self.inner.get_unchecked_mut(self.len).write(val);
-        }
-        self.len += 1;
-        Ok(())
-    }
-
-    pub(super) fn pop(&mut self) -> Option<T> {
-        if self.len == 0 {
-            return None;
-        }
-        let ret = unsafe {
-            self.inner
-                .get_unchecked_mut(self.len - 1)
-                .assume_init_read()
-        };
-        self.len -= 1;
-        Some(ret)
-    }
-
-    pub(super) fn tos(&self) -> Option<&T> {
-        if self.len == 0 {
-            return None;
-        }
-        Some(unsafe { self.inner.get_unchecked(self.len - 1).assume_init_ref() })
-    }
-
-    pub(super) fn tos_mut(&mut self) -> Option<&mut T> {
-        if self.len == 0 {
-            return None;
-        }
-        Some(unsafe { self.inner.get_unchecked_mut(self.len - 1).assume_init_mut() })
-    }
-
-    pub(super) fn len(&self) -> usize {
-        self.len
-    }
-
-    pub(super) fn pop_n<const M: usize>(&mut self, n: usize) -> SmallVec<[T; M]> {
-        assert!(n <= self.len, "pop_n: not enough items on stack");
-        let mut result = SmallVec::new();
-        let start = self.len - n;
-        for i in start..self.len {
-            result.push(unsafe { self.inner.get_unchecked(i).assume_init_read() });
-        }
-        self.len = start;
-        result
-    }
-}

fix/src/runtime/value.rs

@@ -1,489 +0,0 @@
-use std::fmt;
-use std::marker::PhantomData;
-use std::mem::size_of;
-use std::ops::Deref;
-
-use boxing::nan::raw::{RawBox, RawStore, RawTag, Value as RawValue};
-use gc_arena::{Collect, Gc, Mutation, RefLock, collect::Trace};
-use sealed::sealed;
-use smallvec::SmallVec;
-use string_interner::{Symbol, symbol::SymbolU32};
-
-use crate::ir::StringId;
-
-#[sealed]
-pub(crate) trait Storable {
-    const TAG: (bool, u8);
-}
-pub(crate) trait InlineStorable: Storable + RawStore {}
-pub(crate) trait GcStorable: Storable {}
-
-macro_rules! define_value_types {
-    (
-        inline { $($itype:ty => $itag:expr, $iname:literal;)* }
-        gc { $($gtype:ty => $gtag:expr, $gname:literal;)* }
-    ) => {
-        $(
-        #[sealed]
-        impl Storable for $itype {
-            const TAG: (bool, u8) = $itag;
-        }
-        impl InlineStorable for $itype {}
-        )*
-        $(
-        #[sealed]
-        impl Storable for $gtype {
-            const TAG: (bool, u8) = $gtag;
-        }
-        impl GcStorable for $gtype {}
-        )*
-
-        const _: () = assert!(size_of::<Value<'static>>() == 8);
-        $(const _: () = assert!(size_of::<$itype>() <= 6);)*
-        $(const _: () = { let (_, val) = $itag; assert!(val >= 1 && val <= 7); };)*
-        $(const _: () = { let (_, val) = $gtag; assert!(val >= 1 && val <= 7); };)*
-
-        const _: () = {
-            let tags: &[(bool, u8)] = &[$($itag),*, $($gtag),*];
-            let mut mask_false: u8 = 0;
-            let mut mask_true: u8 = 0;
-            let mut i = 0;
-            while i < tags.len() {
-                let (neg, val) = tags[i];
-                let bit = 1 << val;
-                if neg {
-                    assert!(mask_true & bit == 0, "duplicate true tag id");
-                    mask_true |= bit;
-                } else {
-                    assert!(mask_false & bit == 0, "duplicate false tag id");
-                    mask_false |= bit;
-                }
-                i += 1;
-            }
-        };
-
-        unsafe impl<'gc> Collect<'gc> for Value<'gc> {
-            const NEEDS_TRACE: bool = true;
-            fn trace<T: Trace<'gc>>(&self, cc: &mut T) {
-                let Some(tag) = self.raw.tag() else { return };
-                match tag.neg_val() {
-                    $(<$gtype as Storable>::TAG => unsafe {
-                        self.load_gc::<$gtype>().trace(cc)
-                    },)*
-                    $(<$itype as Storable>::TAG => (),)*
-                    (neg, val) => unreachable!("invalid tag: neg={neg}, val={val}"),
-                }
-            }
-        }
-
-        impl fmt::Debug for Value<'_> {
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                match self.tag() {
-                    None => write!(f, "Float({:?})", unsafe {
-                        self.raw.float().unwrap_unchecked()
-                    }),
-                    $(Some(<$itype as Storable>::TAG) => write!(f, "{}({:?})", $iname, unsafe {
-                        self.as_inline::<$itype>().unwrap_unchecked()
-                    }),)*
-                    $(Some(<$gtype as Storable>::TAG) =>
-                        write!(f, "{}({:?})", $gname, unsafe { self.as_gc::<$gtype>().unwrap_unchecked() }),)*
-                    Some((neg, val)) => write!(f, "Unknown(neg={neg}, val={val})"),
-                }
-            }
-        }
-    };
-}
-
-define_value_types! {
-    inline {
-        i32 => (false, 1), "SmallInt";
-        bool => (false, 2), "Bool";
-        Null => (false, 3), "Null";
-        StringId => (false, 4), "SmallString";
-        PrimOp => (false, 5), "PrimOp";
-    }
-    gc {
-        i64 => (false, 6), "BigInt";
-        NixString => (false, 7), "String";
-        AttrSet<'_> => (true, 1), "AttrSet";
-        List<'_> => (true, 2), "List";
-        Thunk<'_> => (true, 3), "Thunk";
-        Closure<'_> => (true, 4), "Closure";
-        PrimOpApp<'_> => (true, 5), "PrimOpApp";
-    }
-}
-
-/// # Nix runtime value representation
-///
-/// NaN-boxed value fitting in 8 bytes.
-#[repr(transparent)]
-pub(crate) struct Value<'gc> {
-    raw: RawBox,
-    _marker: PhantomData<Gc<'gc, ()>>,
-}
-
-impl Clone for Value<'_> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self {
-            raw: self.raw.clone(),
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl Default for Value<'_> {
-    #[inline(always)]
-    fn default() -> Self {
-        Self::new_inline(Null)
-    }
-}
-
-impl<'gc> Value<'gc> {
-    #[inline(always)]
-    fn mk_tag(neg: bool, val: u8) -> RawTag {
-        // Safety: val is asserted to be in 1..=7.
-        unsafe { RawTag::new_unchecked(neg, val) }
-    }
-
-    #[inline(always)]
-    fn from_raw_value(rv: RawValue) -> Self {
-        Self {
-            raw: RawBox::from_value(rv),
-            _marker: PhantomData,
-        }
-    }
-
-    /// Load a GC pointer from a value with a negative tag.
-    ///
-    /// # Safety
-    ///
-    /// The value must actually store a `Gc<'gc, T>` with the matching type.
-    #[inline(always)]
-    unsafe fn load_gc<T: GcStorable>(&self) -> Gc<'gc, T> {
-        unsafe {
-            let rv = self.raw.value().unwrap_unchecked();
-            let ptr: *const T = <*const T as RawStore>::from_val(rv);
-            Gc::from_ptr(ptr)
-        }
-    }
-
-    /// Returns the `(negative, val)` tag, or `None` for a float.
-    #[inline(always)]
-    fn tag(&self) -> Option<(bool, u8)> {
-        self.raw.tag().map(|t| t.neg_val())
-    }
-}
-
-impl<'gc> Value<'gc> {
-    #[inline]
-    pub(crate) fn new_float(val: f64) -> Self {
-        Self {
-            raw: RawBox::from_float(val),
-            _marker: PhantomData,
-        }
-    }
-
-    #[inline]
-    pub(crate) fn new_inline<T: InlineStorable>(val: T) -> Self {
-        Self::from_raw_value(RawValue::store(Self::mk_tag(T::TAG.0, T::TAG.1), val))
-    }
-
-    #[inline]
-    pub(crate) fn new_gc<T: GcStorable>(gc: Gc<'gc, T>) -> Self {
-        let ptr = Gc::as_ptr(gc);
-        Self::from_raw_value(RawValue::store(Self::mk_tag(T::TAG.0, T::TAG.1), ptr))
-    }
-}
-
-impl<'gc> Value<'gc> {
-    #[inline]
-    pub(crate) fn is_float(&self) -> bool {
-        self.raw.is_float()
-    }
-
-    #[inline]
-    pub(crate) fn is<T: Storable>(&self) -> bool {
-        self.tag() == Some(T::TAG)
-    }
-}
-
-impl<'gc> Value<'gc> {
-    #[inline]
-    pub(crate) fn as_float(&self) -> Option<f64> {
-        self.raw.float().copied()
-    }
-
-    #[inline]
-    pub(crate) fn as_inline<T: InlineStorable>(&self) -> Option<T> {
-        if self.is::<T>() {
-            Some(unsafe {
-                let rv = self.raw.value().unwrap_unchecked();
-                T::from_val(rv)
-            })
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn as_gc<T: GcStorable>(&self) -> Option<Gc<'gc, T>> {
-        if self.is::<T>() {
-            Some(unsafe {
-                let rv = self.raw.value().unwrap_unchecked();
-                let ptr: *const T = <*const T as RawStore>::from_val(rv);
-                Gc::from_ptr(ptr)
-            })
-        } else {
-            None
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub(crate) struct Null;
-impl RawStore for Null {
-    fn to_val(self, value: &mut RawValue) {
-        value.set_data([0; 6]);
-    }
-    fn from_val(_: &RawValue) -> Self {
-        Self
-    }
-}
-
-impl RawStore for StringId {
-    fn to_val(self, value: &mut RawValue) {
-        (self.0.to_usize() as u32).to_val(value);
-    }
-    fn from_val(value: &RawValue) -> Self {
-        Self(
-            SymbolU32::try_from_usize(u32::from_val(value) as usize)
-                .expect("failed to read StringId from Value"),
-        )
-    }
-}
-
-/// Heap-allocated Nix string.
-///
-/// Stored on the GC heap via `Gc<'gc, NixString>`. The string data itself
-/// lives in a standard `Box<str>` owned by this struct; the GC only manages
-/// the outer allocation.
-#[derive(Collect)]
-#[collect(require_static)]
-pub(crate) struct NixString {
-    data: Box<str>,
-    // TODO: string context for derivation dependency tracking
-}
-
-impl NixString {
-    pub(crate) fn new(s: impl Into<Box<str>>) -> Self {
-        Self { data: s.into() }
-    }
-
-    pub(crate) fn as_str(&self) -> &str {
-        &self.data
-    }
-}
-
-impl fmt::Debug for NixString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.data, f)
-    }
-}
-
-#[derive(Collect, Debug)]
-#[collect(no_drop)]
-pub(crate) struct AttrSet<'gc> {
-    pub(crate) entries: SmallVec<[(StringId, Value<'gc>); 4]>,
-}
-
-impl<'gc> AttrSet<'gc> {
-    pub(crate) fn from_sorted(entries: SmallVec<[(StringId, Value<'gc>); 4]>) -> Self {
-        debug_assert!(entries.is_sorted_by_key(|(key, _)| *key));
-        Self { entries }
-    }
-
-    pub(crate) fn lookup(&self, key: StringId) -> Option<Value<'gc>> {
-        self.entries
-            .binary_search_by_key(&key, |(k, _)| *k)
-            .ok()
-            .map(|i| self.entries[i].1.clone())
-    }
-
-    pub(crate) fn has(&self, key: StringId) -> bool {
-        self.entries
-            .binary_search_by_key(&key, |(k, _)| *k)
-            .is_ok()
-    }
-
-    pub(crate) fn merge(&self, other: &Self, mc: &Mutation<'gc>) -> Gc<'gc, Self> {
-        use std::cmp::Ordering::*;
-
-        debug_assert!(self.entries.is_sorted_by_key(|(key, _)| *key));
-        debug_assert!(other.entries.is_sorted_by_key(|(key, _)| *key));
-
-        let mut entries = SmallVec::new();
-        let mut i = 0;
-        let mut j = 0;
-        while i < self.entries.len() && j < other.entries.len() {
-            match self.entries[i].0.cmp(&other.entries[j].0) {
-                Less => {
-                    entries.push(self.entries[i].clone());
-                    i += 1;
-                }
-                Greater => {
-                    entries.push(other.entries[j].clone());
-                    j += 1;
-                }
-                Equal => {
-                    entries.push(other.entries[j].clone());
-                    i += 1;
-                    j += 1;
-                }
-            }
-        }
-        entries.extend(other.entries[j..].iter().cloned());
-        entries.extend(self.entries[i..].iter().cloned());
-
-        debug_assert!(entries.is_sorted_by_key(|(key, _)| *key));
-
-        Gc::new(mc, AttrSet { entries })
-    }
-}
-
-#[derive(Collect, Debug)]
-#[collect(no_drop)]
-pub(crate) struct List<'gc> {
-    pub(crate) inner: SmallVec<[Value<'gc>; 4]>,
-}
-
-pub(crate) type Thunk<'gc> = RefLock<ThunkState<'gc>>;
-
-#[derive(Collect, Debug)]
-#[collect(no_drop)]
-pub(crate) enum ThunkState<'gc> {
-    Pending {
-        ip: u32,
-        env: Gc<'gc, RefLock<Env<'gc>>>,
-    },
-    Blackhole,
-    Evaluated(Value<'gc>),
-}
-
-#[derive(Collect, Debug)]
-#[collect(no_drop)]
-pub(crate) struct Env<'gc> {
-    pub(crate) locals: SmallVec<[Value<'gc>; 4]>,
-    pub(crate) prev: Option<Gc<'gc, RefLock<Env<'gc>>>>,
-}
-
-impl<'gc> Env<'gc> {
-    pub(crate) fn empty() -> Self {
-        Env {
-            locals: SmallVec::new(),
-            prev: None,
-        }
-    }
-
-    pub(crate) fn with_arg(
-        arg: Value<'gc>,
-        n_locals: u32,
-        prev: Gc<'gc, RefLock<Env<'gc>>>,
-    ) -> Self {
-        let mut locals = smallvec::smallvec![Value::default(); 1 + n_locals as usize];
-        locals[0] = arg;
-        Env {
-            locals,
-            prev: Some(prev),
-        }
-    }
-}
-
-#[derive(Collect, Debug)]
-#[collect(no_drop)]
-pub(crate) struct Closure<'gc> {
-    pub(crate) ip: u32,
-    pub(crate) n_locals: u32,
-    pub(crate) env: Gc<'gc, RefLock<Env<'gc>>>,
-    pub(crate) pattern: Option<Gc<'gc, PatternInfo>>,
-}
-
-#[derive(Collect, Debug)]
-#[collect(require_static)]
-pub(crate) struct PatternInfo {
-    pub(crate) required: SmallVec<[StringId; 4]>,
-    pub(crate) optional: SmallVec<[StringId; 4]>,
-    pub(crate) ellipsis: bool,
-    pub(crate) param_spans: Box<[(StringId, u32)]>,
-}
-
-#[derive(Clone, Copy, Debug, Collect)]
-#[collect(require_static)]
-pub(crate) struct PrimOp {
-    pub(crate) id: u8,
-    pub(crate) arity: u8,
-}
-
-impl RawStore for PrimOp {
-    fn to_val(self, value: &mut RawValue) {
-        value.set_data([0, 0, 0, 0, self.id, self.arity]);
-    }
-    fn from_val(value: &RawValue) -> Self {
-        let [.., id, arity] = *value.data();
-        Self { id, arity }
-    }
-}
-
-#[derive(Collect, Debug)]
-#[collect(no_drop)]
-pub(crate) struct PrimOpApp<'gc> {
-    pub(crate) primop: PrimOp,
-    pub(crate) args: SmallVec<[Value<'gc>; 2]>,
-}
-
-#[repr(transparent)]
-pub(crate) struct StrictValue<'gc>(Value<'gc>);
-
-impl<'gc> StrictValue<'gc> {
-    #[inline]
-    pub(crate) fn try_from_forced(val: Value<'gc>) -> Option<Self> {
-        if !val.is::<Thunk<'gc>>() {
-            Some(Self(val))
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn into_relaxed(self) -> Value<'gc> {
-        self.0
-    }
-}
-
-impl<'gc> Deref for StrictValue<'gc> {
-    type Target = Value<'gc>;
-    #[inline]
-    fn deref(&self) -> &Value<'gc> {
-        &self.0
-    }
-}
-
-impl Clone for StrictValue<'_> {
-    #[inline]
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl fmt::Debug for StrictValue<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.0, f)
-    }
-}
-
-unsafe impl<'gc> Collect<'gc> for StrictValue<'gc> {
-    const NEEDS_TRACE: bool = true;
-    fn trace<T: gc_arena::collect::Trace<'gc>>(&self, cc: &mut T) {
-        self.0.trace(cc);
-    }
-}

fix/src/store.rs

@@ -1,40 +0,0 @@
-use crate::error::Result;
-
-mod config;
-mod daemon;
-mod error;
-mod validation;
-
-pub use config::StoreConfig;
-pub use daemon::DaemonStore;
-pub use validation::validate_store_path;
-
-pub trait Store: Send + Sync {
-    fn get_store_dir(&self) -> &str;
-
-    fn is_valid_path(&self, path: &str) -> Result<bool>;
-
-    fn ensure_path(&self, path: &str) -> Result<()>;
-
-    fn add_to_store(
-        &self,
-        name: &str,
-        content: &[u8],
-        recursive: bool,
-        references: Vec<String>,
-    ) -> Result<String>;
-
-    fn add_to_store_from_path(
-        &self,
-        name: &str,
-        source_path: &std::path::Path,
-        references: Vec<String>,
-    ) -> Result<String>;
-
-    fn add_text_to_store(
-        &self,
-        name: &str,
-        content: &str,
-        references: Vec<String>,
-    ) -> Result<String>;
-}

fix/src/store/config.rs

@@ -1,22 +0,0 @@
-use std::path::PathBuf;
-
-#[derive(Debug, Clone)]
-pub struct StoreConfig {
-    pub daemon_socket: PathBuf,
-}
-
-impl StoreConfig {
-    pub fn from_env() -> Self {
-        let daemon_socket = std::env::var("NIX_DAEMON_SOCKET")
-            .map(PathBuf::from)
-            .unwrap_or_else(|_| PathBuf::from("/nix/var/nix/daemon-socket/socket"));
-
-        Self { daemon_socket }
-    }
-}
-
-impl Default for StoreConfig {
-    fn default() -> Self {
-        Self::from_env()
-    }
-}

fix/src/string_context.rs

@@ -1,209 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet, VecDeque};
-
-pub enum StringContextElem {
-    Opaque { path: String },
-    DrvDeep { drv_path: String },
-    Built { drv_path: String, output: String },
-}
-
-impl StringContextElem {
-    pub fn decode(encoded: &str) -> Self {
-        if let Some(drv_path) = encoded.strip_prefix('=') {
-            StringContextElem::DrvDeep {
-                drv_path: drv_path.to_string(),
-            }
-        } else if let Some(rest) = encoded.strip_prefix('!') {
-            if let Some(second_bang) = rest.find('!') {
-                let output = rest[..second_bang].to_string();
-                let drv_path = rest[second_bang + 1..].to_string();
-                StringContextElem::Built { drv_path, output }
-            } else {
-                StringContextElem::Opaque {
-                    path: encoded.to_string(),
-                }
-            }
-        } else {
-            StringContextElem::Opaque {
-                path: encoded.to_string(),
-            }
-        }
-    }
-}
-
-pub type InputDrvs = BTreeMap<String, BTreeSet<String>>;
-pub type Srcs = BTreeSet<String>;
-pub fn extract_input_drvs_and_srcs(context: &[String]) -> Result<(InputDrvs, Srcs), String> {
-    let mut input_drvs: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
-    let mut input_srcs: BTreeSet<String> = BTreeSet::new();
-
-    for encoded in context {
-        match StringContextElem::decode(encoded) {
-            StringContextElem::Opaque { path } => {
-                input_srcs.insert(path);
-            }
-            StringContextElem::DrvDeep { drv_path } => {
-                compute_fs_closure(&drv_path, &mut input_drvs, &mut input_srcs)?;
-            }
-            StringContextElem::Built { drv_path, output } => {
-                input_drvs.entry(drv_path).or_default().insert(output);
-            }
-        }
-    }
-
-    Ok((input_drvs, input_srcs))
-}
-
-fn compute_fs_closure(
-    drv_path: &str,
-    input_drvs: &mut BTreeMap<String, BTreeSet<String>>,
-    input_srcs: &mut BTreeSet<String>,
-) -> Result<(), String> {
-    let mut queue: VecDeque<String> = VecDeque::new();
-    let mut visited: BTreeSet<String> = BTreeSet::new();
-
-    queue.push_back(drv_path.to_string());
-
-    while let Some(current_path) = queue.pop_front() {
-        if visited.contains(&current_path) {
-            continue;
-        }
-        visited.insert(current_path.clone());
-        input_srcs.insert(current_path.clone());
-
-        if !current_path.ends_with(".drv") {
-            continue;
-        }
-
-        let content = std::fs::read_to_string(&current_path)
-            .map_err(|e| format!("failed to read derivation {}: {}", current_path, e))?;
-
-        let inputs = parse_derivation_inputs(&content)
-            .ok_or_else(|| format!("failed to parse derivation {}", current_path))?;
-
-        for src in inputs.input_srcs {
-            input_srcs.insert(src.clone());
-            if !visited.contains(&src) {
-                queue.push_back(src);
-            }
-        }
-
-        for (dep_drv, outputs) in inputs.input_drvs {
-            input_srcs.insert(dep_drv.clone());
-            let entry = input_drvs.entry(dep_drv.clone()).or_default();
-            for output in outputs {
-                entry.insert(output);
-            }
-            if !visited.contains(&dep_drv) {
-                queue.push_back(dep_drv);
-            }
-        }
-    }
-
-    Ok(())
-}
-
-struct DerivationInputs {
-    input_drvs: Vec<(String, Vec<String>)>,
-    input_srcs: Vec<String>,
-}
-
-fn parse_derivation_inputs(aterm: &str) -> Option<DerivationInputs> {
-    let aterm = aterm.strip_prefix("Derive([")?;
-
-    let mut bracket_count: i32 = 1;
-    let mut pos = 0;
-    let bytes = aterm.as_bytes();
-    while pos < bytes.len() && bracket_count > 0 {
-        match bytes[pos] {
-            b'[' => bracket_count += 1,
-            b']' => bracket_count -= 1,
-            _ => {}
-        }
-        pos += 1;
-    }
-    if bracket_count != 0 {
-        return None;
-    }
-
-    let rest = &aterm[pos..];
-    let rest = rest.strip_prefix(",[")?;
-
-    let mut input_drvs = Vec::new();
-    let mut bracket_count: i32 = 1;
-    let mut start = 0;
-    pos = 0;
-    let bytes = rest.as_bytes();
-
-    while pos < bytes.len() && bracket_count > 0 {
-        match bytes[pos] {
-            b'[' => bracket_count += 1,
-            b']' => bracket_count -= 1,
-            b'(' if bracket_count == 1 => {
-                start = pos;
-            }
-            b')' if bracket_count == 1 => {
-                let entry = &rest[start + 1..pos];
-                if let Some((drv_path, outputs)) = parse_input_drv_entry(entry) {
-                    input_drvs.push((drv_path, outputs));
-                }
-            }
-            _ => {}
-        }
-        pos += 1;
-    }
-
-    let rest = &rest[pos..];
-    let rest = rest.strip_prefix(",[")?;
-
-    let mut input_srcs = Vec::new();
-    bracket_count = 1;
-    pos = 0;
-    let bytes = rest.as_bytes();
-
-    while pos < bytes.len() && bracket_count > 0 {
-        match bytes[pos] {
-            b'[' => bracket_count += 1,
-            b']' => bracket_count -= 1,
-            b'"' if bracket_count == 1 => {
-                pos += 1;
-                let src_start = pos;
-                while pos < bytes.len() && bytes[pos] != b'"' {
-                    if bytes[pos] == b'\\' && pos + 1 < bytes.len() {
-                        pos += 2;
-                    } else {
-                        pos += 1;
-                    }
-                }
-                let src = std::str::from_utf8(&bytes[src_start..pos]).ok()?;
-                input_srcs.push(src.to_string());
-            }
-            _ => {}
-        }
-        pos += 1;
-    }
-
-    Some(DerivationInputs {
-        input_drvs,
-        input_srcs,
-    })
-}
-
-fn parse_input_drv_entry(entry: &str) -> Option<(String, Vec<String>)> {
-    let entry = entry.strip_prefix('"')?;
-    let quote_end = entry.find('"')?;
-    let drv_path = entry[..quote_end].to_string();
-
-    let rest = &entry[quote_end + 1..];
-    let rest = rest.strip_prefix(",[")?;
-    let rest = rest.strip_suffix(']')?;
-
-    let mut outputs = Vec::new();
-    for part in rest.split(',') {
-        let part = part.trim();
-        if let Some(name) = part.strip_prefix('"').and_then(|s| s.strip_suffix('"')) {
-            outputs.push(name.to_string());
-        }
-    }
-
-    Some((drv_path, outputs))
-}

fix/src/value.rs

@@ -1,372 +0,0 @@
-use core::fmt::{Debug, Display, Formatter, Result as FmtResult};
-use core::hash::Hash;
-use core::ops::Deref;
-use std::borrow::Cow;
-use std::collections::BTreeMap;
-use std::ops::DerefMut;
-
-use derive_more::{Constructor, IsVariant, Unwrap};
-
-/// Represents a Nix symbol, which is used as a key in attribute sets.
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Constructor)]
-pub struct Symbol<'a>(Cow<'a, str>);
-
-pub type StaticSymbol = Symbol<'static>;
-
-impl From<String> for Symbol<'_> {
-    fn from(value: String) -> Self {
-        Symbol(Cow::Owned(value))
-    }
-}
-
-impl<'a> From<&'a str> for Symbol<'a> {
-    fn from(value: &'a str) -> Self {
-        Symbol(Cow::Borrowed(value))
-    }
-}
-
-/// Formats a string slice as a Nix symbol, quoting it if necessary.
-pub fn format_symbol<'a>(sym: impl Into<Cow<'a, str>>) -> Cow<'a, str> {
-    let sym = sym.into();
-    if Symbol::NORMAL_REGEX.test(&sym) {
-        sym
-    } else {
-        Cow::Owned(escape_quote_string(&sym))
-    }
-}
-
-impl Display for Symbol<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        if self.normal() {
-            write!(f, "{}", self.0)
-        } else {
-            write!(f, "{}", escape_quote_string(&self.0))
-        }
-    }
-}
-
-impl Symbol<'_> {
-    const NORMAL_REGEX: ere::Regex<1> = ere::compile_regex!("^[a-zA-Z_][a-zA-Z0-9_'-]*$");
-    /// Checks if the symbol is a "normal" identifier that doesn't require quotes.
-    fn normal(&self) -> bool {
-        Self::NORMAL_REGEX.test(self)
-    }
-}
-
-impl Deref for Symbol<'_> {
-    type Target = str;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-/// Represents a Nix attribute set, which is a map from symbols to values.
-#[derive(Constructor, Default, Clone, PartialEq)]
-pub struct AttrSet {
-    data: BTreeMap<StaticSymbol, Value>,
-}
-
-impl AttrSet {
-    /// Gets a value by key (string or Symbol).
-    pub fn get<'a, 'sym: 'a>(&'a self, key: impl Into<Symbol<'sym>>) -> Option<&'a Value> {
-        self.data.get(&key.into())
-    }
-
-    /// Checks if a key exists in the attribute set.
-    pub fn contains_key<'a, 'sym: 'a>(&'a self, key: impl Into<Symbol<'sym>>) -> bool {
-        self.data.contains_key(&key.into())
-    }
-}
-
-impl Deref for AttrSet {
-    type Target = BTreeMap<StaticSymbol, Value>;
-    fn deref(&self) -> &Self::Target {
-        &self.data
-    }
-}
-impl DerefMut for AttrSet {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.data
-    }
-}
-
-impl Debug for AttrSet {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        use Value::*;
-        write!(f, "{{")?;
-        for (k, v) in self.data.iter() {
-            write!(f, " {k:?} = ")?;
-            match v {
-                List(_) => write!(f, "[ ... ];")?,
-                AttrSet(_) => write!(f, "{{ ... }};")?,
-                v => write!(f, "{v:?};")?,
-            }
-        }
-        write!(f, " }}")
-    }
-}
-
-impl Display for AttrSet {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        use Value::*;
-        if self.data.len() > 1 {
-            writeln!(f, "{{")?;
-            for (k, v) in self.data.iter() {
-                write!(f, "  {k} = ")?;
-                match v {
-                    List(_) => writeln!(f, "[ ... ];")?,
-                    AttrSet(_) => writeln!(f, "{{ ... }};")?,
-                    v => writeln!(f, "{v};")?,
-                }
-            }
-            write!(f, "}}")
-        } else {
-            write!(f, "{{")?;
-            for (k, v) in self.data.iter() {
-                write!(f, " {k} = ")?;
-                match v {
-                    List(_) => write!(f, "[ ... ];")?,
-                    AttrSet(_) => write!(f, "{{ ... }};")?,
-                    v => write!(f, "{v};")?,
-                }
-            }
-            write!(f, " }}")
-        }
-    }
-}
-
-impl AttrSet {
-    pub fn display_compat(&self) -> AttrSetCompatDisplay<'_> {
-        AttrSetCompatDisplay(self)
-    }
-}
-
-pub struct AttrSetCompatDisplay<'a>(&'a AttrSet);
-
-impl Display for AttrSetCompatDisplay<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        write!(f, "{{")?;
-        for (k, v) in self.0.data.iter() {
-            write!(f, " {k} = {};", v.display_compat())?;
-        }
-        write!(f, " }}")
-    }
-}
-
-/// Represents a Nix list, which is a vector of values.
-#[derive(Constructor, Default, Clone, Debug, PartialEq)]
-pub struct List {
-    data: Vec<Value>,
-}
-
-impl Deref for List {
-    type Target = Vec<Value>;
-    fn deref(&self) -> &Self::Target {
-        &self.data
-    }
-}
-impl DerefMut for List {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.data
-    }
-}
-
-impl Display for List {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        use Value::*;
-        if self.data.len() > 1 {
-            writeln!(f, "[")?;
-            for v in self.data.iter() {
-                match v {
-                    List(_) => writeln!(f, "  [ ... ]")?,
-                    AttrSet(_) => writeln!(f, "  {{ ... }}")?,
-                    v => writeln!(f, "  {v}")?,
-                }
-            }
-            write!(f, "]")
-        } else {
-            write!(f, "[ ")?;
-            for v in self.data.iter() {
-                match v {
-                    List(_) => write!(f, "[ ... ] ")?,
-                    AttrSet(_) => write!(f, "{{ ... }} ")?,
-                    v => write!(f, "{v} ")?,
-                }
-            }
-            write!(f, "]")
-        }
-    }
-}
-
-impl List {
-    pub fn display_compat(&self) -> ListCompatDisplay<'_> {
-        ListCompatDisplay(self)
-    }
-}
-
-pub struct ListCompatDisplay<'a>(&'a List);
-
-impl Display for ListCompatDisplay<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        write!(f, "[ ")?;
-        for v in self.0.data.iter() {
-            write!(f, "{} ", v.display_compat())?;
-        }
-        write!(f, "]")
-    }
-}
-
-/// Represents any possible Nix value that can be returned from an evaluation.
-#[derive(IsVariant, Unwrap, Clone, Debug, PartialEq)]
-pub enum Value {
-    /// An integer value.
-    Int(i64),
-    /// An floating-point value.
-    Float(f64),
-    /// An boolean value.
-    Bool(bool),
-    /// An null value.
-    Null,
-    /// A string value.
-    String(String),
-    /// A path value (absolute path string).
-    Path(String),
-    /// An attribute set.
-    AttrSet(AttrSet),
-    /// A list.
-    List(List),
-    /// A thunk, representing a delayed computation.
-    Thunk,
-    /// A function (lambda).
-    Func,
-    /// A primitive (built-in) operation.
-    PrimOp(String),
-    /// A partially applied primitive operation.
-    PrimOpApp(String),
-    /// A marker for a value that has been seen before during serialization, to break cycles.
-    /// This is used to prevent infinite recursion when printing or serializing cyclic data structures.
-    Repeated,
-}
-
-fn escape_quote_string(s: &str) -> String {
-    let mut ret = String::with_capacity(s.len() + 2);
-    ret.push('"');
-    let mut iter = s.chars().peekable();
-    while let Some(c) = iter.next() {
-        match c {
-            '\\' => ret.push_str("\\\\"),
-            '"' => ret.push_str("\\\""),
-            '\n' => ret.push_str("\\n"),
-            '\r' => ret.push_str("\\r"),
-            '\t' => ret.push_str("\\t"),
-            '$' if iter.peek() == Some(&'{') => ret.push_str("\\$"),
-            c => ret.push(c),
-        }
-    }
-    ret.push('"');
-    ret
-}
-
-/// Format a float matching C's `printf("%g", x)` with default precision 6.
-fn fmt_nix_float(f: &mut Formatter<'_>, x: f64) -> FmtResult {
-    if !x.is_finite() {
-        return write!(f, "{x}");
-    }
-    if x == 0.0 {
-        return if x.is_sign_negative() {
-            write!(f, "-0")
-        } else {
-            write!(f, "0")
-        };
-    }
-
-    let precision: i32 = 6;
-    let exp = x.abs().log10().floor() as i32;
-
-    let formatted = if exp >= -4 && exp < precision {
-        let decimal_places = (precision - 1 - exp) as usize;
-        format!("{x:.decimal_places$}")
-    } else {
-        let sig_digits = (precision - 1) as usize;
-        let s = format!("{x:.sig_digits$e}");
-        let (mantissa, exp_part) = s
-            .split_once('e')
-            .expect("scientific notation must contain 'e'");
-        let (sign, digits) = if let Some(d) = exp_part.strip_prefix('-') {
-            ("-", d)
-        } else if let Some(d) = exp_part.strip_prefix('+') {
-            ("+", d)
-        } else {
-            ("+", exp_part)
-        };
-        if digits.len() < 2 {
-            format!("{mantissa}e{sign}0{digits}")
-        } else {
-            format!("{mantissa}e{sign}{digits}")
-        }
-    };
-
-    if formatted.contains('.') {
-        if let Some(e_pos) = formatted.find('e') {
-            let trimmed = formatted[..e_pos]
-                .trim_end_matches('0')
-                .trim_end_matches('.');
-            write!(f, "{}{}", trimmed, &formatted[e_pos..])
-        } else {
-            let trimmed = formatted.trim_end_matches('0').trim_end_matches('.');
-            write!(f, "{trimmed}")
-        }
-    } else {
-        write!(f, "{formatted}")
-    }
-}
-
-impl Display for Value {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        use Value::*;
-        match self {
-            &Int(x) => write!(f, "{x}"),
-            &Float(x) => fmt_nix_float(f, x),
-            &Bool(x) => write!(f, "{x}"),
-            Null => write!(f, "null"),
-            String(x) => write!(f, "{}", escape_quote_string(x)),
-            Path(x) => write!(f, "{x}"),
-            AttrSet(x) => write!(f, "{x}"),
-            List(x) => write!(f, "{x}"),
-            Thunk => write!(f, "«code»"),
-            Func => write!(f, "«lambda»"),
-            PrimOp(name) => write!(f, "«primop {name}»"),
-            PrimOpApp(name) => write!(f, "«partially applied primop {name}»"),
-            Repeated => write!(f, "«repeated»"),
-        }
-    }
-}
-
-impl Value {
-    pub fn display_compat(&self) -> ValueCompatDisplay<'_> {
-        ValueCompatDisplay(self)
-    }
-}
-
-pub struct ValueCompatDisplay<'a>(&'a Value);
-
-impl Display for ValueCompatDisplay<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        use Value::*;
-        match self.0 {
-            &Int(x) => write!(f, "{x}"),
-            &Float(x) => fmt_nix_float(f, x),
-            &Bool(x) => write!(f, "{x}"),
-            Null => write!(f, "null"),
-            String(x) => write!(f, "{}", escape_quote_string(x)),
-            Path(x) => write!(f, "{x}"),
-            AttrSet(x) => write!(f, "{}", x.display_compat()),
-            List(x) => write!(f, "{}", x.display_compat()),
-            Thunk => write!(f, "«thunk»"),
-            Func => write!(f, "<LAMBDA>"),
-            PrimOp(_) => write!(f, "<PRIMOP>"),
-            PrimOpApp(_) => write!(f, "<PRIMOP-APP>"),
-            Repeated => write!(f, "«repeated»"),
-        }
-    }
-}

fix/tests/tests/lang.rs

@@ -1,319 +0,0 @@
-#![allow(non_snake_case)]
-
-use std::path::PathBuf;
-
-use fix::error::Source;
-use fix::runtime::Runtime;
-use fix::value::Value;
-
-fn get_lang_dir() -> PathBuf {
-    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/tests/lang")
-}
-
-fn eval_file(name: &str) -> Result<(Value, Source), String> {
-    let lang_dir = get_lang_dir();
-    let nix_path = lang_dir.join(format!("{name}.nix"));
-
-    let expr = format!(r#"import "{}""#, nix_path.display());
-
-    let mut ctx = Runtime::new().map_err(|e| e.to_string())?;
-    let source = Source {
-        ty: fix::error::SourceType::File(nix_path.into()),
-        src: expr.into(),
-    };
-    ctx.eval_deep(source.clone())
-        .map(|val| (val, source))
-        .map_err(|e| e.to_string())
-}
-
-fn read_expected(name: &str) -> String {
-    let lang_dir = get_lang_dir();
-    let exp_path = lang_dir.join(format!("{name}.exp"));
-    std::fs::read_to_string(exp_path)
-        .expect("expected file should exist")
-        .trim_end()
-        .to_string()
-}
-
-fn format_value(value: &Value) -> String {
-    value.display_compat().to_string()
-}
-
-macro_rules! eval_okay_test {
-    ($(#[$attr:meta])* $name:ident$(, $pre:expr)?) => {
-        $(#[$attr])*
-        #[test_log::test]
-        fn $name() {
-            $(($pre)();)?
-            let test_name = concat!("eval-okay-", stringify!($name))
-                .replace("_", "-")
-                .replace("r#", "");
-            let result = eval_file(&test_name);
-            match result {
-                Ok((value, source)) => {
-                    let actual = format_value(&value);
-                    let actual = actual.replace(
-                        source
-                            .get_dir()
-                            .parent()
-                            .unwrap()
-                            .to_string_lossy()
-                            .as_ref(),
-                        "/pwd",
-                    );
-                    let expected = read_expected(&test_name);
-                    assert_eq!(actual, expected, "Output mismatch for {}", test_name);
-                }
-                Err(e) => {
-                    panic!("Test {} failed to evaluate: {}", test_name, e);
-                }
-            }
-        }
-    };
-}
-
-macro_rules! eval_fail_test {
-    ($name:ident) => {
-        #[test_log::test]
-        fn $name() {
-            let test_name = concat!("eval-fail-", stringify!($name))
-                .replace("_", "-")
-                .replace("r#", "");
-            let result = eval_file(&test_name);
-            assert!(
-                result.is_err(),
-                "Test {} should have failed but succeeded with: {:?}",
-                test_name,
-                result
-            );
-        }
-    };
-}
-
-eval_okay_test!(any_all);
-eval_okay_test!(arithmetic);
-eval_okay_test!(attrnames);
-eval_okay_test!(attrs);
-eval_okay_test!(attrs2);
-eval_okay_test!(attrs3);
-eval_okay_test!(attrs4);
-eval_okay_test!(attrs5);
-eval_okay_test!(
-    #[ignore = "__overrides is not supported"]
-    attrs6
-);
-eval_okay_test!(
-    #[ignore = "requires --arg/--argstr CLI flags"]
-    autoargs
-);
-eval_okay_test!(backslash_newline_1);
-eval_okay_test!(backslash_newline_2);
-eval_okay_test!(baseNameOf);
-eval_okay_test!(builtins);
-eval_okay_test!(builtins_add);
-eval_okay_test!(callable_attrs);
-eval_okay_test!(catattrs);
-eval_okay_test!(closure);
-eval_okay_test!(comments);
-eval_okay_test!(concat);
-eval_okay_test!(concatmap);
-eval_okay_test!(concatstringssep);
-eval_okay_test!(context);
-eval_okay_test!(context_introspection);
-eval_okay_test!(convertHash);
-eval_okay_test!(curpos);
-eval_okay_test!(deepseq);
-eval_okay_test!(delayed_with);
-eval_okay_test!(delayed_with_inherit);
-eval_okay_test!(deprecate_cursed_or);
-eval_okay_test!(derivation_legacy);
-eval_okay_test!(dynamic_attrs);
-eval_okay_test!(dynamic_attrs_2);
-eval_okay_test!(dynamic_attrs_bare);
-eval_okay_test!(elem);
-eval_okay_test!(empty_args);
-eval_okay_test!(eq);
-eval_okay_test!(eq_derivations);
-eval_okay_test!(filter);
-eval_okay_test!(
-    #[ignore = "not implemented: flakeRefToString"]
-    flake_ref_to_string
-);
-eval_okay_test!(flatten);
-eval_okay_test!(float);
-eval_okay_test!(floor_ceil);
-eval_okay_test!(foldlStrict);
-eval_okay_test!(foldlStrict_lazy_elements);
-eval_okay_test!(foldlStrict_lazy_initial_accumulator);
-eval_okay_test!(fromjson);
-eval_okay_test!(fromjson_escapes);
-eval_okay_test!(fromTOML);
-eval_okay_test!(
-    #[ignore = "timestamps are not supported"]
-    fromTOML_timestamps
-);
-eval_okay_test!(functionargs);
-eval_okay_test!(hashfile);
-eval_okay_test!(hashstring);
-eval_okay_test!(getattrpos);
-eval_okay_test!(getattrpos_functionargs);
-eval_okay_test!(getattrpos_undefined);
-eval_okay_test!(getenv, || {
-    unsafe { std::env::set_var("TEST_VAR", "foo") };
-});
-eval_okay_test!(groupBy);
-eval_okay_test!(r#if);
-eval_okay_test!(ind_string);
-eval_okay_test!(import);
-eval_okay_test!(inherit_attr_pos);
-eval_okay_test!(
-    #[ignore = "__overrides is not supported"]
-    inherit_from
-);
-eval_okay_test!(intersectAttrs);
-eval_okay_test!(r#let);
-eval_okay_test!(list);
-eval_okay_test!(listtoattrs);
-eval_okay_test!(logic);
-eval_okay_test!(map);
-eval_okay_test!(mapattrs);
-eval_okay_test!(merge_dynamic_attrs);
-eval_okay_test!(nested_with);
-eval_okay_test!(new_let);
-eval_okay_test!(null_dynamic_attrs);
-eval_okay_test!(
-    #[ignore = "__overrides is not supported"]
-    overrides
-);
-eval_okay_test!(
-    #[ignore = "not implemented: parseFlakeRef"]
-    parse_flake_ref
-);
-eval_okay_test!(partition);
-eval_okay_test!(path);
-eval_okay_test!(pathexists);
-eval_okay_test!(path_string_interpolation, || {
-    unsafe {
-        std::env::set_var("HOME", "/fake-home");
-    }
-});
-eval_okay_test!(patterns);
-eval_okay_test!(print);
-eval_okay_test!(readDir);
-eval_okay_test!(readfile);
-eval_okay_test!(readFileType);
-eval_okay_test!(redefine_builtin);
-eval_okay_test!(regex_match);
-eval_okay_test!(regex_split);
-eval_okay_test!(regression_20220122);
-eval_okay_test!(regression_20220125);
-eval_okay_test!(regrettable_rec_attrset_merge);
-eval_okay_test!(remove);
-eval_okay_test!(repeated_empty_attrs);
-eval_okay_test!(repeated_empty_list);
-eval_okay_test!(replacestrings);
-eval_okay_test!(
-    #[ignore = "requires -I CLI flags"]
-    search_path
-);
-eval_okay_test!(scope_1);
-eval_okay_test!(scope_2);
-eval_okay_test!(scope_3);
-eval_okay_test!(scope_4);
-eval_okay_test!(scope_6);
-eval_okay_test!(scope_7);
-eval_okay_test!(seq);
-eval_okay_test!(sort);
-eval_okay_test!(splitversion);
-eval_okay_test!(string);
-eval_okay_test!(strings_as_attrs_names);
-eval_okay_test!(substring);
-eval_okay_test!(substring_context);
-eval_okay_test!(symlink_resolution);
-eval_okay_test!(
-    #[ignore = "TCO not implemented, also disabled in CppNix"]
-    tail_call_1
-);
-eval_okay_test!(tojson);
-eval_okay_test!(toxml);
-eval_okay_test!(toxml2);
-eval_okay_test!(tryeval);
-eval_okay_test!(types);
-eval_okay_test!(versions);
-eval_okay_test!(with);
-eval_okay_test!(zipAttrsWith);
-
-eval_fail_test!(fail_abort);
-eval_fail_test!(fail_addDrvOutputDependencies_empty_context);
-eval_fail_test!(fail_addDrvOutputDependencies_multi_elem_context);
-eval_fail_test!(fail_addDrvOutputDependencies_wrong_element_kind);
-eval_fail_test!(fail_addErrorRuntime_example);
-eval_fail_test!(fail_assert);
-eval_fail_test!(fail_assert_equal_attrs_names);
-eval_fail_test!(fail_assert_equal_attrs_names_2);
-eval_fail_test!(fail_assert_equal_derivations);
-eval_fail_test!(fail_assert_equal_derivations_extra);
-eval_fail_test!(fail_assert_equal_floats);
-eval_fail_test!(fail_assert_equal_function_direct);
-eval_fail_test!(fail_assert_equal_int_float);
-eval_fail_test!(fail_assert_equal_ints);
-eval_fail_test!(fail_assert_equal_list_length);
-eval_fail_test!(fail_assert_equal_paths);
-eval_fail_test!(fail_assert_equal_type);
-eval_fail_test!(fail_assert_equal_type_nested);
-eval_fail_test!(fail_assert_nested_bool);
-eval_fail_test!(fail_attr_name_type);
-eval_fail_test!(fail_attrset_merge_drops_later_rec);
-eval_fail_test!(fail_bad_string_interpolation_1);
-eval_fail_test!(fail_bad_string_interpolation_2);
-eval_fail_test!(fail_bad_string_interpolation_3);
-eval_fail_test!(fail_bad_string_interpolation_4);
-eval_fail_test!(fail_blackhole);
-eval_fail_test!(fail_call_primop);
-eval_fail_test!(fail_deepseq);
-eval_fail_test!(fail_derivation_name);
-eval_fail_test!(fail_dup_dynamic_attrs);
-eval_fail_test!(fail_duplicate_traces);
-eval_fail_test!(fail_eol_1);
-eval_fail_test!(fail_eol_2);
-eval_fail_test!(fail_eol_3);
-eval_fail_test!(fail_fetchTree_negative);
-eval_fail_test!(fail_fetchurl_baseName);
-eval_fail_test!(fail_fetchurl_baseName_attrs);
-eval_fail_test!(fail_fetchurl_baseName_attrs_name);
-eval_fail_test!(fail_flake_ref_to_string_negative_integer);
-eval_fail_test!(fail_foldlStrict_strict_op_application);
-eval_fail_test!(fail_fromJSON_keyWithNullByte);
-eval_fail_test!(fail_fromJSON_overflowing);
-eval_fail_test!(fail_fromJSON_valueWithNullByte);
-eval_fail_test!(fail_fromTOML_keyWithNullByte);
-eval_fail_test!(fail_fromTOML_timestamps);
-eval_fail_test!(fail_fromTOML_valueWithNullByte);
-eval_fail_test!(fail_hashfile_missing);
-eval_fail_test!(fail_infinite_recursion_lambda);
-eval_fail_test!(fail_list);
-eval_fail_test!(fail_missing_arg);
-eval_fail_test!(fail_mutual_recursion);
-eval_fail_test!(fail_nested_list_items);
-eval_fail_test!(fail_nonexist_path);
-eval_fail_test!(fail_not_throws);
-eval_fail_test!(fail_overflowing_add);
-eval_fail_test!(fail_overflowing_div);
-eval_fail_test!(fail_overflowing_mul);
-eval_fail_test!(fail_overflowing_sub);
-eval_fail_test!(fail_path_slash);
-eval_fail_test!(fail_pipe_operators);
-eval_fail_test!(fail_recursion);
-eval_fail_test!(fail_remove);
-eval_fail_test!(fail_scope_5);
-eval_fail_test!(fail_seq);
-eval_fail_test!(fail_set);
-eval_fail_test!(fail_set_override);
-eval_fail_test!(fail_string_nul_1);
-eval_fail_test!(fail_string_nul_2);
-eval_fail_test!(fail_substring);
-eval_fail_test!(fail_toJSON);
-eval_fail_test!(fail_toJSON_non_utf_8);
-eval_fail_test!(fail_to_path);
-eval_fail_test!(fail_undeclared_arg);
-eval_fail_test!(fail_using_set_as_attr_name);

fix/tests/tests/lang/data

@@ -1 +0,0 @@
-foo

fix/tests/tests/lang/dir1/a.nix

@@ -1 +0,0 @@
-"a"

fix/tests/tests/lang/dir2/a.nix

@@ -1 +0,0 @@
-"X"

fix/tests/tests/lang/dir2/b.nix

@@ -1 +0,0 @@
-"b"

fix/tests/tests/lang/dir3/a.nix

@@ -1 +0,0 @@
-"X"

fix/tests/tests/lang/dir3/b.nix

@@ -1 +0,0 @@
-"X"

fix/tests/tests/lang/dir3/c.nix

@@ -1 +0,0 @@
-"c"

fix/tests/tests/lang/dir4/a.nix

@@ -1 +0,0 @@
-"X"

fix/tests/tests/lang/dir4/c.nix

@@ -1 +0,0 @@
-"X"

fix/tests/tests/lang/eval-fail-abort.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while calling the 'abort' builtin
-         at /pwd/lang/eval-fail-abort.nix:1:14:
-            1| if true then abort "this should fail" else 1
-             |              ^
-            2|
-
-       error: evaluation aborted with the following error message: 'this should fail'

fix/tests/tests/lang/eval-fail-abort.nix

@@ -1 +0,0 @@
-if true then abort "this should fail" else 1

fix/tests/tests/lang/eval-fail-addDrvOutputDependencies-empty-context.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while calling the 'addDrvOutputDependencies' builtin
-         at /pwd/lang/eval-fail-addDrvOutputDependencies-empty-context.nix:1:1:
-            1| builtins.addDrvOutputDependencies ""
-             | ^
-            2|
-
-       error: context of string '' must have exactly one element, but has 0

fix/tests/tests/lang/eval-fail-addDrvOutputDependencies-empty-context.nix

@@ -1 +0,0 @@
-builtins.addDrvOutputDependencies ""

fix/tests/tests/lang/eval-fail-addDrvOutputDependencies-multi-elem-context.err.exp

@@ -1,9 +0,0 @@
-error:
-       … while calling the 'addDrvOutputDependencies' builtin
-         at /pwd/lang/eval-fail-addDrvOutputDependencies-multi-elem-context.nix:25:1:
-           24| in
-           25| builtins.addDrvOutputDependencies combo-path
-             | ^
-           26|
-
-       error: context of string '/nix/store/pg9yqs4yd85yhdm3f4i5dyaqp5jahrsz-fail.drv/nix/store/2dxd5frb715z451vbf7s8birlf3argbk-fail-2.drv' must have exactly one element, but has 2

fix/tests/tests/lang/eval-fail-addDrvOutputDependencies-multi-elem-context.nix

@@ -1,25 +0,0 @@
-let
-  drv0 = derivation {
-    name = "fail";
-    builder = "/bin/false";
-    system = "x86_64-linux";
-    outputs = [
-      "out"
-      "foo"
-    ];
-  };
-
-  drv1 = derivation {
-    name = "fail-2";
-    builder = "/bin/false";
-    system = "x86_64-linux";
-    outputs = [
-      "out"
-      "foo"
-    ];
-  };
-
-  combo-path = "${drv0.drvPath}${drv1.drvPath}";
-
-in
-builtins.addDrvOutputDependencies combo-path

fix/tests/tests/lang/eval-fail-addDrvOutputDependencies-wrong-element-kind.err.exp

@@ -1,9 +0,0 @@
-error:
-       … while calling the 'addDrvOutputDependencies' builtin
-         at /pwd/lang/eval-fail-addDrvOutputDependencies-wrong-element-kind.nix:13:1:
-           12| in
-           13| builtins.addDrvOutputDependencies drv.outPath
-             | ^
-           14|
-
-       error: `addDrvOutputDependencies` can only act on derivations, not on a derivation output such as 'out'

fix/tests/tests/lang/eval-fail-addDrvOutputDependencies-wrong-element-kind.nix

@@ -1,13 +0,0 @@
-let
-  drv = derivation {
-    name = "fail";
-    builder = "/bin/false";
-    system = "x86_64-linux";
-    outputs = [
-      "out"
-      "foo"
-    ];
-  };
-
-in
-builtins.addDrvOutputDependencies drv.outPath

fix/tests/tests/lang/eval-fail-addErrorContext-example.err.exp

@@ -1,24 +0,0 @@
-error:
-       … while counting down; n = 10
-
-       … while counting down; n = 9
-
-       … while counting down; n = 8
-
-       … while counting down; n = 7
-
-       … while counting down; n = 6
-
-       … while counting down; n = 5
-
-       … while counting down; n = 4
-
-       … while counting down; n = 3
-
-       … while counting down; n = 2
-
-       … while counting down; n = 1
-
-       (stack trace truncated; use '--show-trace' to show the full, detailed trace)
-
-       error: kaboom

fix/tests/tests/lang/eval-fail-addErrorContext-example.nix

@@ -1,9 +0,0 @@
-let
-  countDown =
-    n:
-    if n == 0 then
-      throw "kaboom"
-    else
-      builtins.addErrorContext "while counting down; n = ${toString n}" ("x" + countDown (n - 1));
-in
-countDown 10

fix/tests/tests/lang/eval-fail-assert-equal-attrs-names-2.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ a = true; } == { a = true; b = true; })'
-         at /pwd/lang/eval-fail-assert-equal-attrs-names-2.nix:1:1:
-            1| assert
-             | ^
-            2|   {
-
-       error: attribute names of attribute set '{ a = true; }' differs from attribute set '{ a = true; b = true; }'

fix/tests/tests/lang/eval-fail-assert-equal-attrs-names-2.nix

@@ -1,8 +0,0 @@
-assert
-  {
-    a = true;
-  } == {
-    a = true;
-    b = true;
-  };
-throw "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-attrs-names.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ a = true; b = true; } == { a = true; })'
-         at /pwd/lang/eval-fail-assert-equal-attrs-names.nix:1:1:
-            1| assert
-             | ^
-            2|   {
-
-       error: attribute names of attribute set '{ a = true; b = true; }' differs from attribute set '{ a = true; }'

fix/tests/tests/lang/eval-fail-assert-equal-attrs-names.nix

@@ -1,8 +0,0 @@
-assert
-  {
-    a = true;
-    b = true;
-  } == {
-    a = true;
-  };
-throw "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-derivations-extra.err.exp

@@ -1,26 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ foo = { outPath = "/nix/store/0"; type = "derivation"; }; } == { foo = { devious = true; outPath = "/nix/store/1"; type = "derivation"; }; })'
-         at /pwd/lang/eval-fail-assert-equal-derivations-extra.nix:1:1:
-            1| assert
-             | ^
-            2|   {
-
-       … while comparing attribute 'foo'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-equal-derivations-extra.nix:3:5:
-            2|   {
-            3|     foo = {
-             |     ^
-            4|       type = "derivation";
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-equal-derivations-extra.nix:8:5:
-            7|   } == {
-            8|     foo = {
-             |     ^
-            9|       type = "derivation";
-
-       … while comparing a derivation by its 'outPath' attribute
-
-       error: string '"/nix/store/0"' is not equal to string '"/nix/store/1"'

fix/tests/tests/lang/eval-fail-assert-equal-derivations-extra.nix

@@ -1,14 +0,0 @@
-assert
-  {
-    foo = {
-      type = "derivation";
-      outPath = "/nix/store/0";
-    };
-  } == {
-    foo = {
-      type = "derivation";
-      outPath = "/nix/store/1";
-      devious = true;
-    };
-  };
-throw "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-derivations.err.exp

@@ -1,26 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ foo = { ignored = (abort "not ignored"); outPath = "/nix/store/0"; type = "derivation"; }; } == { foo = { ignored = (abort "not ignored"); outPath = "/nix/store/1"; type = "derivation"; }; })'
-         at /pwd/lang/eval-fail-assert-equal-derivations.nix:1:1:
-            1| assert
-             | ^
-            2|   {
-
-       … while comparing attribute 'foo'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-equal-derivations.nix:3:5:
-            2|   {
-            3|     foo = {
-             |     ^
-            4|       type = "derivation";
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-equal-derivations.nix:9:5:
-            8|   } == {
-            9|     foo = {
-             |     ^
-           10|       type = "derivation";
-
-       … while comparing a derivation by its 'outPath' attribute
-
-       error: string '"/nix/store/0"' is not equal to string '"/nix/store/1"'

fix/tests/tests/lang/eval-fail-assert-equal-derivations.nix

@@ -1,15 +0,0 @@
-assert
-  {
-    foo = {
-      type = "derivation";
-      outPath = "/nix/store/0";
-      ignored = abort "not ignored";
-    };
-  } == {
-    foo = {
-      type = "derivation";
-      outPath = "/nix/store/1";
-      ignored = abort "not ignored";
-    };
-  };
-throw "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-floats.err.exp

@@ -1,22 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ b = 1; } == { b = 1.01; })'
-         at /pwd/lang/eval-fail-assert-equal-floats.nix:1:1:
-            1| assert { b = 1.0; } == { b = 1.01; };
-             | ^
-            2| abort "unreachable"
-
-       … while comparing attribute 'b'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-equal-floats.nix:1:10:
-            1| assert { b = 1.0; } == { b = 1.01; };
-             |          ^
-            2| abort "unreachable"
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-equal-floats.nix:1:26:
-            1| assert { b = 1.0; } == { b = 1.01; };
-             |                          ^
-            2| abort "unreachable"
-
-       error: a float with value '1' is not equal to a float with value '1.01'

fix/tests/tests/lang/eval-fail-assert-equal-floats.nix

@@ -1,2 +0,0 @@
-assert { b = 1.0; } == { b = 1.01; };
-abort "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-function-direct.err.exp

@@ -1,9 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '((x: x) == (x: x))'
-         at /pwd/lang/eval-fail-assert-equal-function-direct.nix:3:1:
-            2| # This only compares a direct comparison and makes no claims about functions in nested structures.
-            3| assert (x: x) == (x: x);
-             | ^
-            4| abort "unreachable"
-
-       error: distinct functions and immediate comparisons of identical functions compare as unequal

fix/tests/tests/lang/eval-fail-assert-equal-function-direct.nix

@@ -1,4 +0,0 @@
-# Note: functions in nested structures, e.g. attributes, may be optimized away by pointer identity optimization.
-# This only compares a direct comparison and makes no claims about functions in nested structures.
-assert (x: x) == (x: x);
-abort "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-int-float.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '(1 == 1.1)'
-         at /pwd/lang/eval-fail-assert-equal-int-float.nix:1:1:
-            1| assert 1 == 1.1;
-             | ^
-            2| throw "unreachable"
-
-       error: an integer with value '1' is not equal to a float with value '1.1'

fix/tests/tests/lang/eval-fail-assert-equal-int-float.nix

@@ -1,2 +0,0 @@
-assert 1 == 1.1;
-throw "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-ints.err.exp

@@ -1,22 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ b = 1; } == { b = 2; })'
-         at /pwd/lang/eval-fail-assert-equal-ints.nix:1:1:
-            1| assert { b = 1; } == { b = 2; };
-             | ^
-            2| abort "unreachable"
-
-       … while comparing attribute 'b'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-equal-ints.nix:1:10:
-            1| assert { b = 1; } == { b = 2; };
-             |          ^
-            2| abort "unreachable"
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-equal-ints.nix:1:24:
-            1| assert { b = 1; } == { b = 2; };
-             |                        ^
-            2| abort "unreachable"
-
-       error: an integer with value '1' is not equal to an integer with value '2'

fix/tests/tests/lang/eval-fail-assert-equal-ints.nix

@@ -1,2 +0,0 @@
-assert { b = 1; } == { b = 2; };
-abort "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-list-length.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '([ (1) (0) ] == [ (10) ])'
-         at /pwd/lang/eval-fail-assert-equal-list-length.nix:1:1:
-            1| assert
-             | ^
-            2|   [
-
-       error: list of size '2' is not equal to list of size '1', left hand side is '[ 1 0 ]', right hand side is '[ 10 ]'

fix/tests/tests/lang/eval-fail-assert-equal-list-length.nix

@@ -1,6 +0,0 @@
-assert
-  [
-    1
-    0
-  ] == [ 10 ];
-throw "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-paths.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '(/pwd/lang/foo == /pwd/lang/bar)'
-         at /pwd/lang/eval-fail-assert-equal-paths.nix:1:1:
-            1| assert ./foo == ./bar;
-             | ^
-            2| throw "unreachable"
-
-       error: path '/pwd/lang/foo' is not equal to path '/pwd/lang/bar'

fix/tests/tests/lang/eval-fail-assert-equal-paths.nix

@@ -1,2 +0,0 @@
-assert ./foo == ./bar;
-throw "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-type-nested.err.exp

@@ -1,22 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ ding = false; } == { ding = null; })'
-         at /pwd/lang/eval-fail-assert-equal-type-nested.nix:1:1:
-            1| assert { ding = false; } == { ding = null; };
-             | ^
-            2| abort "unreachable"
-
-       … while comparing attribute 'ding'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-equal-type-nested.nix:1:10:
-            1| assert { ding = false; } == { ding = null; };
-             |          ^
-            2| abort "unreachable"
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-equal-type-nested.nix:1:31:
-            1| assert { ding = false; } == { ding = null; };
-             |                               ^
-            2| abort "unreachable"
-
-       error: a Boolean of value 'false' is not equal to null of value 'null'

fix/tests/tests/lang/eval-fail-assert-equal-type-nested.nix

@@ -1,2 +0,0 @@
-assert { ding = false; } == { ding = null; };
-abort "unreachable"

fix/tests/tests/lang/eval-fail-assert-equal-type.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '(false == null)'
-         at /pwd/lang/eval-fail-assert-equal-type.nix:1:1:
-            1| assert false == null;
-             | ^
-            2| abort "unreachable"
-
-       error: a Boolean of value 'false' is not equal to null of value 'null'

fix/tests/tests/lang/eval-fail-assert-equal-type.nix

@@ -1,2 +0,0 @@
-assert false == null;
-abort "unreachable"

fix/tests/tests/lang/eval-fail-assert-nested-bool.err.exp

@@ -1,66 +0,0 @@
-error:
-       … while evaluating the condition of the assertion '({ a = { b = [ ({ c = { d = true; }; }) ]; }; } == { a = { b = [ ({ c = { d = false; }; }) ]; }; })'
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:1:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             | ^
-            2|
-
-       … while comparing attribute 'a'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:10:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |          ^
-            2|
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:44:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |                                            ^
-            2|
-
-       … while comparing attribute 'b'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:10:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |          ^
-            2|
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:44:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |                                            ^
-            2|
-
-       … while comparing list element 0
-
-       … while comparing attribute 'c'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:20:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |                    ^
-            2|
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:54:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |                                                      ^
-            2|
-
-       … while comparing attribute 'd'
-
-       … where left hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:20:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |                    ^
-            2|
-
-       … where right hand side is
-         at /pwd/lang/eval-fail-assert-nested-bool.nix:1:54:
-            1| assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-             |                                                      ^
-            2|
-
-       error: boolean 'true' is not equal to boolean 'false'

fix/tests/tests/lang/eval-fail-assert-nested-bool.nix

@@ -1,3 +0,0 @@
-assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-
-abort "unreachable"

fix/tests/tests/lang/eval-fail-assert.err.exp

@@ -1,30 +0,0 @@
-error:
-       … while evaluating the attribute 'body'
-         at /pwd/lang/eval-fail-assert.nix:7:3:
-            6|
-            7|   body = x "x";
-             |   ^
-            8| }
-
-       … from call site
-         at /pwd/lang/eval-fail-assert.nix:7:10:
-            6|
-            7|   body = x "x";
-             |          ^
-            8| }
-
-       … while calling 'x'
-         at /pwd/lang/eval-fail-assert.nix:3:5:
-            2|   x =
-            3|     arg:
-             |     ^
-            4|     assert arg == "y";
-
-       … while evaluating the condition of the assertion '(arg == "y")'
-         at /pwd/lang/eval-fail-assert.nix:4:5:
-            3|     arg:
-            4|     assert arg == "y";
-             |     ^
-            5|     123;
-
-       error: string '"x"' is not equal to string '"y"'

fix/tests/tests/lang/eval-fail-assert.nix

@@ -1,8 +0,0 @@
-let {
-  x =
-    arg:
-    assert arg == "y";
-    123;
-
-  body = x "x";
-}

fix/tests/tests/lang/eval-fail-attr-name-type.err.exp

@@ -1,21 +0,0 @@
-error:
-       … while evaluating the attribute 'puppy."${key}"'
-         at /pwd/lang/eval-fail-attr-name-type.nix:3:5:
-            2|   attrs = {
-            3|     puppy.doggy = { };
-             |     ^
-            4|   };
-
-       … while evaluating an attribute name
-         at /pwd/lang/eval-fail-attr-name-type.nix:7:15:
-            6| in
-            7| attrs.puppy.${key}
-             |               ^
-            8|
-
-       error: expected a string but found an integer: 1
-       at /pwd/lang/eval-fail-attr-name-type.nix:7:15:
-            6| in
-            7| attrs.puppy.${key}
-             |               ^
-            8|

fix/tests/tests/lang/eval-fail-attr-name-type.nix

@@ -1,7 +0,0 @@
-let
-  attrs = {
-    puppy.doggy = { };
-  };
-  key = 1;
-in
-attrs.puppy.${key}

fix/tests/tests/lang/eval-fail-attrset-merge-drops-later-rec.err.exp

@@ -1,6 +0,0 @@
-error: undefined variable 'd'
-       at /pwd/lang/eval-fail-attrset-merge-drops-later-rec.nix:4:9:
-            3|   a = rec {
-            4|     c = d + 2;
-             |         ^
-            5|     d = 3;

fix/tests/tests/lang/eval-fail-attrset-merge-drops-later-rec.nix

@@ -1,8 +0,0 @@
-{
-  a.b = 1;
-  a = rec {
-    c = d + 2;
-    d = 3;
-  };
-}
-.c

fix/tests/tests/lang/eval-fail-bad-string-interpolation-1.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating a path segment
-         at /pwd/lang/eval-fail-bad-string-interpolation-1.nix:1:2:
-            1| "${x: x}"
-             |  ^
-            2|
-
-       error: cannot coerce a function to a string: «lambda @ /pwd/lang/eval-fail-bad-string-interpolation-1.nix:1:4»

fix/tests/tests/lang/eval-fail-bad-string-interpolation-1.nix

@@ -1 +0,0 @@
-"${x: x}"

fix/tests/tests/lang/eval-fail-bad-string-interpolation-2.err.exp

@@ -1 +0,0 @@
-error: path '/pwd/lang/fnord' does not exist

fix/tests/tests/lang/eval-fail-bad-string-interpolation-2.nix

@@ -1 +0,0 @@
-"${./fnord}"

fix/tests/tests/lang/eval-fail-bad-string-interpolation-3.err.exp

@@ -1,8 +0,0 @@
-error:
-       … while evaluating a path segment
-         at /pwd/lang/eval-fail-bad-string-interpolation-3.nix:1:3:
-            1| ''${x: x}''
-             |   ^
-            2|
-
-       error: cannot coerce a function to a string: «lambda @ /pwd/lang/eval-fail-bad-string-interpolation-3.nix:1:5»

fix/tests/tests/lang/eval-fail-bad-string-interpolation-3.nix

@@ -1 +0,0 @@
-''${x: x}''

fix/tests/tests/lang/eval-fail-bad-string-interpolation-4.err.exp

@@ -1,9 +0,0 @@
-error:
-       … while evaluating a path segment
-         at /pwd/lang/eval-fail-bad-string-interpolation-4.nix:19:3:
-           18| # The error message should not be too long.
-           19| ''${pkgs}''
-             |   ^
-           20|
-
-       error: cannot coerce a set to a string: { a = { a = { a = { a = "ha"; b = "ha"; c = "ha"; d = "ha"; e = "ha"; f = "ha"; g = "ha"; h = "ha"; j = "ha"; }; «8 attributes elided» }; «8 attributes elided» }; «8 attributes elided» }

fix/tests/tests/lang/eval-fail-bad-string-interpolation-4.nix

@@ -1,19 +0,0 @@
-let
-  # Basically a "billion laughs" attack, but toned down to simulated `pkgs`.
-  ha = x: y: {
-    a = x y;
-    b = x y;
-    c = x y;
-    d = x y;
-    e = x y;
-    f = x y;
-    g = x y;
-    h = x y;
-    j = x y;
-  };
-  has = ha (ha (ha (ha (x: x)))) "ha";
-  # A large structure that has already been evaluated.
-  pkgs = builtins.deepSeq has has;
-in
-# The error message should not be too long.
-''${pkgs}''

fix/tests/tests/lang/eval-fail-blackhole.err.exp

@@ -1,14 +0,0 @@
-error:
-       … while evaluating the attribute 'body'
-         at /pwd/lang/eval-fail-blackhole.nix:2:3:
-            1| let {
-            2|   body = x;
-             |   ^
-            3|   x = y;
-
-       error: infinite recursion encountered
-       at /pwd/lang/eval-fail-blackhole.nix:3:7:
-            2|   body = x;
-            3|   x = y;
-             |       ^
-            4|   y = x;

fix/tests/tests/lang/eval-fail-blackhole.nix

@@ -1,5 +0,0 @@
-let {
-  body = x;
-  x = y;
-  y = x;
-}

fix/tests/tests/lang/eval-fail-call-primop.err.exp

@@ -1,10 +0,0 @@
-error:
-       … while calling the 'length' builtin
-         at /pwd/lang/eval-fail-call-primop.nix:1:1:
-            1| builtins.length 1
-             | ^
-            2|
-
-       … while evaluating the first argument passed to builtins.length
-
-       error: expected a list but found an integer: 1

fix/tests/tests/lang/eval-fail-call-primop.nix

@@ -1 +0,0 @@
-builtins.length 1

fix/tests/tests/lang/eval-fail-deepseq.err.exp

@@ -1,20 +0,0 @@
-error:
-       … while calling the 'deepSeq' builtin
-         at /pwd/lang/eval-fail-deepseq.nix:1:1:
-            1| builtins.deepSeq { x = abort "foo"; } 456
-             | ^
-            2|
-
-       … while evaluating the attribute 'x'
-         at /pwd/lang/eval-fail-deepseq.nix:1:20:
-            1| builtins.deepSeq { x = abort "foo"; } 456
-             |                    ^
-            2|
-
-       … while calling the 'abort' builtin
-         at /pwd/lang/eval-fail-deepseq.nix:1:24:
-            1| builtins.deepSeq { x = abort "foo"; } 456
-             |                        ^
-            2|
-
-       error: evaluation aborted with the following error message: 'foo'

fix/tests/tests/lang/eval-fail-deepseq.nix

@@ -1 +0,0 @@
-builtins.deepSeq { x = abort "foo"; } 456

fix/tests/tests/lang/eval-fail-derivation-name.err.exp

@@ -1,26 +0,0 @@
-error:
-       … while evaluating the attribute 'outPath'
-         at <nix/derivation-internal.nix>:<number>:<number>:
-     <number>|     value = commonAttrs // {
-     <number>|       outPath = builtins.getAttr outputName strict;
-             |       ^
-     <number>|       drvPath = strict.drvPath;
-
-       … while calling the 'getAttr' builtin
-         at <nix/derivation-internal.nix>:<number>:<number>:
-     <number>|     value = commonAttrs // {
-     <number>|       outPath = builtins.getAttr outputName strict;
-             |                 ^
-     <number>|       drvPath = strict.drvPath;
-
-       … while calling the 'derivationStrict' builtin
-         at <nix/derivation-internal.nix>:<number>:<number>:
-     <number>|
-     <number>|   strict = derivationStrict drvAttrs;
-             |            ^
-     <number>|
-
-       … while evaluating derivation '~jiggle~'
-         whose name attribute is located at /pwd/lang/eval-fail-derivation-name.nix:<number>:<number>
-
-       error: invalid derivation name: name '~jiggle~' contains illegal character '~'. Please pass a different 'name'.