Move /src to /subprojects

This will facilitate breaking up Nix into multiple packages for each
component with Meson.

subprojects/libexpr/.version

@@ -0,0 +1 @@
+../../.version

subprojects/libexpr/attr-path.cc

@@ -0,0 +1,142 @@
+#include "attr-path.hh"
+#include "eval-inline.hh"
+
+
+namespace nix {
+
+
+static Strings parseAttrPath(std::string_view s)
+{
+    Strings res;
+    std::string cur;
+    auto i = s.begin();
+    while (i != s.end()) {
+        if (*i == '.') {
+            res.push_back(cur);
+            cur.clear();
+        } else if (*i == '"') {
+            ++i;
+            while (1) {
+                if (i == s.end())
+                    throw ParseError("missing closing quote in selection path '%1%'", s);
+                if (*i == '"') break;
+                cur.push_back(*i++);
+            }
+        } else
+            cur.push_back(*i);
+        ++i;
+    }
+    if (!cur.empty()) res.push_back(cur);
+    return res;
+}
+
+
+std::vector<Symbol> parseAttrPath(EvalState & state, std::string_view s)
+{
+    std::vector<Symbol> res;
+    for (auto & a : parseAttrPath(s))
+        res.push_back(state.symbols.create(a));
+    return res;
+}
+
+
+std::pair<Value *, PosIdx> findAlongAttrPath(EvalState & state, const std::string & attrPath,
+    Bindings & autoArgs, Value & vIn)
+{
+    Strings tokens = parseAttrPath(attrPath);
+
+    Value * v = &vIn;
+    PosIdx pos = noPos;
+
+    for (auto & attr : tokens) {
+
+        /* Is i an index (integer) or a normal attribute name? */
+        auto attrIndex = string2Int<unsigned int>(attr);
+
+        /* Evaluate the expression. */
+        Value * vNew = state.allocValue();
+        state.autoCallFunction(autoArgs, *v, *vNew);
+        v = vNew;
+        state.forceValue(*v, noPos);
+
+        /* It should evaluate to either a set or an expression,
+           according to what is specified in the attrPath. */
+
+        if (!attrIndex) {
+
+            if (v->type() != nAttrs)
+                state.error<TypeError>(
+                    "the expression selected by the selection path '%1%' should be a set but is %2%",
+                    attrPath,
+                    showType(*v)).debugThrow();
+            if (attr.empty())
+                throw Error("empty attribute name in selection path '%1%'", attrPath);
+
+            auto a = v->attrs()->get(state.symbols.create(attr));
+            if (!a) {
+                std::set<std::string> attrNames;
+                for (auto & attr : *v->attrs())
+                    attrNames.insert(std::string(state.symbols[attr.name]));
+
+                auto suggestions = Suggestions::bestMatches(attrNames, attr);
+                throw AttrPathNotFound(suggestions, "attribute '%1%' in selection path '%2%' not found", attr, attrPath);
+            }
+            v = &*a->value;
+            pos = a->pos;
+        }
+
+        else {
+
+            if (!v->isList())
+                state.error<TypeError>(
+                    "the expression selected by the selection path '%1%' should be a list but is %2%",
+                    attrPath,
+                    showType(*v)).debugThrow();
+            if (*attrIndex >= v->listSize())
+                throw AttrPathNotFound("list index %1% in selection path '%2%' is out of range", *attrIndex, attrPath);
+
+            v = v->listElems()[*attrIndex];
+            pos = noPos;
+        }
+
+    }
+
+    return {v, pos};
+}
+
+
+std::pair<SourcePath, uint32_t> findPackageFilename(EvalState & state, Value & v, std::string what)
+{
+    Value * v2;
+    try {
+        auto dummyArgs = state.allocBindings(0);
+        v2 = findAlongAttrPath(state, "meta.position", *dummyArgs, v).first;
+    } catch (Error &) {
+        throw NoPositionInfo("package '%s' has no source location information", what);
+    }
+
+    // FIXME: is it possible to extract the Pos object instead of doing this
+    //        toString + parsing?
+    NixStringContext context;
+    auto path = state.coerceToPath(noPos, *v2, context, "while evaluating the 'meta.position' attribute of a derivation");
+
+    auto fn = path.path.abs();
+
+    auto fail = [fn]() {
+        throw ParseError("cannot parse 'meta.position' attribute '%s'", fn);
+    };
+
+    try {
+        auto colon = fn.rfind(':');
+        if (colon == std::string::npos) fail();
+        std::string filename(fn, 0, colon);
+        auto lineno = std::stoi(std::string(fn, colon + 1, std::string::npos));
+        return {SourcePath{path.accessor, CanonPath(fn.substr(0, colon))}, lineno};
+    } catch (std::invalid_argument & e) {
+        fail();
+        unreachable();
+    }
+}
+
+
+}

subprojects/libexpr/attr-path.hh

@@ -0,0 +1,27 @@
+#pragma once
+///@file
+
+#include "eval.hh"
+
+#include <string>
+#include <map>
+
+namespace nix {
+
+MakeError(AttrPathNotFound, Error);
+MakeError(NoPositionInfo, Error);
+
+std::pair<Value *, PosIdx> findAlongAttrPath(
+    EvalState & state,
+    const std::string & attrPath,
+    Bindings & autoArgs,
+    Value & vIn);
+
+/**
+ * Heuristic to find the filename and lineno or a nix value.
+ */
+std::pair<SourcePath, uint32_t> findPackageFilename(EvalState & state, Value & v, std::string what);
+
+std::vector<Symbol> parseAttrPath(EvalState & state, std::string_view s);
+
+}

subprojects/libexpr/attr-set.cc

@@ -0,0 +1,53 @@
+#include "attr-set.hh"
+#include "eval-inline.hh"
+
+#include <algorithm>
+
+
+namespace nix {
+
+
+
+/* Allocate a new array of attributes for an attribute set with a specific
+   capacity. The space is implicitly reserved after the Bindings
+   structure. */
+Bindings * EvalState::allocBindings(size_t capacity)
+{
+    if (capacity == 0)
+        return &emptyBindings;
+    if (capacity > std::numeric_limits<Bindings::size_t>::max())
+        throw Error("attribute set of size %d is too big", capacity);
+    nrAttrsets++;
+    nrAttrsInAttrsets += capacity;
+    return new (allocBytes(sizeof(Bindings) + sizeof(Attr) * capacity)) Bindings((Bindings::size_t) capacity);
+}
+
+
+Value & BindingsBuilder::alloc(Symbol name, PosIdx pos)
+{
+    auto value = state.allocValue();
+    bindings->push_back(Attr(name, value, pos));
+    return *value;
+}
+
+
+Value & BindingsBuilder::alloc(std::string_view name, PosIdx pos)
+{
+    return alloc(state.symbols.create(name), pos);
+}
+
+
+void Bindings::sort()
+{
+    if (size_) std::sort(begin(), end());
+}
+
+
+Value & Value::mkAttrs(BindingsBuilder & bindings)
+{
+    mkAttrs(bindings.finish());
+    return *this;
+}
+
+
+}

subprojects/libexpr/attr-set.hh

@@ -0,0 +1,194 @@
+#pragma once
+///@file
+
+#include "nixexpr.hh"
+#include "symbol-table.hh"
+
+#include <algorithm>
+
+namespace nix {
+
+
+class EvalState;
+struct Value;
+
+/**
+ * Map one attribute name to its value.
+ */
+struct Attr
+{
+    /* the placement of `name` and `pos` in this struct is important.
+       both of them are uint32 wrappers, they are next to each other
+       to make sure that Attr has no padding on 64 bit machines. that
+       way we keep Attr size at two words with no wasted space. */
+    Symbol name;
+    PosIdx pos;
+    Value * value;
+    Attr(Symbol name, Value * value, PosIdx pos = noPos)
+        : name(name), pos(pos), value(value) { };
+    Attr() { };
+    auto operator <=> (const Attr & a) const
+    {
+        return name <=> a.name;
+    }
+};
+
+static_assert(sizeof(Attr) == 2 * sizeof(uint32_t) + sizeof(Value *),
+    "performance of the evaluator is highly sensitive to the size of Attr. "
+    "avoid introducing any padding into Attr if at all possible, and do not "
+    "introduce new fields that need not be present for almost every instance.");
+
+/**
+ * Bindings contains all the attributes of an attribute set. It is defined
+ * by its size and its capacity, the capacity being the number of Attr
+ * elements allocated after this structure, while the size corresponds to
+ * the number of elements already inserted in this structure.
+ */
+class Bindings
+{
+public:
+    typedef uint32_t size_t;
+    PosIdx pos;
+
+private:
+    size_t size_, capacity_;
+    Attr attrs[0];
+
+    Bindings(size_t capacity) : size_(0), capacity_(capacity) { }
+    Bindings(const Bindings & bindings) = delete;
+
+public:
+    size_t size() const { return size_; }
+
+    bool empty() const { return !size_; }
+
+    typedef Attr * iterator;
+
+    typedef const Attr * const_iterator;
+
+    void push_back(const Attr & attr)
+    {
+        assert(size_ < capacity_);
+        attrs[size_++] = attr;
+    }
+
+    const_iterator find(Symbol name) const
+    {
+        Attr key(name, 0);
+        const_iterator i = std::lower_bound(begin(), end(), key);
+        if (i != end() && i->name == name) return i;
+        return end();
+    }
+
+    const Attr * get(Symbol name) const
+    {
+        Attr key(name, 0);
+        const_iterator i = std::lower_bound(begin(), end(), key);
+        if (i != end() && i->name == name) return &*i;
+        return nullptr;
+    }
+
+    iterator begin() { return &attrs[0]; }
+    iterator end() { return &attrs[size_]; }
+
+    const_iterator begin() const { return &attrs[0]; }
+    const_iterator end() const { return &attrs[size_]; }
+
+    Attr & operator[](size_t pos)
+    {
+        return attrs[pos];
+    }
+
+    const Attr & operator[](size_t pos) const
+    {
+        return attrs[pos];
+    }
+
+    void sort();
+
+    size_t capacity() const { return capacity_; }
+
+    /**
+     * Returns the attributes in lexicographically sorted order.
+     */
+    std::vector<const Attr *> lexicographicOrder(const SymbolTable & symbols) const
+    {
+        std::vector<const Attr *> res;
+        res.reserve(size_);
+        for (size_t n = 0; n < size_; n++)
+            res.emplace_back(&attrs[n]);
+        std::sort(res.begin(), res.end(), [&](const Attr * a, const Attr * b) {
+            std::string_view sa = symbols[a->name], sb = symbols[b->name];
+            return sa < sb;
+        });
+        return res;
+    }
+
+    friend class EvalState;
+};
+
+/**
+ * A wrapper around Bindings that ensures that its always in sorted
+ * order at the end. The only way to consume a BindingsBuilder is to
+ * call finish(), which sorts the bindings.
+ */
+class BindingsBuilder
+{
+    Bindings * bindings;
+
+public:
+    // needed by std::back_inserter
+    using value_type = Attr;
+
+    EvalState & state;
+
+    BindingsBuilder(EvalState & state, Bindings * bindings)
+        : bindings(bindings), state(state)
+    { }
+
+    void insert(Symbol name, Value * value, PosIdx pos = noPos)
+    {
+        insert(Attr(name, value, pos));
+    }
+
+    void insert(const Attr & attr)
+    {
+        push_back(attr);
+    }
+
+    void push_back(const Attr & attr)
+    {
+        bindings->push_back(attr);
+    }
+
+    Value & alloc(Symbol name, PosIdx pos = noPos);
+
+    Value & alloc(std::string_view name, PosIdx pos = noPos);
+
+    Bindings * finish()
+    {
+        bindings->sort();
+        return bindings;
+    }
+
+    Bindings * alreadySorted()
+    {
+        return bindings;
+    }
+
+    size_t capacity()
+    {
+        return bindings->capacity();
+    }
+
+    void grow(Bindings * newBindings)
+    {
+        for (auto & i : *bindings)
+            newBindings->push_back(i);
+        bindings = newBindings;
+    }
+
+    friend struct ExprAttrs;
+};
+
+}

subprojects/libexpr/build-utils-meson

@@ -0,0 +1 @@
+../../build-utils-meson

subprojects/libexpr/call-flake.nix

@@ -0,0 +1,85 @@
+# This is a helper to callFlake() to lazily fetch flake inputs.
+
+# The contents of the lock file, in JSON format.
+lockFileStr:
+
+# A mapping of lock file node IDs to { sourceInfo, subdir } attrsets,
+# with sourceInfo.outPath providing an SourceAccessor to a previously
+# fetched tree. This is necessary for possibly unlocked inputs, in
+# particular the root input, but also --override-inputs pointing to
+# unlocked trees.
+overrides:
+
+let
+
+  lockFile = builtins.fromJSON lockFileStr;
+
+  # Resolve a input spec into a node name. An input spec is
+  # either a node name, or a 'follows' path from the root
+  # node.
+  resolveInput = inputSpec:
+    if builtins.isList inputSpec
+    then getInputByPath lockFile.root inputSpec
+    else inputSpec;
+
+  # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
+  # root node, returning the final node.
+  getInputByPath = nodeName: path:
+    if path == []
+    then nodeName
+    else
+      getInputByPath
+        # Since this could be a 'follows' input, call resolveInput.
+        (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
+        (builtins.tail path);
+
+  allNodes =
+    builtins.mapAttrs
+      (key: node:
+        let
+
+          sourceInfo =
+            if overrides ? ${key}
+            then
+              overrides.${key}.sourceInfo
+            else
+              # FIXME: remove obsolete node.info.
+              fetchTree (node.info or {} // removeAttrs node.locked ["dir"]);
+
+          subdir = overrides.${key}.dir or node.locked.dir or "";
+
+          outPath = sourceInfo + ((if subdir == "" then "" else "/") + subdir);
+
+          flake = import (outPath + "/flake.nix");
+
+          inputs = builtins.mapAttrs
+            (inputName: inputSpec: allNodes.${resolveInput inputSpec})
+            (node.inputs or {});
+
+          outputs = flake.outputs (inputs // { self = result; });
+
+          result =
+            outputs
+            # We add the sourceInfo attribute for its metadata, as they are
+            # relevant metadata for the flake. However, the outPath of the
+            # sourceInfo does not necessarily match the outPath of the flake,
+            # as the flake may be in a subdirectory of a source.
+            # This is shadowed in the next //
+            // sourceInfo
+            // {
+              # This shadows the sourceInfo.outPath
+              inherit outPath;
+
+              inherit inputs; inherit outputs; inherit sourceInfo; _type = "flake";
+            };
+
+        in
+          if node.flake or true then
+            assert builtins.isFunction flake.outputs;
+            result
+          else
+            sourceInfo
+      )
+      lockFile.nodes;
+
+in allNodes.${lockFile.root}

subprojects/libexpr/eval-cache.cc

@@ -0,0 +1,786 @@
+#include "users.hh"
+#include "eval-cache.hh"
+#include "sqlite.hh"
+#include "eval.hh"
+#include "eval-inline.hh"
+#include "store-api.hh"
+// Need specialization involving `SymbolStr` just in this one module.
+#include "strings-inline.hh"
+
+namespace nix::eval_cache {
+
+CachedEvalError::CachedEvalError(ref<AttrCursor> cursor, Symbol attr)
+    : EvalError(cursor->root->state, "cached failure of attribute '%s'", cursor->getAttrPathStr(attr))
+    , cursor(cursor), attr(attr)
+{ }
+
+void CachedEvalError::force()
+{
+    auto & v = cursor->forceValue();
+
+    if (v.type() == nAttrs) {
+        auto a = v.attrs()->get(this->attr);
+
+        state.forceValue(*a->value, a->pos);
+    }
+
+    // Shouldn't happen.
+    throw EvalError(state, "evaluation of cached failed attribute '%s' unexpectedly succeeded", cursor->getAttrPathStr(attr));
+}
+
+static const char * schema = R"sql(
+create table if not exists Attributes (
+    parent      integer not null,
+    name        text,
+    type        integer not null,
+    value       text,
+    context     text,
+    primary key (parent, name)
+);
+)sql";
+
+struct AttrDb
+{
+    std::atomic_bool failed{false};
+
+    const StoreDirConfig & cfg;
+
+    struct State
+    {
+        SQLite db;
+        SQLiteStmt insertAttribute;
+        SQLiteStmt insertAttributeWithContext;
+        SQLiteStmt queryAttribute;
+        SQLiteStmt queryAttributes;
+        std::unique_ptr<SQLiteTxn> txn;
+    };
+
+    std::unique_ptr<Sync<State>> _state;
+
+    SymbolTable & symbols;
+
+    AttrDb(
+        const StoreDirConfig & cfg,
+        const Hash & fingerprint,
+        SymbolTable & symbols)
+        : cfg(cfg)
+        , _state(std::make_unique<Sync<State>>())
+        , symbols(symbols)
+    {
+        auto state(_state->lock());
+
+        Path cacheDir = getCacheDir() + "/eval-cache-v5";
+        createDirs(cacheDir);
+
+        Path dbPath = cacheDir + "/" + fingerprint.to_string(HashFormat::Base16, false) + ".sqlite";
+
+        state->db = SQLite(dbPath);
+        state->db.isCache();
+        state->db.exec(schema);
+
+        state->insertAttribute.create(state->db,
+            "insert or replace into Attributes(parent, name, type, value) values (?, ?, ?, ?)");
+
+        state->insertAttributeWithContext.create(state->db,
+            "insert or replace into Attributes(parent, name, type, value, context) values (?, ?, ?, ?, ?)");
+
+        state->queryAttribute.create(state->db,
+            "select rowid, type, value, context from Attributes where parent = ? and name = ?");
+
+        state->queryAttributes.create(state->db,
+            "select name from Attributes where parent = ?");
+
+        state->txn = std::make_unique<SQLiteTxn>(state->db);
+    }
+
+    ~AttrDb()
+    {
+        try {
+            auto state(_state->lock());
+            if (!failed && state->txn->active)
+                state->txn->commit();
+            state->txn.reset();
+        } catch (...) {
+            ignoreExceptionInDestructor();
+        }
+    }
+
+    template<typename F>
+    AttrId doSQLite(F && fun)
+    {
+        if (failed) return 0;
+        try {
+            return fun();
+        } catch (SQLiteError &) {
+            ignoreExceptionExceptInterrupt();
+            failed = true;
+            return 0;
+        }
+    }
+
+    AttrId setAttrs(
+        AttrKey key,
+        const std::vector<Symbol> & attrs)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::FullAttrs)
+                (0, false).exec();
+
+            AttrId rowId = state->db.getLastInsertedRowId();
+            assert(rowId);
+
+            for (auto & attr : attrs)
+                state->insertAttribute.use()
+                    (rowId)
+                    (symbols[attr])
+                    (AttrType::Placeholder)
+                    (0, false).exec();
+
+            return rowId;
+        });
+    }
+
+    AttrId setString(
+        AttrKey key,
+        std::string_view s,
+        const char * * context = nullptr)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            if (context) {
+                std::string ctx;
+                for (const char * * p = context; *p; ++p) {
+                    if (p != context) ctx.push_back(' ');
+                    ctx.append(*p);
+                }
+                state->insertAttributeWithContext.use()
+                    (key.first)
+                    (symbols[key.second])
+                    (AttrType::String)
+                    (s)
+                    (ctx).exec();
+            } else {
+                state->insertAttribute.use()
+                    (key.first)
+                    (symbols[key.second])
+                    (AttrType::String)
+                (s).exec();
+            }
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    AttrId setBool(
+        AttrKey key,
+        bool b)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::Bool)
+                (b ? 1 : 0).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    AttrId setInt(
+        AttrKey key,
+        int n)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::Int)
+                (n).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    AttrId setListOfStrings(
+        AttrKey key,
+        const std::vector<std::string> & l)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::ListOfStrings)
+                (dropEmptyInitThenConcatStringsSep("\t", l)).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    AttrId setPlaceholder(AttrKey key)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::Placeholder)
+                (0, false).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    AttrId setMissing(AttrKey key)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::Missing)
+                (0, false).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    AttrId setMisc(AttrKey key)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::Misc)
+                (0, false).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    AttrId setFailed(AttrKey key)
+    {
+        return doSQLite([&]()
+        {
+            auto state(_state->lock());
+
+            state->insertAttribute.use()
+                (key.first)
+                (symbols[key.second])
+                (AttrType::Failed)
+                (0, false).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
+    std::optional<std::pair<AttrId, AttrValue>> getAttr(AttrKey key)
+    {
+        auto state(_state->lock());
+
+        auto queryAttribute(state->queryAttribute.use()(key.first)(symbols[key.second]));
+        if (!queryAttribute.next()) return {};
+
+        auto rowId = (AttrId) queryAttribute.getInt(0);
+        auto type = (AttrType) queryAttribute.getInt(1);
+
+        switch (type) {
+            case AttrType::Placeholder:
+                return {{rowId, placeholder_t()}};
+            case AttrType::FullAttrs: {
+                // FIXME: expensive, should separate this out.
+                std::vector<Symbol> attrs;
+                auto queryAttributes(state->queryAttributes.use()(rowId));
+                while (queryAttributes.next())
+                    attrs.emplace_back(symbols.create(queryAttributes.getStr(0)));
+                return {{rowId, attrs}};
+            }
+            case AttrType::String: {
+                NixStringContext context;
+                if (!queryAttribute.isNull(3))
+                    for (auto & s : tokenizeString<std::vector<std::string>>(queryAttribute.getStr(3), ";"))
+                        context.insert(NixStringContextElem::parse(s));
+                return {{rowId, string_t{queryAttribute.getStr(2), context}}};
+            }
+            case AttrType::Bool:
+                return {{rowId, queryAttribute.getInt(2) != 0}};
+            case AttrType::Int:
+                return {{rowId, int_t{NixInt{queryAttribute.getInt(2)}}}};
+            case AttrType::ListOfStrings:
+                return {{rowId, tokenizeString<std::vector<std::string>>(queryAttribute.getStr(2), "\t")}};
+            case AttrType::Missing:
+                return {{rowId, missing_t()}};
+            case AttrType::Misc:
+                return {{rowId, misc_t()}};
+            case AttrType::Failed:
+                return {{rowId, failed_t()}};
+            default:
+                throw Error("unexpected type in evaluation cache");
+        }
+    }
+};
+
+static std::shared_ptr<AttrDb> makeAttrDb(
+    const StoreDirConfig & cfg,
+    const Hash & fingerprint,
+    SymbolTable & symbols)
+{
+    try {
+        return std::make_shared<AttrDb>(cfg, fingerprint, symbols);
+    } catch (SQLiteError &) {
+        ignoreExceptionExceptInterrupt();
+        return nullptr;
+    }
+}
+
+EvalCache::EvalCache(
+    std::optional<std::reference_wrapper<const Hash>> useCache,
+    EvalState & state,
+    RootLoader rootLoader)
+    : db(useCache ? makeAttrDb(*state.store, *useCache, state.symbols) : nullptr)
+    , state(state)
+    , rootLoader(rootLoader)
+{
+}
+
+Value * EvalCache::getRootValue()
+{
+    if (!value) {
+        debug("getting root value");
+        value = allocRootValue(rootLoader());
+    }
+    return *value;
+}
+
+ref<AttrCursor> EvalCache::getRoot()
+{
+    return make_ref<AttrCursor>(ref(shared_from_this()), std::nullopt);
+}
+
+AttrCursor::AttrCursor(
+    ref<EvalCache> root,
+    Parent parent,
+    Value * value,
+    std::optional<std::pair<AttrId, AttrValue>> && cachedValue)
+    : root(root), parent(parent), cachedValue(std::move(cachedValue))
+{
+    if (value)
+        _value = allocRootValue(value);
+}
+
+AttrKey AttrCursor::getKey()
+{
+    if (!parent)
+        return {0, root->state.sEpsilon};
+    if (!parent->first->cachedValue) {
+        parent->first->cachedValue = root->db->getAttr(parent->first->getKey());
+        assert(parent->first->cachedValue);
+    }
+    return {parent->first->cachedValue->first, parent->second};
+}
+
+Value & AttrCursor::getValue()
+{
+    if (!_value) {
+        if (parent) {
+            auto & vParent = parent->first->getValue();
+            root->state.forceAttrs(vParent, noPos, "while searching for an attribute");
+            auto attr = vParent.attrs()->get(parent->second);
+            if (!attr)
+                throw Error("attribute '%s' is unexpectedly missing", getAttrPathStr());
+            _value = allocRootValue(attr->value);
+        } else
+            _value = allocRootValue(root->getRootValue());
+    }
+    return **_value;
+}
+
+std::vector<Symbol> AttrCursor::getAttrPath() const
+{
+    if (parent) {
+        auto attrPath = parent->first->getAttrPath();
+        attrPath.push_back(parent->second);
+        return attrPath;
+    } else
+        return {};
+}
+
+std::vector<Symbol> AttrCursor::getAttrPath(Symbol name) const
+{
+    auto attrPath = getAttrPath();
+    attrPath.push_back(name);
+    return attrPath;
+}
+
+std::string AttrCursor::getAttrPathStr() const
+{
+    return dropEmptyInitThenConcatStringsSep(".", root->state.symbols.resolve(getAttrPath()));
+}
+
+std::string AttrCursor::getAttrPathStr(Symbol name) const
+{
+    return dropEmptyInitThenConcatStringsSep(".", root->state.symbols.resolve(getAttrPath(name)));
+}
+
+Value & AttrCursor::forceValue()
+{
+    debug("evaluating uncached attribute '%s'", getAttrPathStr());
+
+    auto & v = getValue();
+
+    try {
+        root->state.forceValue(v, noPos);
+    } catch (EvalError &) {
+        debug("setting '%s' to failed", getAttrPathStr());
+        if (root->db)
+            cachedValue = {root->db->setFailed(getKey()), failed_t()};
+        throw;
+    }
+
+    if (root->db && (!cachedValue || std::get_if<placeholder_t>(&cachedValue->second))) {
+        if (v.type() == nString)
+            cachedValue = {root->db->setString(getKey(), v.c_str(), v.context()),
+                           string_t{v.c_str(), {}}};
+        else if (v.type() == nPath) {
+            auto path = v.path().path;
+            cachedValue = {root->db->setString(getKey(), path.abs()), string_t{path.abs(), {}}};
+        }
+        else if (v.type() == nBool)
+            cachedValue = {root->db->setBool(getKey(), v.boolean()), v.boolean()};
+        else if (v.type() == nInt)
+            cachedValue = {root->db->setInt(getKey(), v.integer().value), int_t{v.integer()}};
+        else if (v.type() == nAttrs)
+            ; // FIXME: do something?
+        else
+            cachedValue = {root->db->setMisc(getKey()), misc_t()};
+    }
+
+    return v;
+}
+
+Suggestions AttrCursor::getSuggestionsForAttr(Symbol name)
+{
+    auto attrNames = getAttrs();
+    std::set<std::string> strAttrNames;
+    for (auto & name : attrNames)
+        strAttrNames.insert(std::string(root->state.symbols[name]));
+
+    return Suggestions::bestMatches(strAttrNames, root->state.symbols[name]);
+}
+
+std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name)
+{
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = root->db->getAttr(getKey());
+
+        if (cachedValue) {
+            if (auto attrs = std::get_if<std::vector<Symbol>>(&cachedValue->second)) {
+                for (auto & attr : *attrs)
+                    if (attr == name)
+                        return std::make_shared<AttrCursor>(root, std::make_pair(shared_from_this(), attr));
+                return nullptr;
+            } else if (std::get_if<placeholder_t>(&cachedValue->second)) {
+                auto attr = root->db->getAttr({cachedValue->first, name});
+                if (attr) {
+                    if (std::get_if<missing_t>(&attr->second))
+                        return nullptr;
+                    else if (std::get_if<failed_t>(&attr->second))
+                        throw CachedEvalError(ref(shared_from_this()), name);
+                    else
+                        return std::make_shared<AttrCursor>(root,
+                            std::make_pair(shared_from_this(), name), nullptr, std::move(attr));
+                }
+                // Incomplete attrset, so need to fall thru and
+                // evaluate to see whether 'name' exists
+            } else
+                return nullptr;
+                //error<TypeError>("'%s' is not an attribute set", getAttrPathStr()).debugThrow();
+        }
+    }
+
+    auto & v = forceValue();
+
+    if (v.type() != nAttrs)
+        return nullptr;
+        //error<TypeError>("'%s' is not an attribute set", getAttrPathStr()).debugThrow();
+
+    auto attr = v.attrs()->get(name);
+
+    if (!attr) {
+        if (root->db) {
+            if (!cachedValue)
+                cachedValue = {root->db->setPlaceholder(getKey()), placeholder_t()};
+            root->db->setMissing({cachedValue->first, name});
+        }
+        return nullptr;
+    }
+
+    std::optional<std::pair<AttrId, AttrValue>> cachedValue2;
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = {root->db->setPlaceholder(getKey()), placeholder_t()};
+        cachedValue2 = {root->db->setPlaceholder({cachedValue->first, name}), placeholder_t()};
+    }
+
+    return make_ref<AttrCursor>(
+        root, std::make_pair(shared_from_this(), name), attr->value, std::move(cachedValue2));
+}
+
+std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(std::string_view name)
+{
+    return maybeGetAttr(root->state.symbols.create(name));
+}
+
+ref<AttrCursor> AttrCursor::getAttr(Symbol name)
+{
+    auto p = maybeGetAttr(name);
+    if (!p)
+        throw Error("attribute '%s' does not exist", getAttrPathStr(name));
+    return ref(p);
+}
+
+ref<AttrCursor> AttrCursor::getAttr(std::string_view name)
+{
+    return getAttr(root->state.symbols.create(name));
+}
+
+OrSuggestions<ref<AttrCursor>> AttrCursor::findAlongAttrPath(const std::vector<Symbol> & attrPath)
+{
+    auto res = shared_from_this();
+    for (auto & attr : attrPath) {
+        auto child = res->maybeGetAttr(attr);
+        if (!child) {
+            auto suggestions = res->getSuggestionsForAttr(attr);
+            return OrSuggestions<ref<AttrCursor>>::failed(suggestions);
+        }
+        res = child;
+    }
+    return ref(res);
+}
+
+std::string AttrCursor::getString()
+{
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = root->db->getAttr(getKey());
+        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
+            if (auto s = std::get_if<string_t>(&cachedValue->second)) {
+                debug("using cached string attribute '%s'", getAttrPathStr());
+                return s->first;
+            } else
+                root->state.error<TypeError>("'%s' is not a string", getAttrPathStr()).debugThrow();
+        }
+    }
+
+    auto & v = forceValue();
+
+    if (v.type() != nString && v.type() != nPath)
+        root->state.error<TypeError>("'%s' is not a string but %s", getAttrPathStr(), showType(v)).debugThrow();
+
+    return v.type() == nString ? v.c_str() : v.path().to_string();
+}
+
+string_t AttrCursor::getStringWithContext()
+{
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = root->db->getAttr(getKey());
+        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
+            if (auto s = std::get_if<string_t>(&cachedValue->second)) {
+                bool valid = true;
+                for (auto & c : s->second) {
+                    const StorePath & path = std::visit(overloaded {
+                        [&](const NixStringContextElem::DrvDeep & d) -> const StorePath & {
+                            return d.drvPath;
+                        },
+                        [&](const NixStringContextElem::Built & b) -> const StorePath & {
+                            return b.drvPath->getBaseStorePath();
+                        },
+                        [&](const NixStringContextElem::Opaque & o) -> const StorePath & {
+                            return o.path;
+                        },
+                    }, c.raw);
+                    if (!root->state.store->isValidPath(path)) {
+                        valid = false;
+                        break;
+                    }
+                }
+                if (valid) {
+                    debug("using cached string attribute '%s'", getAttrPathStr());
+                    return *s;
+                }
+            } else
+                root->state.error<TypeError>("'%s' is not a string", getAttrPathStr()).debugThrow();
+        }
+    }
+
+    auto & v = forceValue();
+
+    if (v.type() == nString) {
+        NixStringContext context;
+        copyContext(v, context);
+        return {v.c_str(), std::move(context)};
+    }
+    else if (v.type() == nPath)
+        return {v.path().to_string(), {}};
+    else
+        root->state.error<TypeError>("'%s' is not a string but %s", getAttrPathStr(), showType(v)).debugThrow();
+}
+
+bool AttrCursor::getBool()
+{
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = root->db->getAttr(getKey());
+        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
+            if (auto b = std::get_if<bool>(&cachedValue->second)) {
+                debug("using cached Boolean attribute '%s'", getAttrPathStr());
+                return *b;
+            } else
+                root->state.error<TypeError>("'%s' is not a Boolean", getAttrPathStr()).debugThrow();
+        }
+    }
+
+    auto & v = forceValue();
+
+    if (v.type() != nBool)
+        root->state.error<TypeError>("'%s' is not a Boolean", getAttrPathStr()).debugThrow();
+
+    return v.boolean();
+}
+
+NixInt AttrCursor::getInt()
+{
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = root->db->getAttr(getKey());
+        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
+            if (auto i = std::get_if<int_t>(&cachedValue->second)) {
+                debug("using cached integer attribute '%s'", getAttrPathStr());
+                return i->x;
+            } else
+                root->state.error<TypeError>("'%s' is not an integer", getAttrPathStr()).debugThrow();
+        }
+    }
+
+    auto & v = forceValue();
+
+    if (v.type() != nInt)
+        root->state.error<TypeError>("'%s' is not an integer", getAttrPathStr()).debugThrow();
+
+    return v.integer();
+}
+
+std::vector<std::string> AttrCursor::getListOfStrings()
+{
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = root->db->getAttr(getKey());
+        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
+            if (auto l = std::get_if<std::vector<std::string>>(&cachedValue->second)) {
+                debug("using cached list of strings attribute '%s'", getAttrPathStr());
+                return *l;
+            } else
+                root->state.error<TypeError>("'%s' is not a list of strings", getAttrPathStr()).debugThrow();
+        }
+    }
+
+    debug("evaluating uncached attribute '%s'", getAttrPathStr());
+
+    auto & v = getValue();
+    root->state.forceValue(v, noPos);
+
+    if (v.type() != nList)
+        root->state.error<TypeError>("'%s' is not a list", getAttrPathStr()).debugThrow();
+
+    std::vector<std::string> res;
+
+    for (auto & elem : v.listItems())
+        res.push_back(std::string(root->state.forceStringNoCtx(*elem, noPos, "while evaluating an attribute for caching")));
+
+    if (root->db)
+        cachedValue = {root->db->setListOfStrings(getKey(), res), res};
+
+    return res;
+}
+
+std::vector<Symbol> AttrCursor::getAttrs()
+{
+    if (root->db) {
+        if (!cachedValue)
+            cachedValue = root->db->getAttr(getKey());
+        if (cachedValue && !std::get_if<placeholder_t>(&cachedValue->second)) {
+            if (auto attrs = std::get_if<std::vector<Symbol>>(&cachedValue->second)) {
+                debug("using cached attrset attribute '%s'", getAttrPathStr());
+                return *attrs;
+            } else
+                root->state.error<TypeError>("'%s' is not an attribute set", getAttrPathStr()).debugThrow();
+        }
+    }
+
+    auto & v = forceValue();
+
+    if (v.type() != nAttrs)
+        root->state.error<TypeError>("'%s' is not an attribute set", getAttrPathStr()).debugThrow();
+
+    std::vector<Symbol> attrs;
+    for (auto & attr : *getValue().attrs())
+        attrs.push_back(attr.name);
+    std::sort(attrs.begin(), attrs.end(), [&](Symbol a, Symbol b) {
+        std::string_view sa = root->state.symbols[a], sb = root->state.symbols[b];
+        return sa < sb;
+    });
+
+    if (root->db)
+        cachedValue = {root->db->setAttrs(getKey(), attrs), attrs};
+
+    return attrs;
+}
+
+bool AttrCursor::isDerivation()
+{
+    auto aType = maybeGetAttr("type");
+    return aType && aType->getString() == "derivation";
+}
+
+StorePath AttrCursor::forceDerivation()
+{
+    auto aDrvPath = getAttr(root->state.sDrvPath);
+    auto drvPath = root->state.store->parseStorePath(aDrvPath->getString());
+    drvPath.requireDerivation();
+    if (!root->state.store->isValidPath(drvPath) && !settings.readOnlyMode) {
+        /* The eval cache contains 'drvPath', but the actual path has
+           been garbage-collected. So force it to be regenerated. */
+        aDrvPath->forceValue();
+        if (!root->state.store->isValidPath(drvPath))
+            throw Error("don't know how to recreate store derivation '%s'!",
+                root->state.store->printStorePath(drvPath));
+    }
+    return drvPath;
+}
+
+}

subprojects/libexpr/eval-cache.hh

@@ -0,0 +1,156 @@
+#pragma once
+///@file
+
+#include "sync.hh"
+#include "hash.hh"
+#include "eval.hh"
+
+#include <functional>
+#include <variant>
+
+namespace nix::eval_cache {
+
+struct AttrDb;
+class AttrCursor;
+
+struct CachedEvalError : EvalError
+{
+    const ref<AttrCursor> cursor;
+    const Symbol attr;
+
+    CachedEvalError(ref<AttrCursor> cursor, Symbol attr);
+
+    /**
+     * Evaluate this attribute, which should result in a regular
+     * `EvalError` exception being thrown.
+     */
+    [[noreturn]]
+    void force();
+};
+
+class EvalCache : public std::enable_shared_from_this<EvalCache>
+{
+    friend class AttrCursor;
+    friend struct CachedEvalError;
+
+    std::shared_ptr<AttrDb> db;
+    EvalState & state;
+    typedef std::function<Value *()> RootLoader;
+    RootLoader rootLoader;
+    RootValue value;
+
+    Value * getRootValue();
+
+public:
+
+    EvalCache(
+        std::optional<std::reference_wrapper<const Hash>> useCache,
+        EvalState & state,
+        RootLoader rootLoader);
+
+    ref<AttrCursor> getRoot();
+};
+
+enum AttrType {
+    Placeholder = 0,
+    FullAttrs = 1,
+    String = 2,
+    Missing = 3,
+    Misc = 4,
+    Failed = 5,
+    Bool = 6,
+    ListOfStrings = 7,
+    Int = 8,
+};
+
+struct placeholder_t {};
+struct missing_t {};
+struct misc_t {};
+struct failed_t {};
+struct int_t { NixInt x; };
+typedef uint64_t AttrId;
+typedef std::pair<AttrId, Symbol> AttrKey;
+typedef std::pair<std::string, NixStringContext> string_t;
+
+typedef std::variant<
+    std::vector<Symbol>,
+    string_t,
+    placeholder_t,
+    missing_t,
+    misc_t,
+    failed_t,
+    bool,
+    int_t,
+    std::vector<std::string>
+    > AttrValue;
+
+class AttrCursor : public std::enable_shared_from_this<AttrCursor>
+{
+    friend class EvalCache;
+    friend struct CachedEvalError;
+
+    ref<EvalCache> root;
+    typedef std::optional<std::pair<std::shared_ptr<AttrCursor>, Symbol>> Parent;
+    Parent parent;
+    RootValue _value;
+    std::optional<std::pair<AttrId, AttrValue>> cachedValue;
+
+    AttrKey getKey();
+
+    Value & getValue();
+
+public:
+
+    AttrCursor(
+        ref<EvalCache> root,
+        Parent parent,
+        Value * value = nullptr,
+        std::optional<std::pair<AttrId, AttrValue>> && cachedValue = {});
+
+    std::vector<Symbol> getAttrPath() const;
+
+    std::vector<Symbol> getAttrPath(Symbol name) const;
+
+    std::string getAttrPathStr() const;
+
+    std::string getAttrPathStr(Symbol name) const;
+
+    Suggestions getSuggestionsForAttr(Symbol name);
+
+    std::shared_ptr<AttrCursor> maybeGetAttr(Symbol name);
+
+    std::shared_ptr<AttrCursor> maybeGetAttr(std::string_view name);
+
+    ref<AttrCursor> getAttr(Symbol name);
+
+    ref<AttrCursor> getAttr(std::string_view name);
+
+    /**
+     * Get an attribute along a chain of attrsets. Note that this does
+     * not auto-call functors or functions.
+     */
+    OrSuggestions<ref<AttrCursor>> findAlongAttrPath(const std::vector<Symbol> & attrPath);
+
+    std::string getString();
+
+    string_t getStringWithContext();
+
+    bool getBool();
+
+    NixInt getInt();
+
+    std::vector<std::string> getListOfStrings();
+
+    std::vector<Symbol> getAttrs();
+
+    bool isDerivation();
+
+    Value & forceValue();
+
+    /**
+     * Force creation of the .drv file in the Nix store.
+     */
+    StorePath forceDerivation();
+};
+
+}

subprojects/libexpr/eval-error.cc

@@ -0,0 +1,114 @@
+#include "eval-error.hh"
+#include "eval.hh"
+#include "value.hh"
+
+namespace nix {
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::withExitStatus(unsigned int exitStatus)
+{
+    error.withExitStatus(exitStatus);
+    return *this;
+}
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::atPos(PosIdx pos)
+{
+    error.err.pos = error.state.positions[pos];
+    return *this;
+}
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::atPos(Value & value, PosIdx fallback)
+{
+    return atPos(value.determinePos(fallback));
+}
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::withTrace(PosIdx pos, const std::string_view text)
+{
+    error.addTrace(error.state.positions[pos], text);
+    return *this;
+}
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::withSuggestions(Suggestions & s)
+{
+    error.err.suggestions = s;
+    return *this;
+}
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::withFrame(const Env & env, const Expr & expr)
+{
+    // NOTE: This is abusing side-effects.
+    // TODO: check compatibility with nested debugger calls.
+    // TODO: What side-effects??
+    error.state.debugTraces.push_front(DebugTrace{
+        .pos = error.state.positions[expr.getPos()],
+        .expr = expr,
+        .env = env,
+        .hint = HintFmt("Fake frame for debugging purposes"),
+        .isError = true});
+    return *this;
+}
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::addTrace(PosIdx pos, HintFmt hint)
+{
+    error.addTrace(error.state.positions[pos], hint);
+    return *this;
+}
+
+template<class T>
+template<typename... Args>
+EvalErrorBuilder<T> &
+EvalErrorBuilder<T>::addTrace(PosIdx pos, std::string_view formatString, const Args &... formatArgs)
+{
+
+    addTrace(error.state.positions[pos], HintFmt(std::string(formatString), formatArgs...));
+    return *this;
+}
+
+template<class T>
+EvalErrorBuilder<T> & EvalErrorBuilder<T>::setIsFromExpr()
+{
+    error.err.isFromExpr = true;
+    return *this;
+}
+
+template<class T>
+void EvalErrorBuilder<T>::debugThrow()
+{
+    error.state.runDebugRepl(&error);
+
+    // `EvalState` is the only class that can construct an `EvalErrorBuilder`,
+    // and it does so in dynamic storage. This is the final method called on
+    // any such instance and must delete itself before throwing the underlying
+    // error.
+    auto error = std::move(this->error);
+    delete this;
+
+    throw error;
+}
+
+template<class T>
+void EvalErrorBuilder<T>::panic()
+{
+    logError(error.info());
+    printError("This is a bug! An unexpected condition occurred, causing the Nix evaluator to have to stop. If you could share a reproducible example or a core dump, please open an issue at https://github.com/NixOS/nix/issues");
+    abort();
+}
+
+template class EvalErrorBuilder<EvalBaseError>;
+template class EvalErrorBuilder<EvalError>;
+template class EvalErrorBuilder<AssertionError>;
+template class EvalErrorBuilder<ThrownError>;
+template class EvalErrorBuilder<Abort>;
+template class EvalErrorBuilder<TypeError>;
+template class EvalErrorBuilder<UndefinedVarError>;
+template class EvalErrorBuilder<MissingArgumentError>;
+template class EvalErrorBuilder<InfiniteRecursionError>;
+template class EvalErrorBuilder<InvalidPathError>;
+
+}

subprojects/libexpr/eval-error.hh

@@ -0,0 +1,121 @@
+#pragma once
+
+#include "error.hh"
+#include "pos-idx.hh"
+
+namespace nix {
+
+struct Env;
+struct Expr;
+struct Value;
+
+class EvalState;
+template<class T>
+class EvalErrorBuilder;
+
+/**
+ * Base class for all errors that occur during evaluation.
+ *
+ * Most subclasses should inherit from `EvalError` instead of this class.
+ */
+class EvalBaseError : public Error
+{
+    template<class T>
+    friend class EvalErrorBuilder;
+public:
+    EvalState & state;
+
+    EvalBaseError(EvalState & state, ErrorInfo && errorInfo)
+        : Error(errorInfo)
+        , state(state)
+    {
+    }
+
+    template<typename... Args>
+    explicit EvalBaseError(EvalState & state, const std::string & formatString, const Args &... formatArgs)
+        : Error(formatString, formatArgs...)
+        , state(state)
+    {
+    }
+};
+
+/**
+ * `EvalError` is the base class for almost all errors that occur during evaluation.
+ *
+ * All instances of `EvalError` should show a degree of purity that allows them to be
+ * cached in pure mode. This means that they should not depend on the configuration or the overall environment.
+ */
+MakeError(EvalError, EvalBaseError);
+MakeError(ParseError, Error);
+MakeError(AssertionError, EvalError);
+MakeError(ThrownError, AssertionError);
+MakeError(Abort, EvalError);
+MakeError(TypeError, EvalError);
+MakeError(UndefinedVarError, EvalError);
+MakeError(MissingArgumentError, EvalError);
+MakeError(InfiniteRecursionError, EvalError);
+
+struct InvalidPathError : public EvalError
+{
+public:
+    Path path;
+    InvalidPathError(EvalState & state, const Path & path)
+        : EvalError(state, "path '%s' is not valid", path)
+    {
+    }
+};
+
+/**
+ * `EvalErrorBuilder`s may only be constructed by `EvalState`. The `debugThrow`
+ * method must be the final method in any such `EvalErrorBuilder` usage, and it
+ * handles deleting the object.
+ */
+template<class T>
+class EvalErrorBuilder final
+{
+    friend class EvalState;
+
+    template<typename... Args>
+    explicit EvalErrorBuilder(EvalState & state, const Args &... args)
+        : error(T(state, args...))
+    {
+    }
+
+public:
+    T error;
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & withExitStatus(unsigned int exitStatus);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & atPos(PosIdx pos);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & atPos(Value & value, PosIdx fallback = noPos);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & withTrace(PosIdx pos, const std::string_view text);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & withFrameTrace(PosIdx pos, const std::string_view text);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & withSuggestions(Suggestions & s);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & withFrame(const Env & e, const Expr & ex);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & addTrace(PosIdx pos, HintFmt hint);
+
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> & setIsFromExpr();
+
+    template<typename... Args>
+    [[nodiscard, gnu::noinline]] EvalErrorBuilder<T> &
+    addTrace(PosIdx pos, std::string_view formatString, const Args &... formatArgs);
+
+    /**
+     * Delete the `EvalErrorBuilder` and throw the underlying exception.
+     */
+    [[gnu::noinline, gnu::noreturn]] void debugThrow();
+
+    /**
+     * A programming error or fatal condition occurred. Abort the process for core dump and debugging.
+     * This does not print a proper backtrace, because unwinding the stack is destructive.
+     */
+    [[gnu::noinline, gnu::noreturn]] void panic();
+};
+
+}

subprojects/libexpr/eval-gc.cc

@@ -0,0 +1,117 @@
+#include "error.hh"
+#include "environment-variables.hh"
+#include "eval-settings.hh"
+#include "config-global.hh"
+#include "serialise.hh"
+#include "eval-gc.hh"
+
+#if HAVE_BOEHMGC
+
+#  include <pthread.h>
+#  if __FreeBSD__
+#    include <pthread_np.h>
+#  endif
+
+#  include <gc/gc.h>
+#  include <gc/gc_cpp.h>
+#  include <gc/gc_allocator.h>
+
+#  include <boost/coroutine2/coroutine.hpp>
+#  include <boost/coroutine2/protected_fixedsize_stack.hpp>
+#  include <boost/context/stack_context.hpp>
+
+#endif
+
+namespace nix {
+
+#if HAVE_BOEHMGC
+/* Called when the Boehm GC runs out of memory. */
+static void * oomHandler(size_t requested)
+{
+    /* Convert this to a proper C++ exception. */
+    throw std::bad_alloc();
+}
+
+static inline void initGCReal()
+{
+    /* Initialise the Boehm garbage collector. */
+
+    /* Don't look for interior pointers. This reduces the odds of
+       misdetection a bit. */
+    GC_set_all_interior_pointers(0);
+
+    /* We don't have any roots in data segments, so don't scan from
+       there. */
+    GC_set_no_dls(1);
+
+    /* Enable perf measurements. This is just a setting; not much of a
+       start of something. */
+    GC_start_performance_measurement();
+
+    GC_INIT();
+
+    GC_set_oom_fn(oomHandler);
+
+    /* Set the initial heap size to something fairly big (25% of
+       physical RAM, up to a maximum of 384 MiB) so that in most cases
+       we don't need to garbage collect at all.  (Collection has a
+       fairly significant overhead.)  The heap size can be overridden
+       through libgc's GC_INITIAL_HEAP_SIZE environment variable.  We
+       should probably also provide a nix.conf setting for this.  Note
+       that GC_expand_hp() causes a lot of virtual, but not physical
+       (resident) memory to be allocated.  This might be a problem on
+       systems that don't overcommit. */
+    if (!getEnv("GC_INITIAL_HEAP_SIZE")) {
+        size_t size = 32 * 1024 * 1024;
+#  if HAVE_SYSCONF && defined(_SC_PAGESIZE) && defined(_SC_PHYS_PAGES)
+        size_t maxSize = 384 * 1024 * 1024;
+        long pageSize = sysconf(_SC_PAGESIZE);
+        long pages = sysconf(_SC_PHYS_PAGES);
+        if (pageSize != -1)
+            size = (pageSize * pages) / 4; // 25% of RAM
+        if (size > maxSize)
+            size = maxSize;
+#  endif
+        debug("setting initial heap size to %1% bytes", size);
+        GC_expand_hp(size);
+    }
+}
+
+static size_t gcCyclesAfterInit = 0;
+
+size_t getGCCycles()
+{
+    assertGCInitialized();
+    return static_cast<size_t>(GC_get_gc_no()) - gcCyclesAfterInit;
+}
+
+#endif
+
+static bool gcInitialised = false;
+
+void initGC()
+{
+    if (gcInitialised)
+        return;
+
+#if HAVE_BOEHMGC
+    initGCReal();
+
+    gcCyclesAfterInit = GC_get_gc_no();
+#endif
+
+    // NIX_PATH must override the regular setting
+    // See the comment in applyConfig
+    if (auto nixPathEnv = getEnv("NIX_PATH")) {
+        globalConfig.set("nix-path", concatStringsSep(" ", EvalSettings::parseNixPath(nixPathEnv.value())));
+    }
+
+    gcInitialised = true;
+}
+
+void assertGCInitialized()
+{
+    assert(gcInitialised);
+}
+
+} // namespace nix

subprojects/libexpr/eval-gc.hh

@@ -0,0 +1,53 @@
+#pragma once
+///@file
+
+#include <cstddef>
+
+#if HAVE_BOEHMGC
+
+#  define GC_INCLUDE_NEW
+
+#  include <gc/gc.h>
+#  include <gc/gc_cpp.h>
+#  include <gc/gc_allocator.h>
+
+#else
+
+#  include <memory>
+
+/* Some dummy aliases for Boehm GC definitions to reduce the number of
+   #ifdefs. */
+
+template<typename T>
+using traceable_allocator = std::allocator<T>;
+
+template<typename T>
+using gc_allocator = std::allocator<T>;
+
+#  define GC_MALLOC_ATOMIC std::malloc
+
+struct gc
+{};
+
+#endif
+
+namespace nix {
+
+/**
+ * Initialise the Boehm GC, if applicable.
+ */
+void initGC();
+
+/**
+ * Make sure `initGC` has already been called.
+ */
+void assertGCInitialized();
+
+#ifdef HAVE_BOEHMGC
+/**
+ * The number of GC cycles since initGC().
+ */
+size_t getGCCycles();
+#endif
+
+} // namespace nix

subprojects/libexpr/eval-inline.hh

@@ -0,0 +1,150 @@
+#pragma once
+///@file
+
+#include "print.hh"
+#include "eval.hh"
+#include "eval-error.hh"
+#include "eval-settings.hh"
+
+namespace nix {
+
+/**
+ * Note: Various places expect the allocated memory to be zeroed.
+ */
+[[gnu::always_inline]]
+inline void * allocBytes(size_t n)
+{
+    void * p;
+#if HAVE_BOEHMGC
+    p = GC_MALLOC(n);
+#else
+    p = calloc(n, 1);
+#endif
+    if (!p) throw std::bad_alloc();
+    return p;
+}
+
+
+[[gnu::always_inline]]
+Value * EvalState::allocValue()
+{
+#if HAVE_BOEHMGC
+    /* We use the boehm batch allocator to speed up allocations of Values (of which there are many).
+       GC_malloc_many returns a linked list of objects of the given size, where the first word
+       of each object is also the pointer to the next object in the list. This also means that we
+       have to explicitly clear the first word of every object we take. */
+    if (!*valueAllocCache) {
+        *valueAllocCache = GC_malloc_many(sizeof(Value));
+        if (!*valueAllocCache) throw std::bad_alloc();
+    }
+
+    /* GC_NEXT is a convenience macro for accessing the first word of an object.
+       Take the first list item, advance the list to the next item, and clear the next pointer. */
+    void * p = *valueAllocCache;
+    *valueAllocCache = GC_NEXT(p);
+    GC_NEXT(p) = nullptr;
+#else
+    void * p = allocBytes(sizeof(Value));
+#endif
+
+    nrValues++;
+    return (Value *) p;
+}
+
+
+[[gnu::always_inline]]
+Env & EvalState::allocEnv(size_t size)
+{
+    nrEnvs++;
+    nrValuesInEnvs += size;
+
+    Env * env;
+
+#if HAVE_BOEHMGC
+    if (size == 1) {
+        /* see allocValue for explanations. */
+        if (!*env1AllocCache) {
+            *env1AllocCache = GC_malloc_many(sizeof(Env) + sizeof(Value *));
+            if (!*env1AllocCache) throw std::bad_alloc();
+        }
+
+        void * p = *env1AllocCache;
+        *env1AllocCache = GC_NEXT(p);
+        GC_NEXT(p) = nullptr;
+        env = (Env *) p;
+    } else
+#endif
+        env = (Env *) allocBytes(sizeof(Env) + size * sizeof(Value *));
+
+    /* We assume that env->values has been cleared by the allocator; maybeThunk() and lookupVar fromWith expect this. */
+
+    return *env;
+}
+
+
+[[gnu::always_inline]]
+void EvalState::forceValue(Value & v, const PosIdx pos)
+{
+    if (v.isThunk()) {
+        Env * env = v.payload.thunk.env;
+        Expr * expr = v.payload.thunk.expr;
+        try {
+            v.mkBlackhole();
+            //checkInterrupt();
+            expr->eval(*this, *env, v);
+        } catch (...) {
+            v.mkThunk(env, expr);
+            tryFixupBlackHolePos(v, pos);
+            throw;
+        }
+    }
+    else if (v.isApp())
+        callFunction(*v.payload.app.left, *v.payload.app.right, v, pos);
+}
+
+
+[[gnu::always_inline]]
+inline void EvalState::forceAttrs(Value & v, const PosIdx pos, std::string_view errorCtx)
+{
+    forceAttrs(v, [&]() { return pos; }, errorCtx);
+}
+
+
+template <typename Callable>
+[[gnu::always_inline]]
+inline void EvalState::forceAttrs(Value & v, Callable getPos, std::string_view errorCtx)
+{
+    PosIdx pos = getPos();
+    forceValue(v, pos);
+    if (v.type() != nAttrs) {
+        error<TypeError>(
+            "expected a set but found %1%: %2%",
+            showType(v),
+            ValuePrinter(*this, v, errorPrintOptions)
+        ).withTrace(pos, errorCtx).debugThrow();
+    }
+}
+
+
+[[gnu::always_inline]]
+inline void EvalState::forceList(Value & v, const PosIdx pos, std::string_view errorCtx)
+{
+    forceValue(v, pos);
+    if (!v.isList()) {
+        error<TypeError>(
+            "expected a list but found %1%: %2%",
+            showType(v),
+            ValuePrinter(*this, v, errorPrintOptions)
+        ).withTrace(pos, errorCtx).debugThrow();
+    }
+}
+
+[[gnu::always_inline]]
+inline CallDepth EvalState::addCallDepth(const PosIdx pos) {
+    if (callDepth > settings.maxCallDepth)
+        error<EvalError>("stack overflow; max-call-depth exceeded").atPos(pos).debugThrow();
+
+    return CallDepth(callDepth);
+};
+
+}

subprojects/libexpr/eval-settings.cc

@@ -0,0 +1,106 @@
+#include "users.hh"
+#include "globals.hh"
+#include "profiles.hh"
+#include "eval.hh"
+#include "eval-settings.hh"
+
+namespace nix {
+
+/* Very hacky way to parse $NIX_PATH, which is colon-separated, but
+   can contain URLs (e.g. "nixpkgs=https://bla...:foo=https://"). */
+Strings EvalSettings::parseNixPath(const std::string & s)
+{
+    Strings res;
+
+    auto p = s.begin();
+
+    while (p != s.end()) {
+        auto start = p;
+        auto start2 = p;
+
+        while (p != s.end() && *p != ':') {
+            if (*p == '=') start2 = p + 1;
+            ++p;
+        }
+
+        if (p == s.end()) {
+            if (p != start) res.push_back(std::string(start, p));
+            break;
+        }
+
+        if (*p == ':') {
+            auto prefix = std::string(start2, s.end());
+            if (EvalSettings::isPseudoUrl(prefix) || hasPrefix(prefix, "flake:")) {
+                ++p;
+                while (p != s.end() && *p != ':') ++p;
+            }
+            res.push_back(std::string(start, p));
+            if (p == s.end()) break;
+        }
+
+        ++p;
+    }
+
+    return res;
+}
+
+EvalSettings::EvalSettings(bool & readOnlyMode, EvalSettings::LookupPathHooks lookupPathHooks)
+    : readOnlyMode{readOnlyMode}
+    , lookupPathHooks{lookupPathHooks}
+{
+    auto var = getEnv("NIX_ABORT_ON_WARN");
+    if (var && (var == "1" || var == "yes" || var == "true"))
+        builtinsAbortOnWarn = true;
+}
+
+Strings EvalSettings::getDefaultNixPath()
+{
+    Strings res;
+    auto add = [&](const Path & p, const std::string & s = std::string()) {
+        if (pathAccessible(p)) {
+            if (s.empty()) {
+                res.push_back(p);
+            } else {
+                res.push_back(s + "=" + p);
+            }
+        }
+    };
+
+    add(getNixDefExpr() + "/channels");
+    add(rootChannelsDir() + "/nixpkgs", "nixpkgs");
+    add(rootChannelsDir());
+
+    return res;
+}
+
+bool EvalSettings::isPseudoUrl(std::string_view s)
+{
+    if (s.compare(0, 8, "channel:") == 0) return true;
+    size_t pos = s.find("://");
+    if (pos == std::string::npos) return false;
+    std::string scheme(s, 0, pos);
+    return scheme == "http" || scheme == "https" || scheme == "file" || scheme == "channel" || scheme == "git" || scheme == "s3" || scheme == "ssh";
+}
+
+std::string EvalSettings::resolvePseudoUrl(std::string_view url)
+{
+    if (hasPrefix(url, "channel:"))
+        return "https://nixos.org/channels/" + std::string(url.substr(8)) + "/nixexprs.tar.xz";
+    else
+        return std::string(url);
+}
+
+const std::string & EvalSettings::getCurrentSystem() const
+{
+    const auto & evalSystem = currentSystem.get();
+    return evalSystem != "" ? evalSystem : settings.thisSystem.get();
+}
+
+Path getNixDefExpr()
+{
+    return settings.useXDGBaseDirectories
+        ? getStateDir() + "/defexpr"
+        : getHome() + "/.nix-defexpr";
+}
+
+}

subprojects/libexpr/eval-settings.hh

@@ -0,0 +1,257 @@
+#pragma once
+///@file
+
+#include "config.hh"
+#include "ref.hh"
+
+namespace nix {
+
+class Store;
+
+struct EvalSettings : Config
+{
+    /**
+     * Function used to interpet look path entries of a given scheme.
+     *
+     * The argument is the non-scheme part of the lookup path entry (see
+     * `LookupPathHooks` below).
+     *
+     * The return value is (a) whether the entry was valid, and, if so,
+     * what does it map to.
+     *
+     * @todo Return (`std::optional` of) `SourceAccssor` or something
+     * more structured instead of mere `std::string`?
+     */
+    using LookupPathHook = std::optional<std::string>(ref<Store> store, std::string_view);
+
+    /**
+     * Map from "scheme" to a `LookupPathHook`.
+     *
+     * Given a lookup path value (i.e. either the whole thing, or after
+     * the `<key>=`) in the form of:
+     *
+     * ```
+     * <scheme>:<arbitrary string>
+     * ```
+     *
+     * if `<scheme>` is a key in this map, then `<arbitrary string>` is
+     * passed to the hook that is the value in this map.
+     */
+    using LookupPathHooks = std::map<std::string, std::function<LookupPathHook>>;
+
+    EvalSettings(bool & readOnlyMode, LookupPathHooks lookupPathHooks = {});
+
+    bool & readOnlyMode;
+
+    static Strings getDefaultNixPath();
+
+    static bool isPseudoUrl(std::string_view s);
+
+    static Strings parseNixPath(const std::string & s);
+
+    static std::string resolvePseudoUrl(std::string_view url);
+
+    LookupPathHooks lookupPathHooks;
+
+    Setting<bool> enableNativeCode{this, false, "allow-unsafe-native-code-during-evaluation", R"(
+        Enable built-in functions that allow executing native code.
+
+        In particular, this adds:
+        - `builtins.importNative` *path* *symbol*
+
+          Opens dynamic shared object (DSO) at *path*, loads the function with the symbol name *symbol* from it and runs it.
+          The loaded function must have the following signature:
+          ```cpp
+          extern "C" typedef void (*ValueInitialiser) (EvalState & state, Value & v);
+          ```
+
+          The [Nix C++ API documentation](@docroot@/development/documentation.md#api-documentation) has more details on evaluator internals.
+
+        - `builtins.exec` *arguments*
+
+          Execute a program, where *arguments* are specified as a list of strings, and parse its output as a Nix expression.
+    )"};
+
+    Setting<Strings> nixPath{
+        this, {}, "nix-path",
+        R"(
+          List of search paths to use for [lookup path](@docroot@/language/constructs/lookup-path.md) resolution.
+          This setting determines the value of
+          [`builtins.nixPath`](@docroot@/language/builtins.md#builtins-nixPath) and can be used with [`builtins.findFile`](@docroot@/language/builtins.md#builtins-findFile).
+
+          - The configuration setting is overridden by the [`NIX_PATH`](@docroot@/command-ref/env-common.md#env-NIX_PATH)
+          environment variable.
+          - `NIX_PATH` is overridden by [specifying the setting as the command line flag](@docroot@/command-ref/conf-file.md#command-line-flags) `--nix-path`.
+          - Any current value is extended by the [`-I` option](@docroot@/command-ref/opt-common.md#opt-I) or `--extra-nix-path`.
+
+          If the respective paths are accessible, the default values are:
+
+          - `$HOME/.nix-defexpr/channels`
+
+            The [user channel link](@docroot@/command-ref/files/default-nix-expression.md#user-channel-link), pointing to the current state of [channels](@docroot@/command-ref/files/channels.md) for the current user.
+
+          - `nixpkgs=$NIX_STATE_DIR/profiles/per-user/root/channels/nixpkgs`
+
+            The current state of the `nixpkgs` channel for the `root` user.
+
+          - `$NIX_STATE_DIR/profiles/per-user/root/channels`
+
+            The current state of all channels for the `root` user.
+
+          These files are set up by the [Nix installer](@docroot@/installation/installing-binary.md).
+          See [`NIX_STATE_DIR`](@docroot@/command-ref/env-common.md#env-NIX_STATE_DIR) for details on the environment variable.
+
+          > **Note**
+          >
+          > If [restricted evaluation](@docroot@/command-ref/conf-file.md#conf-restrict-eval) is enabled, the default value is empty.
+          >
+          > If [pure evaluation](#conf-pure-eval) is enabled, `builtins.nixPath` *always* evaluates to the empty list `[ ]`.
+        )", {}, false};
+
+    Setting<std::string> currentSystem{
+        this, "", "eval-system",
+        R"(
+          This option defines
+          [`builtins.currentSystem`](@docroot@/language/builtins.md#builtins-currentSystem)
+          in the Nix language if it is set as a non-empty string.
+          Otherwise, if it is defined as the empty string (the default), the value of the
+          [`system` ](#conf-system)
+          configuration setting is used instead.
+
+          Unlike `system`, this setting does not change what kind of derivations can be built locally.
+          This is useful for evaluating Nix code on one system to produce derivations to be built on another type of system.
+        )"};
+
+    /**
+     * Implements the `eval-system` vs `system` defaulting logic
+     * described for `eval-system`.
+     */
+    const std::string & getCurrentSystem() const;
+
+    Setting<bool> restrictEval{
+        this, false, "restrict-eval",
+        R"(
+          If set to `true`, the Nix evaluator will not allow access to any
+          files outside of
+          [`builtins.nixPath`](@docroot@/language/builtins.md#builtins-nixPath),
+          or to URIs outside of
+          [`allowed-uris`](@docroot@/command-ref/conf-file.md#conf-allowed-uris).
+        )"};
+
+    Setting<bool> pureEval{this, false, "pure-eval",
+        R"(
+          Pure evaluation mode ensures that the result of Nix expressions is fully determined by explicitly declared inputs, and not influenced by external state:
+
+          - Restrict file system and network access to files specified by cryptographic hash
+          - Disable impure constants:
+            - [`builtins.currentSystem`](@docroot@/language/builtins.md#builtins-currentSystem)
+            - [`builtins.currentTime`](@docroot@/language/builtins.md#builtins-currentTime)
+            - [`builtins.nixPath`](@docroot@/language/builtins.md#builtins-nixPath)
+            - [`builtins.storePath`](@docroot@/language/builtins.md#builtins-storePath)
+        )"
+        };
+
+    Setting<bool> enableImportFromDerivation{
+        this, true, "allow-import-from-derivation",
+        R"(
+          By default, Nix allows [Import from Derivation](@docroot@/language/import-from-derivation.md).
+
+          With this option set to `false`, Nix will throw an error when evaluating an expression that uses this feature,
+          even when the required store object is readily available.
+          This ensures that evaluation will not require any builds to take place,
+          regardless of the state of the store.
+        )"};
+
+    Setting<Strings> allowedUris{this, {}, "allowed-uris",
+        R"(
+          A list of URI prefixes to which access is allowed in restricted
+          evaluation mode. For example, when set to
+          `https://github.com/NixOS`, builtin functions such as `fetchGit` are
+          allowed to access `https://github.com/NixOS/patchelf.git`.
+
+          Access is granted when
+          - the URI is equal to the prefix,
+          - or the URI is a subpath of the prefix,
+          - or the prefix is a URI scheme ended by a colon `:` and the URI has the same scheme.
+        )"};
+
+    Setting<bool> traceFunctionCalls{this, false, "trace-function-calls",
+        R"(
+          If set to `true`, the Nix evaluator will trace every function call.
+          Nix will print a log message at the "vomit" level for every function
+          entrance and function exit.
+
+              function-trace entered undefined position at 1565795816999559622
+              function-trace exited undefined position at 1565795816999581277
+              function-trace entered /nix/store/.../example.nix:226:41 at 1565795253249935150
+              function-trace exited /nix/store/.../example.nix:226:41 at 1565795253249941684
+
+          The `undefined position` means the function call is a builtin.
+
+          Use the `contrib/stack-collapse.py` script distributed with the Nix
+          source code to convert the trace logs in to a format suitable for
+          `flamegraph.pl`.
+        )"};
+
+    Setting<bool> useEvalCache{this, true, "eval-cache",
+        R"(
+            Whether to use the flake evaluation cache.
+            Certain commands won't have to evaluate when invoked for the second time with a particular version of a flake.
+            Intermediate results are not cached.
+        )"};
+
+    Setting<bool> ignoreExceptionsDuringTry{this, false, "ignore-try",
+        R"(
+          If set to true, ignore exceptions inside 'tryEval' calls when evaluating nix expressions in
+          debug mode (using the --debugger flag). By default the debugger will pause on all exceptions.
+        )"};
+
+    Setting<bool> traceVerbose{this, false, "trace-verbose",
+        "Whether `builtins.traceVerbose` should trace its first argument when evaluated."};
+
+    Setting<unsigned int> maxCallDepth{this, 10000, "max-call-depth",
+        "The maximum function call depth to allow before erroring."};
+
+    Setting<bool> builtinsTraceDebugger{this, false, "debugger-on-trace",
+        R"(
+          If set to true and the `--debugger` flag is given, the following functions
+          will enter the debugger like [`builtins.break`](@docroot@/language/builtins.md#builtins-break).
+
+          * [`builtins.trace`](@docroot@/language/builtins.md#builtins-trace)
+          * [`builtins.traceVerbose`](@docroot@/language/builtins.md#builtins-traceVerbose)
+            if [`trace-verbose`](#conf-trace-verbose) is set to true.
+          * [`builtins.warn`](@docroot@/language/builtins.md#builtins-warn)
+
+          This is useful for debugging warnings in third-party Nix code.
+        )"};
+
+    Setting<bool> builtinsDebuggerOnWarn{this, false, "debugger-on-warn",
+        R"(
+          If set to true and the `--debugger` flag is given, [`builtins.warn`](@docroot@/language/builtins.md#builtins-warn)
+          will enter the debugger like [`builtins.break`](@docroot@/language/builtins.md#builtins-break).
+
+          This is useful for debugging warnings in third-party Nix code.
+
+          Use [`debugger-on-trace`](#conf-debugger-on-trace) to also enter the debugger on legacy warnings that are logged with [`builtins.trace`](@docroot@/language/builtins.md#builtins-trace).
+        )"};
+
+    Setting<bool> builtinsAbortOnWarn{this, false, "abort-on-warn",
+        R"(
+          If set to true, [`builtins.warn`](@docroot@/language/builtins.md#builtins-warn) will throw an error when logging a warning.
+
+          This will give you a stack trace that leads to the location of the warning.
+
+          This is useful for finding information about warnings in third-party Nix code when you can not start the interactive debugger, such as when Nix is called from a non-interactive script. See [`debugger-on-warn`](#conf-debugger-on-warn).
+
+          Currently, a stack trace can only be produced when the debugger is enabled, or when evaluation is aborted.
+
+          This option can be enabled by setting `NIX_ABORT_ON_WARN=1` in the environment.
+        )"};
+};
+
+/**
+ * Conventionally part of the default nix path in impure mode.
+ */
+Path getNixDefExpr();
+
+}

subprojects/libexpr/eval.hh

@@ -0,0 +1,901 @@
+#pragma once
+///@file
+
+#include "attr-set.hh"
+#include "eval-error.hh"
+#include "types.hh"
+#include "value.hh"
+#include "nixexpr.hh"
+#include "symbol-table.hh"
+#include "config.hh"
+#include "experimental-features.hh"
+#include "position.hh"
+#include "pos-table.hh"
+#include "source-accessor.hh"
+#include "search-path.hh"
+#include "repl-exit-status.hh"
+#include "ref.hh"
+
+#include <map>
+#include <optional>
+#include <functional>
+
+namespace nix {
+
+/**
+ * We put a limit on primop arity because it lets us use a fixed size array on
+ * the stack. 8 is already an impractical number of arguments. Use an attrset
+ * argument for such overly complicated functions.
+ */
+constexpr size_t maxPrimOpArity = 8;
+
+class Store;
+namespace fetchers { struct Settings; }
+struct EvalSettings;
+class EvalState;
+class StorePath;
+struct SingleDerivedPath;
+enum RepairFlag : bool;
+struct MemorySourceAccessor;
+namespace eval_cache {
+    class EvalCache;
+}
+
+/**
+ * Increments a count on construction and decrements on destruction.
+ */
+class CallDepth {
+  size_t & count;
+
+public:
+  CallDepth(size_t & count) : count(count) {
+    ++count;
+  }
+  ~CallDepth() {
+    --count;
+  }
+};
+
+/**
+ * Function that implements a primop.
+ */
+using PrimOpFun = void(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+
+/**
+ * Info about a primitive operation, and its implementation
+ */
+struct PrimOp
+{
+    /**
+     * Name of the primop. `__` prefix is treated specially.
+     */
+    std::string name;
+
+    /**
+     * Names of the parameters of a primop, for primops that take a
+     * fixed number of arguments to be substituted for these parameters.
+     */
+    std::vector<std::string> args;
+
+    /**
+     * Aritiy of the primop.
+     *
+     * If `args` is not empty, this field will be computed from that
+     * field instead, so it doesn't need to be manually set.
+     */
+    size_t arity = 0;
+
+    /**
+     * Optional free-form documentation about the primop.
+     */
+    const char * doc = nullptr;
+
+    /**
+     * Add a trace item, `while calling the '<name>' builtin`
+     *
+     * This is used to remove the redundant item for `builtins.addErrorContext`.
+     */
+    bool addTrace = true;
+
+    /**
+     * Implementation of the primop.
+     */
+    std::function<PrimOpFun> fun;
+
+    /**
+     * Optional experimental for this to be gated on.
+     */
+    std::optional<ExperimentalFeature> experimentalFeature;
+
+    /**
+     * Validity check to be performed by functions that introduce primops,
+     * such as RegisterPrimOp() and Value::mkPrimOp().
+     */
+    void check();
+};
+
+std::ostream & operator<<(std::ostream & output, const PrimOp & primOp);
+
+/**
+ * Info about a constant
+ */
+struct Constant
+{
+    /**
+     * Optional type of the constant (known since it is a fixed value).
+     *
+     * @todo we should use an enum for this.
+     */
+    ValueType type = nThunk;
+
+    /**
+     * Optional free-form documentation about the constant.
+     */
+    const char * doc = nullptr;
+
+    /**
+     * Whether the constant is impure, and not available in pure mode.
+     */
+    bool impureOnly = false;
+};
+
+typedef std::map<std::string, Value *, std::less<std::string>, traceable_allocator<std::pair<const std::string, Value *> > > ValMap;
+
+typedef std::unordered_map<PosIdx, DocComment> DocCommentMap;
+
+struct Env
+{
+    Env * up;
+    Value * values[0];
+};
+
+void printEnvBindings(const EvalState &es, const Expr & expr, const Env & env);
+void printEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env, int lvl = 0);
+
+std::unique_ptr<ValMap> mapStaticEnvBindings(const SymbolTable & st, const StaticEnv & se, const Env & env);
+
+void copyContext(const Value & v, NixStringContext & context);
+
+
+std::string printValue(EvalState & state, Value & v);
+std::ostream & operator << (std::ostream & os, const ValueType t);
+
+
+struct RegexCache;
+
+std::shared_ptr<RegexCache> makeRegexCache();
+
+struct DebugTrace {
+    std::shared_ptr<Pos> pos;
+    const Expr & expr;
+    const Env & env;
+    HintFmt hint;
+    bool isError;
+};
+
+class EvalState : public std::enable_shared_from_this<EvalState>
+{
+public:
+    const fetchers::Settings & fetchSettings;
+    const EvalSettings & settings;
+    SymbolTable symbols;
+    PosTable positions;
+
+    const Symbol sWith, sOutPath, sDrvPath, sType, sMeta, sName, sValue,
+        sSystem, sOverrides, sOutputs, sOutputName, sIgnoreNulls,
+        sFile, sLine, sColumn, sFunctor, sToString,
+        sRight, sWrong, sStructuredAttrs,
+        sAllowedReferences, sAllowedRequisites, sDisallowedReferences, sDisallowedRequisites,
+        sMaxSize, sMaxClosureSize,
+        sBuilder, sArgs,
+        sContentAddressed, sImpure,
+        sOutputHash, sOutputHashAlgo, sOutputHashMode,
+        sRecurseForDerivations,
+        sDescription, sSelf, sEpsilon, sStartSet, sOperator, sKey, sPath,
+        sPrefix,
+        sOutputSpecified;
+
+    const Expr::AstSymbols exprSymbols;
+
+    /**
+     * If set, force copying files to the Nix store even if they
+     * already exist there.
+     */
+    RepairFlag repair;
+
+    Bindings emptyBindings;
+
+    /**
+     * Empty list constant.
+     */
+    Value vEmptyList;
+
+    /**
+     * `null` constant.
+     *
+     * This is _not_ a singleton. Pointer equality is _not_ sufficient.
+     */
+    Value vNull;
+
+    /**
+     * `true` constant.
+     *
+     * This is _not_ a singleton. Pointer equality is _not_ sufficient.
+     */
+    Value vTrue;
+
+    /**
+     * `true` constant.
+     *
+     * This is _not_ a singleton. Pointer equality is _not_ sufficient.
+     */
+    Value vFalse;
+
+    /** `"regular"` */
+    Value vStringRegular;
+    /** `"directory"` */
+    Value vStringDirectory;
+    /** `"symlink"` */
+    Value vStringSymlink;
+    /** `"unknown"` */
+    Value vStringUnknown;
+
+    /**
+     * The accessor for the root filesystem.
+     */
+    const ref<SourceAccessor> rootFS;
+
+    /**
+     * The in-memory filesystem for <nix/...> paths.
+     */
+    const ref<MemorySourceAccessor> corepkgsFS;
+
+    /**
+     * In-memory filesystem for internal, non-user-callable Nix
+     * expressions like call-flake.nix.
+     */
+    const ref<MemorySourceAccessor> internalFS;
+
+    const SourcePath derivationInternal;
+
+    const SourcePath callFlakeInternal;
+
+    /**
+     * Store used to materialise .drv files.
+     */
+    const ref<Store> store;
+
+    /**
+     * Store used to build stuff.
+     */
+    const ref<Store> buildStore;
+
+    RootValue vImportedDrvToDerivation = nullptr;
+
+    /**
+     * Debugger
+     */
+    ReplExitStatus (* debugRepl)(ref<EvalState> es, const ValMap & extraEnv);
+    bool debugStop;
+    bool inDebugger = false;
+    int trylevel;
+    std::list<DebugTrace> debugTraces;
+    std::map<const Expr*, const std::shared_ptr<const StaticEnv>> exprEnvs;
+    const std::shared_ptr<const StaticEnv> getStaticEnv(const Expr & expr) const
+    {
+        auto i = exprEnvs.find(&expr);
+        if (i != exprEnvs.end())
+            return i->second;
+        else
+            return std::shared_ptr<const StaticEnv>();;
+    }
+
+    /** Whether a debug repl can be started. If `false`, `runDebugRepl(error)` will return without starting a repl. */
+    bool canDebug();
+
+    /** Use front of `debugTraces`; see `runDebugRepl(error,env,expr)` */
+    void runDebugRepl(const Error * error);
+
+    /**
+     * Run a debug repl with the given error, environment and expression.
+     * @param error The error to debug, may be nullptr.
+     * @param env The environment to debug, matching the expression.
+     * @param expr The expression to debug, matching the environment.
+     */
+    void runDebugRepl(const Error * error, const Env & env, const Expr & expr);
+
+    template<class T, typename... Args>
+    [[nodiscard, gnu::noinline]]
+    EvalErrorBuilder<T> & error(const Args & ... args) {
+        // `EvalErrorBuilder::debugThrow` performs the corresponding `delete`.
+        return *new EvalErrorBuilder<T>(*this, args...);
+    }
+
+    /**
+     * A cache for evaluation caches, so as to reuse the same root value if possible
+     */
+    std::map<const Hash, ref<eval_cache::EvalCache>> evalCaches;
+
+private:
+
+    /* Cache for calls to addToStore(); maps source paths to the store
+       paths. */
+    Sync<std::unordered_map<SourcePath, StorePath>> srcToStore;
+
+    /**
+     * A cache from path names to parse trees.
+     */
+    typedef std::unordered_map<SourcePath, Expr *, std::hash<SourcePath>, std::equal_to<SourcePath>, traceable_allocator<std::pair<const SourcePath, Expr *>>> FileParseCache;
+    FileParseCache fileParseCache;
+
+    /**
+     * A cache from path names to values.
+     */
+    typedef std::unordered_map<SourcePath, Value, std::hash<SourcePath>, std::equal_to<SourcePath>, traceable_allocator<std::pair<const SourcePath, Value>>> FileEvalCache;
+    FileEvalCache fileEvalCache;
+
+    /**
+     * Associate source positions of certain AST nodes with their preceding doc comment, if they have one.
+     * Grouped by file.
+     */
+    std::unordered_map<SourcePath, DocCommentMap> positionToDocComment;
+
+    LookupPath lookupPath;
+
+    std::map<std::string, std::optional<std::string>> lookupPathResolved;
+
+    /**
+     * Cache used by prim_match().
+     */
+    std::shared_ptr<RegexCache> regexCache;
+
+#if HAVE_BOEHMGC
+    /**
+     * Allocation cache for GC'd Value objects.
+     */
+    std::shared_ptr<void *> valueAllocCache;
+
+    /**
+     * Allocation cache for size-1 Env objects.
+     */
+    std::shared_ptr<void *> env1AllocCache;
+#endif
+
+public:
+
+    EvalState(
+        const LookupPath & _lookupPath,
+        ref<Store> store,
+        const fetchers::Settings & fetchSettings,
+        const EvalSettings & settings,
+        std::shared_ptr<Store> buildStore = nullptr);
+    ~EvalState();
+
+    LookupPath getLookupPath() { return lookupPath; }
+
+    /**
+     * Return a `SourcePath` that refers to `path` in the root
+     * filesystem.
+     */
+    SourcePath rootPath(CanonPath path);
+
+    /**
+     * Variant which accepts relative paths too.
+     */
+    SourcePath rootPath(PathView path);
+
+    /**
+     * Allow access to a path.
+     */
+    void allowPath(const Path & path);
+
+    /**
+     * Allow access to a store path. Note that this gets remapped to
+     * the real store path if `store` is a chroot store.
+     */
+    void allowPath(const StorePath & storePath);
+
+    /**
+     * Allow access to a store path and return it as a string.
+     */
+    void allowAndSetStorePathString(const StorePath & storePath, Value & v);
+
+    void checkURI(const std::string & uri);
+
+    /**
+     * When using a diverted store and 'path' is in the Nix store, map
+     * 'path' to the diverted location (e.g. /nix/store/foo is mapped
+     * to /home/alice/my-nix/nix/store/foo). However, this is only
+     * done if the context is not empty, since otherwise we're
+     * probably trying to read from the actual /nix/store. This is
+     * intended to distinguish between import-from-derivation and
+     * sources stored in the actual /nix/store.
+     */
+    Path toRealPath(const Path & path, const NixStringContext & context);
+
+    /**
+     * Parse a Nix expression from the specified file.
+     */
+    Expr * parseExprFromFile(const SourcePath & path);
+    Expr * parseExprFromFile(const SourcePath & path, std::shared_ptr<StaticEnv> & staticEnv);
+
+    /**
+     * Parse a Nix expression from the specified string.
+     */
+    Expr * parseExprFromString(std::string s, const SourcePath & basePath, std::shared_ptr<StaticEnv> & staticEnv);
+    Expr * parseExprFromString(std::string s, const SourcePath & basePath);
+
+    Expr * parseStdin();
+
+    /**
+     * Evaluate an expression read from the given file to normal
+     * form. Optionally enforce that the top-level expression is
+     * trivial (i.e. doesn't require arbitrary computation).
+     */
+    void evalFile(const SourcePath & path, Value & v, bool mustBeTrivial = false);
+
+    void resetFileCache();
+
+    /**
+     * Look up a file in the search path.
+     */
+    SourcePath findFile(const std::string_view path);
+    SourcePath findFile(const LookupPath & lookupPath, const std::string_view path, const PosIdx pos = noPos);
+
+    /**
+     * Try to resolve a search path value (not the optional key part).
+     *
+     * If the specified search path element is a URI, download it.
+     *
+     * If it is not found, return `std::nullopt`
+     */
+    std::optional<std::string> resolveLookupPathPath(
+        const LookupPath::Path & elem,
+        bool initAccessControl = false);
+
+    /**
+     * Evaluate an expression to normal form
+     *
+     * @param [out] v The resulting is stored here.
+     */
+    void eval(Expr * e, Value & v);
+
+    /**
+     * Evaluation the expression, then verify that it has the expected
+     * type.
+     */
+    inline bool evalBool(Env & env, Expr * e);
+    inline bool evalBool(Env & env, Expr * e, const PosIdx pos, std::string_view errorCtx);
+    inline void evalAttrs(Env & env, Expr * e, Value & v, const PosIdx pos, std::string_view errorCtx);
+
+    /**
+     * If `v` is a thunk, enter it and overwrite `v` with the result
+     * of the evaluation of the thunk.  If `v` is a delayed function
+     * application, call the function and overwrite `v` with the
+     * result.  Otherwise, this is a no-op.
+     */
+    inline void forceValue(Value & v, const PosIdx pos);
+
+    void tryFixupBlackHolePos(Value & v, PosIdx pos);
+
+    /**
+     * Force a value, then recursively force list elements and
+     * attributes.
+     */
+    void forceValueDeep(Value & v);
+
+    /**
+     * Force `v`, and then verify that it has the expected type.
+     */
+    NixInt forceInt(Value & v, const PosIdx pos, std::string_view errorCtx);
+    NixFloat forceFloat(Value & v, const PosIdx pos, std::string_view errorCtx);
+    bool forceBool(Value & v, const PosIdx pos, std::string_view errorCtx);
+
+    void forceAttrs(Value & v, const PosIdx pos, std::string_view errorCtx);
+
+    template <typename Callable>
+    inline void forceAttrs(Value & v, Callable getPos, std::string_view errorCtx);
+
+    inline void forceList(Value & v, const PosIdx pos, std::string_view errorCtx);
+    /**
+     * @param v either lambda or primop
+     */
+    void forceFunction(Value & v, const PosIdx pos, std::string_view errorCtx);
+    std::string_view forceString(Value & v, const PosIdx pos, std::string_view errorCtx);
+    std::string_view forceString(Value & v, NixStringContext & context, const PosIdx pos, std::string_view errorCtx);
+    std::string_view forceStringNoCtx(Value & v, const PosIdx pos, std::string_view errorCtx);
+
+    template<typename... Args>
+    [[gnu::noinline]]
+    void addErrorTrace(Error & e, const Args & ... formatArgs) const;
+    template<typename... Args>
+    [[gnu::noinline]]
+    void addErrorTrace(Error & e, const PosIdx pos, const Args & ... formatArgs) const;
+
+public:
+    /**
+     * @return true iff the value `v` denotes a derivation (i.e. a
+     * set with attribute `type = "derivation"`).
+     */
+    bool isDerivation(Value & v);
+
+    std::optional<std::string> tryAttrsToString(const PosIdx pos, Value & v,
+        NixStringContext & context, bool coerceMore = false, bool copyToStore = true);
+
+    /**
+     * String coercion.
+     *
+     * Converts strings, paths and derivations to a
+     * string.  If `coerceMore` is set, also converts nulls, integers,
+     * booleans and lists to a string.  If `copyToStore` is set,
+     * referenced paths are copied to the Nix store as a side effect.
+     */
+    BackedStringView coerceToString(const PosIdx pos, Value & v, NixStringContext & context,
+        std::string_view errorCtx,
+        bool coerceMore = false, bool copyToStore = true,
+        bool canonicalizePath = true);
+
+    StorePath copyPathToStore(NixStringContext & context, const SourcePath & path);
+
+    /**
+     * Path coercion.
+     *
+     * Converts strings, paths and derivations to a
+     * path.  The result is guaranteed to be a canonicalised, absolute
+     * path.  Nothing is copied to the store.
+     */
+    SourcePath coerceToPath(const PosIdx pos, Value & v, NixStringContext & context, std::string_view errorCtx);
+
+    /**
+     * Like coerceToPath, but the result must be a store path.
+     */
+    StorePath coerceToStorePath(const PosIdx pos, Value & v, NixStringContext & context, std::string_view errorCtx);
+
+    /**
+     * Part of `coerceToSingleDerivedPath()` without any store IO which is exposed for unit testing only.
+     */
+    std::pair<SingleDerivedPath, std::string_view> coerceToSingleDerivedPathUnchecked(const PosIdx pos, Value & v, std::string_view errorCtx);
+
+    /**
+     * Coerce to `SingleDerivedPath`.
+     *
+     * Must be a string which is either a literal store path or a
+     * "placeholder (see `DownstreamPlaceholder`).
+     *
+     * Even more importantly, the string context must be exactly one
+     * element, which is either a `NixStringContextElem::Opaque` or
+     * `NixStringContextElem::Built`. (`NixStringContextEleme::DrvDeep`
+     * is not permitted).
+     *
+     * The string is parsed based on the context --- the context is the
+     * source of truth, and ultimately tells us what we want, and then
+     * we ensure the string corresponds to it.
+     */
+    SingleDerivedPath coerceToSingleDerivedPath(const PosIdx pos, Value & v, std::string_view errorCtx);
+
+#if HAVE_BOEHMGC
+    /** A GC root for the baseEnv reference. */
+    std::shared_ptr<Env *> baseEnvP;
+#endif
+
+public:
+
+    /**
+     * The base environment, containing the builtin functions and
+     * values.
+     */
+    Env & baseEnv;
+
+    /**
+     * The same, but used during parsing to resolve variables.
+     */
+    std::shared_ptr<StaticEnv> staticBaseEnv; // !!! should be private
+
+    /**
+     * Name and documentation about every constant.
+     *
+     * Constants from primops are hard to crawl, and their docs will go
+     * here too.
+     */
+    std::vector<std::pair<std::string, Constant>> constantInfos;
+
+private:
+
+    unsigned int baseEnvDispl = 0;
+
+    void createBaseEnv();
+
+    Value * addConstant(const std::string & name, Value & v, Constant info);
+
+    void addConstant(const std::string & name, Value * v, Constant info);
+
+    Value * addPrimOp(PrimOp && primOp);
+
+public:
+
+    Value & getBuiltin(const std::string & name);
+
+    struct Doc
+    {
+        Pos pos;
+        std::optional<std::string> name;
+        size_t arity;
+        std::vector<std::string> args;
+        /**
+         * Unlike the other `doc` fields in this file, this one should never be
+         * `null`.
+         */
+        const char * doc;
+    };
+
+    /**
+     * Retrieve the documentation for a value. This will evaluate the value if
+     * it is a thunk, and it will partially apply __functor if applicable.
+     *
+     * @param v The value to get the documentation for.
+     */
+    std::optional<Doc> getDoc(Value & v);
+
+private:
+
+    inline Value * lookupVar(Env * env, const ExprVar & var, bool noEval);
+
+    friend struct ExprVar;
+    friend struct ExprAttrs;
+    friend struct ExprLet;
+
+    Expr * parse(
+        char * text,
+        size_t length,
+        Pos::Origin origin,
+        const SourcePath & basePath,
+        std::shared_ptr<StaticEnv> & staticEnv);
+
+    /**
+     * Current Nix call stack depth, used with `max-call-depth` setting to throw stack overflow hopefully before we run out of system stack.
+     */
+    size_t callDepth = 0;
+
+public:
+
+    /**
+     * Check that the call depth is within limits, and increment it, until the returned object is destroyed.
+     */
+    inline CallDepth addCallDepth(const PosIdx pos);
+
+    /**
+     * Do a deep equality test between two values.  That is, list
+     * elements and attributes are compared recursively.
+     */
+    bool eqValues(Value & v1, Value & v2, const PosIdx pos, std::string_view errorCtx);
+
+    /**
+     * Like `eqValues`, but throws an `AssertionError` if not equal.
+     *
+     * WARNING:
+     * Callers should call `eqValues` first and report if `assertEqValues` behaves
+     * incorrectly. (e.g. if it doesn't throw if eqValues returns false or vice versa)
+     */
+    void assertEqValues(Value & v1, Value & v2, const PosIdx pos, std::string_view errorCtx);
+
+    bool isFunctor(Value & fun);
+
+    // FIXME: use std::span
+    void callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const PosIdx pos);
+
+    void callFunction(Value & fun, Value & arg, Value & vRes, const PosIdx pos)
+    {
+        Value * args[] = {&arg};
+        callFunction(fun, 1, args, vRes, pos);
+    }
+
+    /**
+     * Automatically call a function for which each argument has a
+     * default value or has a binding in the `args` map.
+     */
+    void autoCallFunction(Bindings & args, Value & fun, Value & res);
+
+    /**
+     * Allocation primitives.
+     */
+    inline Value * allocValue();
+    inline Env & allocEnv(size_t size);
+
+    Bindings * allocBindings(size_t capacity);
+
+    BindingsBuilder buildBindings(size_t capacity)
+    {
+        return BindingsBuilder(*this, allocBindings(capacity));
+    }
+
+    ListBuilder buildList(size_t size)
+    {
+        return ListBuilder(*this, size);
+    }
+
+    /**
+     * Return a boolean `Value *` without allocating.
+     */
+    Value *getBool(bool b);
+
+    void mkThunk_(Value & v, Expr * expr);
+    void mkPos(Value & v, PosIdx pos);
+
+    /**
+     * Create a string representing a store path.
+     *
+     * The string is the printed store path with a context containing a
+     * single `NixStringContextElem::Opaque` element of that store path.
+     */
+    void mkStorePathString(const StorePath & storePath, Value & v);
+
+    /**
+     * Create a string representing a `SingleDerivedPath::Built`.
+     *
+     * The string is the printed store path with a context containing a
+     * single `NixStringContextElem::Built` element of the drv path and
+     * output name.
+     *
+     * @param value Value we are settings
+     *
+     * @param b the drv whose output we are making a string for, and the
+     * output
+     *
+     * @param optStaticOutputPath Optional output path for that string.
+     * Must be passed if and only if output store object is
+     * input-addressed or fixed output. Will be printed to form string
+     * if passed, otherwise a placeholder will be used (see
+     * `DownstreamPlaceholder`).
+     *
+     * @param xpSettings Stop-gap to avoid globals during unit tests.
+     */
+    void mkOutputString(
+        Value & value,
+        const SingleDerivedPath::Built & b,
+        std::optional<StorePath> optStaticOutputPath,
+        const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
+
+    /**
+     * Create a string representing a `SingleDerivedPath`.
+     *
+     * A combination of `mkStorePathString` and `mkOutputString`.
+     */
+    void mkSingleDerivedPathString(
+        const SingleDerivedPath & p,
+        Value & v);
+
+    void concatLists(Value & v, size_t nrLists, Value * const * lists, const PosIdx pos, std::string_view errorCtx);
+
+    /**
+     * Print statistics, if enabled.
+     *
+     * Performs a full memory GC before printing the statistics, so that the
+     * GC statistics are more accurate.
+     */
+    void maybePrintStats();
+
+    /**
+     * Print statistics, unconditionally, cheaply, without performing a GC first.
+     */
+    void printStatistics();
+
+    /**
+     * Perform a full memory garbage collection - not incremental.
+     *
+     * @return true if Nix was built with GC and a GC was performed, false if not.
+     *              The return value is currently not thread safe - just the return value.
+     */
+    bool fullGC();
+
+    /**
+     * Realise the given context
+     * @param[in] context the context to realise
+     * @param[out] maybePaths if not nullptr, all built or referenced store paths will be added to this set
+     * @return a mapping from the placeholders used to construct the associated value to their final store path.
+     */
+    [[nodiscard]] StringMap realiseContext(const NixStringContext & context, StorePathSet * maybePaths = nullptr, bool isIFD = true);
+
+    /* Call the binary path filter predicate used builtins.path etc. */
+    bool callPathFilter(
+        Value * filterFun,
+        const SourcePath & path,
+        std::string_view pathArg,
+        PosIdx pos);
+
+    DocComment getDocCommentForPos(PosIdx pos);
+
+private:
+
+    /**
+     * Like `mkOutputString` but just creates a raw string, not an
+     * string Value, which would also have a string context.
+     */
+    std::string mkOutputStringRaw(
+        const SingleDerivedPath::Built & b,
+        std::optional<StorePath> optStaticOutputPath,
+        const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
+
+    /**
+     * Like `mkSingleDerivedPathStringRaw` but just creates a raw string
+     * Value, which would also have a string context.
+     */
+    std::string mkSingleDerivedPathStringRaw(
+        const SingleDerivedPath & p);
+
+    unsigned long nrEnvs = 0;
+    unsigned long nrValuesInEnvs = 0;
+    unsigned long nrValues = 0;
+    unsigned long nrListElems = 0;
+    unsigned long nrLookups = 0;
+    unsigned long nrAttrsets = 0;
+    unsigned long nrAttrsInAttrsets = 0;
+    unsigned long nrAvoided = 0;
+    unsigned long nrOpUpdates = 0;
+    unsigned long nrOpUpdateValuesCopied = 0;
+    unsigned long nrListConcats = 0;
+    unsigned long nrPrimOpCalls = 0;
+    unsigned long nrFunctionCalls = 0;
+
+    bool countCalls;
+
+    typedef std::map<std::string, size_t> PrimOpCalls;
+    PrimOpCalls primOpCalls;
+
+    typedef std::map<ExprLambda *, size_t> FunctionCalls;
+    FunctionCalls functionCalls;
+
+    void incrFunctionCall(ExprLambda * fun);
+
+    typedef std::map<PosIdx, size_t> AttrSelects;
+    AttrSelects attrSelects;
+
+    friend struct ExprOpUpdate;
+    friend struct ExprOpConcatLists;
+    friend struct ExprVar;
+    friend struct ExprString;
+    friend struct ExprInt;
+    friend struct ExprFloat;
+    friend struct ExprPath;
+    friend struct ExprSelect;
+    friend void prim_getAttr(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+    friend void prim_match(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+    friend void prim_split(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+
+    friend struct Value;
+    friend class ListBuilder;
+};
+
+struct DebugTraceStacker {
+    DebugTraceStacker(EvalState & evalState, DebugTrace t);
+    ~DebugTraceStacker()
+    {
+        evalState.debugTraces.pop_front();
+    }
+    EvalState & evalState;
+    DebugTrace trace;
+};
+
+/**
+ * @return A string representing the type of the value `v`.
+ *
+ * @param withArticle Whether to begin with an english article, e.g. "an
+ * integer" vs "integer".
+ */
+std::string_view showType(ValueType type, bool withArticle = true);
+std::string showType(const Value & v);
+
+/**
+ * If `path` refers to a directory, then append "/default.nix".
+ *
+ * @param addDefaultNix Whether to append "/default.nix" after resolving symlinks.
+ */
+SourcePath resolveExprPath(SourcePath path, bool addDefaultNix = true);
+
+/**
+ * Whether a URI is allowed, assuming restrictEval is enabled
+ */
+bool isAllowedURI(std::string_view uri, const Strings & allowedPaths);
+
+}
+
+#include "eval-inline.hh"

subprojects/libexpr/fetchurl.nix

@@ -0,0 +1,40 @@
+{ system ? "" # obsolete
+, url
+, hash ? "" # an SRI hash
+
+# Legacy hash specification
+, md5 ? "", sha1 ? "", sha256 ? "", sha512 ? ""
+, outputHash ?
+    if hash != "" then hash else if sha512 != "" then sha512 else if sha1 != "" then sha1 else if md5 != "" then md5 else sha256
+, outputHashAlgo ?
+    if hash != "" then "" else if sha512 != "" then "sha512" else if sha1 != "" then "sha1" else if md5 != "" then "md5" else "sha256"
+
+, executable ? false
+, unpack ? false
+, name ? baseNameOf (toString url)
+, impure ? false
+}:
+
+derivation ({
+  builder = "builtin:fetchurl";
+
+  # New-style output content requirements.
+  outputHashMode = if unpack || executable then "recursive" else "flat";
+
+  inherit name url executable unpack;
+
+  system = "builtin";
+
+  # No need to double the amount of network traffic
+  preferLocalBuild = true;
+
+  # This attribute does nothing; it's here to avoid changing evaluation results.
+  impureEnvVars = [
+    "http_proxy" "https_proxy" "ftp_proxy" "all_proxy" "no_proxy"
+  ];
+
+  # To make "nix-prefetch-url" work.
+  urls = [ url ];
+} // (if impure
+      then { __impure = true; }
+      else { inherit outputHashAlgo outputHash; }))

subprojects/libexpr/function-trace.cc

@@ -0,0 +1,18 @@
+#include "function-trace.hh"
+#include "logging.hh"
+
+namespace nix {
+
+FunctionCallTrace::FunctionCallTrace(const Pos & pos) : pos(pos) {
+    auto duration = std::chrono::high_resolution_clock::now().time_since_epoch();
+    auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
+    printMsg(lvlInfo, "function-trace entered %1% at %2%", pos, ns.count());
+}
+
+FunctionCallTrace::~FunctionCallTrace() {
+    auto duration = std::chrono::high_resolution_clock::now().time_since_epoch();
+    auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration);
+    printMsg(lvlInfo, "function-trace exited %1% at %2%", pos, ns.count());
+}
+
+}

subprojects/libexpr/function-trace.hh

@@ -0,0 +1,16 @@
+#pragma once
+///@file
+
+#include "eval.hh"
+
+#include <chrono>
+
+namespace nix {
+
+struct FunctionCallTrace
+{
+    const Pos pos;
+    FunctionCallTrace(const Pos & pos);
+    ~FunctionCallTrace();
+};
+}

subprojects/libexpr/gc-small-vector.hh

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <boost/container/small_vector.hpp>
+
+#include "value.hh"
+
+namespace nix {
+
+/**
+ * A GC compatible vector that may used a reserved portion of `nItems` on the stack instead of allocating on the heap.
+ */
+template <typename T, size_t nItems>
+using SmallVector = boost::container::small_vector<T, nItems, traceable_allocator<T>>;
+
+/**
+ * A vector of value pointers. See `SmallVector`.
+ */
+template <size_t nItems>
+using SmallValueVector = SmallVector<Value *, nItems>;
+
+/**
+ * A vector of values that must not be referenced after the vector is destroyed.
+ *
+ * See also `SmallValueVector`.
+ */
+template <size_t nItems>
+using SmallTemporaryValueVector = SmallVector<Value, nItems>;
+
+}

subprojects/libexpr/get-drvs.cc

@@ -0,0 +1,422 @@
+#include "get-drvs.hh"
+#include "eval-inline.hh"
+#include "derivations.hh"
+#include "store-api.hh"
+#include "path-with-outputs.hh"
+
+#include <cstring>
+#include <regex>
+
+
+namespace nix {
+
+
+PackageInfo::PackageInfo(EvalState & state, std::string attrPath, const Bindings * attrs)
+    : state(&state), attrs(attrs), attrPath(std::move(attrPath))
+{
+}
+
+
+PackageInfo::PackageInfo(EvalState & state, ref<Store> store, const std::string & drvPathWithOutputs)
+    : state(&state), attrs(nullptr), attrPath("")
+{
+    auto [drvPath, selectedOutputs] = parsePathWithOutputs(*store, drvPathWithOutputs);
+
+    this->drvPath = drvPath;
+
+    auto drv = store->derivationFromPath(drvPath);
+
+    name = drvPath.name();
+
+    if (selectedOutputs.size() > 1)
+        throw Error("building more than one derivation output is not supported, in '%s'", drvPathWithOutputs);
+
+    outputName =
+        selectedOutputs.empty()
+        ? getOr(drv.env, "outputName", "out")
+        : *selectedOutputs.begin();
+
+    auto i = drv.outputs.find(outputName);
+    if (i == drv.outputs.end())
+        throw Error("derivation '%s' does not have output '%s'", store->printStorePath(drvPath), outputName);
+    auto & [outputName, output] = *i;
+
+    outPath = {output.path(*store, drv.name, outputName)};
+}
+
+
+std::string PackageInfo::queryName() const
+{
+    if (name == "" && attrs) {
+        auto i = attrs->find(state->sName);
+        if (i == attrs->end()) state->error<TypeError>("derivation name missing").debugThrow();
+        name = state->forceStringNoCtx(*i->value, noPos, "while evaluating the 'name' attribute of a derivation");
+    }
+    return name;
+}
+
+
+std::string PackageInfo::querySystem() const
+{
+    if (system == "" && attrs) {
+        auto i = attrs->find(state->sSystem);
+        system = i == attrs->end() ? "unknown" : state->forceStringNoCtx(*i->value, i->pos, "while evaluating the 'system' attribute of a derivation");
+    }
+    return system;
+}
+
+
+std::optional<StorePath> PackageInfo::queryDrvPath() const
+{
+    if (!drvPath && attrs) {
+        if (auto i = attrs->get(state->sDrvPath)) {
+            NixStringContext context;
+            auto found = state->coerceToStorePath(i->pos, *i->value, context, "while evaluating the 'drvPath' attribute of a derivation");
+            try {
+                found.requireDerivation();
+            } catch (Error & e) {
+                e.addTrace(state->positions[i->pos], "while evaluating the 'drvPath' attribute of a derivation");
+                throw;
+            }
+            drvPath = {std::move(found)};
+        } else
+            drvPath = {std::nullopt};
+    }
+    return drvPath.value_or(std::nullopt);
+}
+
+
+StorePath PackageInfo::requireDrvPath() const
+{
+    if (auto drvPath = queryDrvPath())
+        return *drvPath;
+    throw Error("derivation does not contain a 'drvPath' attribute");
+}
+
+
+StorePath PackageInfo::queryOutPath() const
+{
+    if (!outPath && attrs) {
+        auto i = attrs->find(state->sOutPath);
+        NixStringContext context;
+        if (i != attrs->end())
+            outPath = state->coerceToStorePath(i->pos, *i->value, context, "while evaluating the output path of a derivation");
+    }
+    if (!outPath)
+        throw UnimplementedError("CA derivations are not yet supported");
+    return *outPath;
+}
+
+
+PackageInfo::Outputs PackageInfo::queryOutputs(bool withPaths, bool onlyOutputsToInstall)
+{
+    if (outputs.empty()) {
+        /* Get the ‘outputs’ list. */
+        const Attr * i;
+        if (attrs && (i = attrs->get(state->sOutputs))) {
+            state->forceList(*i->value, i->pos, "while evaluating the 'outputs' attribute of a derivation");
+
+            /* For each output... */
+            for (auto elem : i->value->listItems()) {
+                std::string output(state->forceStringNoCtx(*elem, i->pos, "while evaluating the name of an output of a derivation"));
+
+                if (withPaths) {
+                    /* Evaluate the corresponding set. */
+                    auto out = attrs->get(state->symbols.create(output));
+                    if (!out) continue; // FIXME: throw error?
+                    state->forceAttrs(*out->value, i->pos, "while evaluating an output of a derivation");
+
+                    /* And evaluate its ‘outPath’ attribute. */
+                    auto outPath = out->value->attrs()->get(state->sOutPath);
+                    if (!outPath) continue; // FIXME: throw error?
+                    NixStringContext context;
+                    outputs.emplace(output, state->coerceToStorePath(outPath->pos, *outPath->value, context, "while evaluating an output path of a derivation"));
+                } else
+                    outputs.emplace(output, std::nullopt);
+            }
+        } else
+            outputs.emplace("out", withPaths ? std::optional{queryOutPath()} : std::nullopt);
+    }
+
+    if (!onlyOutputsToInstall || !attrs)
+        return outputs;
+
+    const Attr * i;
+    if (attrs && (i = attrs->get(state->sOutputSpecified)) && state->forceBool(*i->value, i->pos, "while evaluating the 'outputSpecified' attribute of a derivation")) {
+        Outputs result;
+        auto out = outputs.find(queryOutputName());
+        if (out == outputs.end())
+            throw Error("derivation does not have output '%s'", queryOutputName());
+        result.insert(*out);
+        return result;
+    }
+
+    else {
+        /* Check for `meta.outputsToInstall` and return `outputs` reduced to that. */
+        const Value * outTI = queryMeta("outputsToInstall");
+        if (!outTI) return outputs;
+        auto errMsg = Error("this derivation has bad 'meta.outputsToInstall'");
+            /* ^ this shows during `nix-env -i` right under the bad derivation */
+        if (!outTI->isList()) throw errMsg;
+        Outputs result;
+        for (auto elem : outTI->listItems()) {
+            if (elem->type() != nString) throw errMsg;
+            auto out = outputs.find(elem->c_str());
+            if (out == outputs.end()) throw errMsg;
+            result.insert(*out);
+        }
+        return result;
+    }
+}
+
+
+std::string PackageInfo::queryOutputName() const
+{
+    if (outputName == "" && attrs) {
+        auto i = attrs->get(state->sOutputName);
+        outputName = i ? state->forceStringNoCtx(*i->value, noPos, "while evaluating the output name of a derivation") : "";
+    }
+    return outputName;
+}
+
+
+const Bindings * PackageInfo::getMeta()
+{
+    if (meta) return meta;
+    if (!attrs) return 0;
+    auto a = attrs->get(state->sMeta);
+    if (!a) return 0;
+    state->forceAttrs(*a->value, a->pos, "while evaluating the 'meta' attribute of a derivation");
+    meta = a->value->attrs();
+    return meta;
+}
+
+
+StringSet PackageInfo::queryMetaNames()
+{
+    StringSet res;
+    if (!getMeta()) return res;
+    for (auto & i : *meta)
+        res.emplace(state->symbols[i.name]);
+    return res;
+}
+
+
+bool PackageInfo::checkMeta(Value & v)
+{
+    state->forceValue(v, v.determinePos(noPos));
+    if (v.type() == nList) {
+        for (auto elem : v.listItems())
+            if (!checkMeta(*elem)) return false;
+        return true;
+    }
+    else if (v.type() == nAttrs) {
+        if (v.attrs()->get(state->sOutPath)) return false;
+        for (auto & i : *v.attrs())
+            if (!checkMeta(*i.value)) return false;
+        return true;
+    }
+    else return v.type() == nInt || v.type() == nBool || v.type() == nString ||
+                v.type() == nFloat;
+}
+
+
+Value * PackageInfo::queryMeta(const std::string & name)
+{
+    if (!getMeta()) return 0;
+    auto a = meta->get(state->symbols.create(name));
+    if (!a || !checkMeta(*a->value)) return 0;
+    return a->value;
+}
+
+
+std::string PackageInfo::queryMetaString(const std::string & name)
+{
+    Value * v = queryMeta(name);
+    if (!v || v->type() != nString) return "";
+    return v->c_str();
+}
+
+
+NixInt PackageInfo::queryMetaInt(const std::string & name, NixInt def)
+{
+    Value * v = queryMeta(name);
+    if (!v) return def;
+    if (v->type() == nInt) return v->integer();
+    if (v->type() == nString) {
+        /* Backwards compatibility with before we had support for
+           integer meta fields. */
+        if (auto n = string2Int<NixInt::Inner>(v->c_str()))
+            return NixInt{*n};
+    }
+    return def;
+}
+
+NixFloat PackageInfo::queryMetaFloat(const std::string & name, NixFloat def)
+{
+    Value * v = queryMeta(name);
+    if (!v) return def;
+    if (v->type() == nFloat) return v->fpoint();
+    if (v->type() == nString) {
+        /* Backwards compatibility with before we had support for
+           float meta fields. */
+        if (auto n = string2Float<NixFloat>(v->c_str()))
+            return *n;
+    }
+    return def;
+}
+
+
+bool PackageInfo::queryMetaBool(const std::string & name, bool def)
+{
+    Value * v = queryMeta(name);
+    if (!v) return def;
+    if (v->type() == nBool) return v->boolean();
+    if (v->type() == nString) {
+        /* Backwards compatibility with before we had support for
+           Boolean meta fields. */
+        if (v->string_view() == "true") return true;
+        if (v->string_view() == "false") return false;
+    }
+    return def;
+}
+
+
+void PackageInfo::setMeta(const std::string & name, Value * v)
+{
+    getMeta();
+    auto attrs = state->buildBindings(1 + (meta ? meta->size() : 0));
+    auto sym = state->symbols.create(name);
+    if (meta)
+        for (auto i : *meta)
+            if (i.name != sym)
+                attrs.insert(i);
+    if (v) attrs.insert(sym, v);
+    meta = attrs.finish();
+}
+
+
+/* Cache for already considered attrsets. */
+typedef std::set<const Bindings *> Done;
+
+
+/* Evaluate value `v'.  If it evaluates to a set of type `derivation',
+   then put information about it in `drvs' (unless it's already in `done').
+   The result boolean indicates whether it makes sense
+   for the caller to recursively search for derivations in `v'. */
+static bool getDerivation(EvalState & state, Value & v,
+    const std::string & attrPath, PackageInfos & drvs, Done & done,
+    bool ignoreAssertionFailures)
+{
+    try {
+        state.forceValue(v, v.determinePos(noPos));
+        if (!state.isDerivation(v)) return true;
+
+        /* Remove spurious duplicates (e.g., a set like `rec { x =
+           derivation {...}; y = x;}'. */
+        if (!done.insert(v.attrs()).second) return false;
+
+        PackageInfo drv(state, attrPath, v.attrs());
+
+        drv.queryName();
+
+        drvs.push_back(drv);
+
+        return false;
+
+    } catch (AssertionError & e) {
+        if (ignoreAssertionFailures) return false;
+        throw;
+    }
+}
+
+
+std::optional<PackageInfo> getDerivation(EvalState & state, Value & v,
+    bool ignoreAssertionFailures)
+{
+    Done done;
+    PackageInfos drvs;
+    getDerivation(state, v, "", drvs, done, ignoreAssertionFailures);
+    if (drvs.size() != 1) return {};
+    return std::move(drvs.front());
+}
+
+
+static std::string addToPath(const std::string & s1, std::string_view s2)
+{
+    return s1.empty() ? std::string(s2) : s1 + "." + s2;
+}
+
+
+static std::regex attrRegex("[A-Za-z_][A-Za-z0-9-_+]*");
+
+
+static void getDerivations(EvalState & state, Value & vIn,
+    const std::string & pathPrefix, Bindings & autoArgs,
+    PackageInfos & drvs, Done & done,
+    bool ignoreAssertionFailures)
+{
+    Value v;
+    state.autoCallFunction(autoArgs, vIn, v);
+
+    /* Process the expression. */
+    if (!getDerivation(state, v, pathPrefix, drvs, done, ignoreAssertionFailures)) ;
+
+    else if (v.type() == nAttrs) {
+
+        /* !!! undocumented hackery to support combining channels in
+           nix-env.cc. */
+        bool combineChannels = v.attrs()->get(state.symbols.create("_combineChannels"));
+
+        /* Consider the attributes in sorted order to get more
+           deterministic behaviour in nix-env operations (e.g. when
+           there are names clashes between derivations, the derivation
+           bound to the attribute with the "lower" name should take
+           precedence). */
+        for (auto & i : v.attrs()->lexicographicOrder(state.symbols)) {
+            try {
+                debug("evaluating attribute '%1%'", state.symbols[i->name]);
+                if (!std::regex_match(std::string(state.symbols[i->name]), attrRegex))
+                    continue;
+                std::string pathPrefix2 = addToPath(pathPrefix, state.symbols[i->name]);
+                if (combineChannels)
+                    getDerivations(state, *i->value, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
+                else if (getDerivation(state, *i->value, pathPrefix2, drvs, done, ignoreAssertionFailures)) {
+                    /* If the value of this attribute is itself a set,
+                    should we recurse into it?  => Only if it has a
+                    `recurseForDerivations = true' attribute. */
+                    if (i->value->type() == nAttrs) {
+                        auto j = i->value->attrs()->get(state.sRecurseForDerivations);
+                        if (j && state.forceBool(*j->value, j->pos, "while evaluating the attribute `recurseForDerivations`"))
+                            getDerivations(state, *i->value, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
+                    }
+                }
+            } catch (Error & e) {
+                e.addTrace(state.positions[i->pos], "while evaluating the attribute '%s'", state.symbols[i->name]);
+                throw;
+            }
+        }
+    }
+
+    else if (v.type() == nList) {
+        for (auto [n, elem] : enumerate(v.listItems())) {
+            std::string pathPrefix2 = addToPath(pathPrefix, fmt("%d", n));
+            if (getDerivation(state, *elem, pathPrefix2, drvs, done, ignoreAssertionFailures))
+                getDerivations(state, *elem, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
+        }
+    }
+
+    else
+        state.error<TypeError>("expression does not evaluate to a derivation (or a set or list of those)").debugThrow();
+}
+
+
+void getDerivations(EvalState & state, Value & v, const std::string & pathPrefix,
+    Bindings & autoArgs, PackageInfos & drvs, bool ignoreAssertionFailures)
+{
+    Done done;
+    getDerivations(state, v, pathPrefix, autoArgs, drvs, done, ignoreAssertionFailures);
+}
+
+
+}

subprojects/libexpr/get-drvs.hh

@@ -0,0 +1,101 @@
+#pragma once
+///@file
+
+#include "eval.hh"
+#include "path.hh"
+
+#include <string>
+#include <map>
+
+
+namespace nix {
+
+/**
+ * A "parsed" package attribute set.
+ */
+struct PackageInfo
+{
+public:
+    typedef std::map<std::string, std::optional<StorePath>> Outputs;
+
+private:
+    EvalState * state;
+
+    mutable std::string name;
+    mutable std::string system;
+    mutable std::optional<std::optional<StorePath>> drvPath;
+    mutable std::optional<StorePath> outPath;
+    mutable std::string outputName;
+    Outputs outputs;
+
+    /**
+     * Set if we get an AssertionError
+     */
+    bool failed = false;
+
+    const Bindings * attrs = nullptr, * meta = nullptr;
+
+    const Bindings * getMeta();
+
+    bool checkMeta(Value & v);
+
+public:
+    /**
+     * path towards the derivation
+     */
+    std::string attrPath;
+
+    PackageInfo(EvalState & state) : state(&state) { };
+    PackageInfo(EvalState & state, std::string attrPath, const Bindings * attrs);
+    PackageInfo(EvalState & state, ref<Store> store, const std::string & drvPathWithOutputs);
+
+    std::string queryName() const;
+    std::string querySystem() const;
+    std::optional<StorePath> queryDrvPath() const;
+    StorePath requireDrvPath() const;
+    StorePath queryOutPath() const;
+    std::string queryOutputName() const;
+    /**
+     * Return the unordered map of output names to (optional) output paths.
+     * The "outputs to install" are determined by `meta.outputsToInstall`.
+     */
+    Outputs queryOutputs(bool withPaths = true, bool onlyOutputsToInstall = false);
+
+    StringSet queryMetaNames();
+    Value * queryMeta(const std::string & name);
+    std::string queryMetaString(const std::string & name);
+    NixInt queryMetaInt(const std::string & name, NixInt def);
+    NixFloat queryMetaFloat(const std::string & name, NixFloat def);
+    bool queryMetaBool(const std::string & name, bool def);
+    void setMeta(const std::string & name, Value * v);
+
+    /*
+    MetaInfo queryMetaInfo(EvalState & state) const;
+    MetaValue queryMetaInfo(EvalState & state, const string & name) const;
+    */
+
+    void setName(const std::string & s) { name = s; }
+    void setDrvPath(StorePath path) { drvPath = {{std::move(path)}}; }
+    void setOutPath(StorePath path) { outPath = {{std::move(path)}}; }
+
+    void setFailed() { failed = true; };
+    bool hasFailed() { return failed; };
+};
+
+
+typedef std::list<PackageInfo, traceable_allocator<PackageInfo>> PackageInfos;
+
+
+/**
+ * If value `v` denotes a derivation, return a PackageInfo object
+ * describing it. Otherwise return nothing.
+ */
+std::optional<PackageInfo> getDerivation(EvalState & state,
+    Value & v, bool ignoreAssertionFailures);
+
+void getDerivations(EvalState & state, Value & v, const std::string & pathPrefix,
+    Bindings & autoArgs, PackageInfos & drvs,
+    bool ignoreAssertionFailures);
+
+
+}

subprojects/libexpr/imported-drv-to-derivation.nix

@@ -0,0 +1,21 @@
+attrs @ { drvPath, outputs, name, ... }:
+
+let
+
+  commonAttrs = (builtins.listToAttrs outputsList) //
+    { all = map (x: x.value) outputsList;
+      inherit drvPath name;
+      type = "derivation";
+    };
+
+  outputToAttrListElement = outputName:
+    { name = outputName;
+      value = commonAttrs // {
+        outPath = builtins.getAttr outputName attrs;
+        inherit outputName;
+      };
+    };
+    
+  outputsList = map outputToAttrListElement outputs;
+    
+in (builtins.head outputsList).value

subprojects/libexpr/json-to-value.cc

@@ -0,0 +1,180 @@
+#include "json-to-value.hh"
+#include "value.hh"
+#include "eval.hh"
+
+#include <limits>
+#include <variant>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+namespace nix {
+
+// for more information, refer to
+// https://github.com/nlohmann/json/blob/master/include/nlohmann/detail/input/json_sax.hpp
+class JSONSax : nlohmann::json_sax<json> {
+    class JSONState {
+    protected:
+        std::unique_ptr<JSONState> parent;
+        RootValue v;
+    public:
+        virtual std::unique_ptr<JSONState> resolve(EvalState &)
+        {
+            throw std::logic_error("tried to close toplevel json parser state");
+        }
+        explicit JSONState(std::unique_ptr<JSONState> && p) : parent(std::move(p)) {}
+        explicit JSONState(Value * v) : v(allocRootValue(v)) {}
+        JSONState(JSONState & p) = delete;
+        Value & value(EvalState & state)
+        {
+            if (!v)
+                v = allocRootValue(state.allocValue());
+            return **v;
+        }
+        virtual ~JSONState() {}
+        virtual void add() {}
+    };
+
+    class JSONObjectState : public JSONState {
+        using JSONState::JSONState;
+        ValueMap attrs;
+        std::unique_ptr<JSONState> resolve(EvalState & state) override
+        {
+            auto attrs2 = state.buildBindings(attrs.size());
+            for (auto & i : attrs)
+                attrs2.insert(i.first, i.second);
+            parent->value(state).mkAttrs(attrs2);
+            return std::move(parent);
+        }
+        void add() override { v = nullptr; }
+    public:
+        void key(string_t & name, EvalState & state)
+        {
+            attrs.insert_or_assign(state.symbols.create(name), &value(state));
+        }
+    };
+
+    class JSONListState : public JSONState {
+        ValueVector values;
+        std::unique_ptr<JSONState> resolve(EvalState & state) override
+        {
+            auto list = state.buildList(values.size());
+            for (const auto & [n, v2] : enumerate(list))
+                v2 = values[n];
+            parent->value(state).mkList(list);
+            return std::move(parent);
+        }
+        void add() override {
+            values.push_back(*v);
+            v = nullptr;
+        }
+    public:
+        JSONListState(std::unique_ptr<JSONState> && p, std::size_t reserve) : JSONState(std::move(p))
+        {
+            values.reserve(reserve);
+        }
+    };
+
+    EvalState & state;
+    std::unique_ptr<JSONState> rs;
+
+public:
+    JSONSax(EvalState & state, Value & v) : state(state), rs(new JSONState(&v)) {};
+
+    bool null() override
+    {
+        rs->value(state).mkNull();
+        rs->add();
+        return true;
+    }
+
+    bool boolean(bool val) override
+    {
+        rs->value(state).mkBool(val);
+        rs->add();
+        return true;
+    }
+
+    bool number_integer(number_integer_t val) override
+    {
+        rs->value(state).mkInt(val);
+        rs->add();
+        return true;
+    }
+
+    bool number_unsigned(number_unsigned_t val_) override
+    {
+        if (val_ > std::numeric_limits<NixInt::Inner>::max()) {
+            throw Error("unsigned json number %1% outside of Nix integer range", val_);
+        }
+        NixInt::Inner val = val_;
+        rs->value(state).mkInt(val);
+        rs->add();
+        return true;
+    }
+
+    bool number_float(number_float_t val, const string_t & s) override
+    {
+        rs->value(state).mkFloat(val);
+        rs->add();
+        return true;
+    }
+
+    bool string(string_t & val) override
+    {
+        rs->value(state).mkString(val);
+        rs->add();
+        return true;
+    }
+
+#if NLOHMANN_JSON_VERSION_MAJOR >= 3 && NLOHMANN_JSON_VERSION_MINOR >= 8
+    bool binary(binary_t&) override
+    {
+        // This function ought to be unreachable
+        assert(false);
+        return true;
+    }
+#endif
+
+    bool start_object(std::size_t len) override
+    {
+        rs = std::make_unique<JSONObjectState>(std::move(rs));
+        return true;
+    }
+
+    bool key(string_t & name) override
+    {
+        dynamic_cast<JSONObjectState*>(rs.get())->key(name, state);
+        return true;
+    }
+
+    bool end_object() override {
+        rs = rs->resolve(state);
+        rs->add();
+        return true;
+    }
+
+    bool end_array() override {
+        return end_object();
+    }
+
+    bool start_array(size_t len) override {
+        rs = std::make_unique<JSONListState>(std::move(rs),
+            len != std::numeric_limits<size_t>::max() ? len : 128);
+        return true;
+    }
+
+    bool parse_error(std::size_t, const std::string&, const nlohmann::detail::exception& ex) override {
+        throw JSONParseError("%s", ex.what());
+    }
+};
+
+void parseJSON(EvalState & state, const std::string_view & s_, Value & v)
+{
+    JSONSax parser(state, v);
+    bool res = json::sax_parse(s_, &parser);
+    if (!res)
+        throw JSONParseError("Invalid JSON Value");
+}
+
+}

subprojects/libexpr/json-to-value.hh

@@ -0,0 +1,17 @@
+#pragma once
+///@file
+
+#include "error.hh"
+
+#include <string>
+
+namespace nix {
+
+class EvalState;
+struct Value;
+
+MakeError(JSONParseError, Error);
+
+void parseJSON(EvalState & state, const std::string_view & s, Value & v);
+
+}

subprojects/libexpr/lexer-helpers.cc

@@ -0,0 +1,30 @@
+#include "lexer-tab.hh"
+#include "lexer-helpers.hh"
+#include "parser-tab.hh"
+
+void nix::lexer::internal::initLoc(YYLTYPE * loc)
+{
+    loc->beginOffset = loc->endOffset = 0;
+}
+
+void nix::lexer::internal::adjustLoc(yyscan_t yyscanner, YYLTYPE * loc, const char * s, size_t len)
+{
+    loc->stash();
+
+    LexerState & lexerState = *yyget_extra(yyscanner);
+
+    if (lexerState.docCommentDistance == 1) {
+        // Preceding token was a doc comment.
+        ParserLocation doc;
+        doc.beginOffset = lexerState.lastDocCommentLoc.beginOffset;
+        ParserLocation docEnd;
+        docEnd.beginOffset = lexerState.lastDocCommentLoc.endOffset;
+        DocComment docComment{lexerState.at(doc), lexerState.at(docEnd)};
+        PosIdx locPos = lexerState.at(*loc);
+        lexerState.positionToDocComment.emplace(locPos, docComment);
+    }
+    lexerState.docCommentDistance++;
+
+    loc->beginOffset = loc->endOffset;
+    loc->endOffset += len;
+}

subprojects/libexpr/lexer-helpers.hh

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace nix::lexer::internal {
+
+void initLoc(YYLTYPE * loc);
+
+void adjustLoc(yyscan_t yyscanner, YYLTYPE * loc, const char * s, size_t len);
+
+} // namespace nix::lexer

subprojects/libexpr/lexer.l

@@ -0,0 +1,324 @@
+%option reentrant bison-bridge bison-locations
+%option align
+%option noyywrap
+%option never-interactive
+%option stack
+%option nodefault
+%option nounput noyy_top_state
+%option extra-type="::nix::LexerState *"
+
+%s DEFAULT
+%x STRING
+%x IND_STRING
+%x INPATH
+%x INPATH_SLASH
+%x PATH_START
+
+%top {
+#include "parser-tab.hh" // YYSTYPE
+#include "parser-state.hh"
+}
+
+%{
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wunneeded-internal-declaration"
+#endif
+
+#include "nixexpr.hh"
+#include "parser-tab.hh"
+#include "lexer-helpers.hh"
+
+namespace nix {
+  struct LexerState;
+}
+
+using namespace nix;
+using namespace nix::lexer::internal;
+
+namespace nix {
+
+#define CUR_POS state->at(*yylloc)
+
+// we make use of the fact that the parser receives a private copy of the input
+// string and can munge around in it.
+static StringToken unescapeStr(SymbolTable & symbols, char * s, size_t length)
+{
+    char * result = s;
+    char * t = s;
+    char c;
+    // the input string is terminated with *two* NULs, so we can safely take
+    // *one* character after the one being checked against.
+    while ((c = *s++)) {
+        if (c == '\\') {
+            c = *s++;
+            if (c == 'n') *t = '\n';
+            else if (c == 'r') *t = '\r';
+            else if (c == 't') *t = '\t';
+            else *t = c;
+        }
+        else if (c == '\r') {
+            /* Normalise CR and CR/LF into LF. */
+            *t = '\n';
+            if (*s == '\n') s++; /* cr/lf */
+        }
+        else *t = c;
+        t++;
+    }
+    return {result, size_t(t - result)};
+}
+
+static void requireExperimentalFeature(const ExperimentalFeature & feature, const Pos & pos)
+{
+    if (!experimentalFeatureSettings.isEnabled(feature))
+        throw ParseError(ErrorInfo{
+            .msg = HintFmt("experimental Nix feature '%1%' is disabled; add '--extra-experimental-features %1%' to enable it", showExperimentalFeature(feature)),
+            .pos = pos,
+        });
+}
+
+}
+
+// yacc generates code that uses unannotated fallthrough.
+#pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
+
+#define YY_USER_INIT initLoc(yylloc)
+#define YY_USER_ACTION adjustLoc(yyscanner, yylloc, yytext, yyleng);
+
+#define PUSH_STATE(state) yy_push_state(state, yyscanner)
+#define POP_STATE() yy_pop_state(yyscanner)
+
+%}
+
+
+ANY         .|\n
+ID          [a-zA-Z\_][a-zA-Z0-9\_\'\-]*
+INT         [0-9]+
+FLOAT       (([1-9][0-9]*\.[0-9]*)|(0?\.[0-9]+))([Ee][+-]?[0-9]+)?
+PATH_CHAR   [a-zA-Z0-9\.\_\-\+]
+PATH        {PATH_CHAR}*(\/{PATH_CHAR}+)+\/?
+PATH_SEG    {PATH_CHAR}*\/
+HPATH       \~(\/{PATH_CHAR}+)+\/?
+HPATH_START \~\/
+SPATH       \<{PATH_CHAR}+(\/{PATH_CHAR}+)*\>
+URI         [a-zA-Z][a-zA-Z0-9\+\-\.]*\:[a-zA-Z0-9\%\/\?\:\@\&\=\+\$\,\-\_\.\!\~\*\']+
+
+
+%%
+
+
+if          { return IF; }
+then        { return THEN; }
+else        { return ELSE; }
+assert      { return ASSERT; }
+with        { return WITH; }
+let         { return LET; }
+in          { return IN_KW; }
+rec         { return REC; }
+inherit     { return INHERIT; }
+or          { return OR_KW; }
+\.\.\.      { return ELLIPSIS; }
+
+\=\=        { return EQ; }
+\!\=        { return NEQ; }
+\<\=        { return LEQ; }
+\>\=        { return GEQ; }
+\&\&        { return AND; }
+\|\|        { return OR; }
+\-\>        { return IMPL; }
+\/\/        { return UPDATE; }
+\+\+        { return CONCAT; }
+\<\|        { requireExperimentalFeature(Xp::PipeOperators, state->positions[CUR_POS]);
+              return PIPE_FROM;
+            }
+\|\>        { requireExperimentalFeature(Xp::PipeOperators, state->positions[CUR_POS]);
+              return PIPE_INTO;
+            }
+
+{ID}        { yylval->id = {yytext, (size_t) yyleng}; return ID; }
+{INT}       { errno = 0;
+              std::optional<int64_t> numMay = string2Int<int64_t>(yytext);
+              if (numMay.has_value()) {
+                  yylval->n = NixInt{*numMay};
+              } else {
+                  throw ParseError(ErrorInfo{
+                      .msg = HintFmt("invalid integer '%1%'", yytext),
+                      .pos = state->positions[CUR_POS],
+                  });
+              }
+              return INT_LIT;
+            }
+{FLOAT}     { errno = 0;
+              yylval->nf = strtod(yytext, 0);
+              if (errno != 0)
+                  throw ParseError(ErrorInfo{
+                      .msg = HintFmt("invalid float '%1%'", yytext),
+                      .pos = state->positions[CUR_POS],
+                  });
+              return FLOAT_LIT;
+            }
+
+\$\{        { PUSH_STATE(DEFAULT); return DOLLAR_CURLY; }
+
+\}          { /* State INITIAL only exists at the bottom of the stack and is
+                 used as a marker. DEFAULT replaces it everywhere else.
+                 Popping when in INITIAL state causes an empty stack exception,
+                 so don't */
+              if (YYSTATE != INITIAL)
+                POP_STATE();
+              return '}';
+            }
+\{          { PUSH_STATE(DEFAULT); return '{'; }
+
+\"          { PUSH_STATE(STRING); return '"'; }
+<STRING>([^\$\"\\]|\$[^\{\"\\]|\\{ANY}|\$\\{ANY})*\$/\" |
+<STRING>([^\$\"\\]|\$[^\{\"\\]|\\{ANY}|\$\\{ANY})+ {
+                /* It is impossible to match strings ending with '$' with one
+                   regex because trailing contexts are only valid at the end
+                   of a rule. (A sane but undocumented limitation.) */
+                yylval->str = unescapeStr(state->symbols, yytext, yyleng);
+                return STR;
+              }
+<STRING>\$\{  { PUSH_STATE(DEFAULT); return DOLLAR_CURLY; }
+<STRING>\"    { POP_STATE(); return '"'; }
+<STRING>\$|\\|\$\\ {
+                /* This can only occur when we reach EOF, otherwise the above
+                   (...|\$[^\{\"\\]|\\.|\$\\.)+ would have triggered.
+                   This is technically invalid, but we leave the problem to the
+                   parser who fails with exact location. */
+                return EOF;
+              }
+
+\'\'(\ *\n)?     { PUSH_STATE(IND_STRING); return IND_STRING_OPEN; }
+<IND_STRING>([^\$\']|\$[^\{\']|\'[^\'\$])+ {
+                   yylval->str = {yytext, (size_t) yyleng, true};
+                   return IND_STR;
+                 }
+<IND_STRING>\'\'\$ |
+<IND_STRING>\$   {
+                   yylval->str = {"$", 1};
+                   return IND_STR;
+                 }
+<IND_STRING>\'\'\' {
+                   yylval->str = {"''", 2};
+                   return IND_STR;
+                 }
+<IND_STRING>\'\'\\{ANY} {
+                   yylval->str = unescapeStr(state->symbols, yytext + 2, yyleng - 2);
+                   return IND_STR;
+                 }
+<IND_STRING>\$\{ { PUSH_STATE(DEFAULT); return DOLLAR_CURLY; }
+<IND_STRING>\'\' { POP_STATE(); return IND_STRING_CLOSE; }
+<IND_STRING>\'   {
+                   yylval->str = {"'", 1};
+                   return IND_STR;
+                 }
+
+{PATH_SEG}\$\{ |
+{HPATH_START}\$\{ {
+  PUSH_STATE(PATH_START);
+  yyless(0);
+  yylloc->unstash();
+}
+
+<PATH_START>{PATH_SEG} {
+  POP_STATE();
+  PUSH_STATE(INPATH_SLASH);
+  yylval->path = {yytext, (size_t) yyleng};
+  return PATH;
+}
+
+<PATH_START>{HPATH_START} {
+  POP_STATE();
+  PUSH_STATE(INPATH_SLASH);
+  yylval->path = {yytext, (size_t) yyleng};
+  return HPATH;
+}
+
+{PATH} {
+  if (yytext[yyleng-1] == '/')
+    PUSH_STATE(INPATH_SLASH);
+  else
+    PUSH_STATE(INPATH);
+  yylval->path = {yytext, (size_t) yyleng};
+  return PATH;
+}
+{HPATH} {
+  if (yytext[yyleng-1] == '/')
+    PUSH_STATE(INPATH_SLASH);
+  else
+    PUSH_STATE(INPATH);
+  yylval->path = {yytext, (size_t) yyleng};
+  return HPATH;
+}
+
+<INPATH,INPATH_SLASH>\$\{ {
+  POP_STATE();
+  PUSH_STATE(INPATH);
+  PUSH_STATE(DEFAULT);
+  return DOLLAR_CURLY;
+}
+<INPATH,INPATH_SLASH>{PATH}|{PATH_SEG}|{PATH_CHAR}+ {
+  POP_STATE();
+  if (yytext[yyleng-1] == '/')
+      PUSH_STATE(INPATH_SLASH);
+  else
+      PUSH_STATE(INPATH);
+  yylval->str = {yytext, (size_t) yyleng};
+  return STR;
+}
+<INPATH>{ANY} |
+<INPATH><<EOF>> {
+  /* if we encounter a non-path character we inform the parser that the path has
+     ended with a PATH_END token and re-parse this character in the default
+     context (it may be ')', ';', or something of that sort) */
+  POP_STATE();
+  yyless(0);
+  yylloc->unstash();
+  return PATH_END;
+}
+
+<INPATH_SLASH>{ANY} |
+<INPATH_SLASH><<EOF>> {
+  throw ParseError(ErrorInfo{
+      .msg = HintFmt("path has a trailing slash"),
+      .pos = state->positions[CUR_POS],
+  });
+}
+
+{SPATH}     { yylval->path = {yytext, (size_t) yyleng}; return SPATH; }
+{URI}       { yylval->uri = {yytext, (size_t) yyleng}; return URI; }
+
+%{
+// Doc comment rule
+//
+//   \/\*\*                            /**
+//         [^/*]                       reject /**/ (empty comment) and /***
+//              ([^*]|\*+[^*/])*\*+\/  same as the long comment rule
+//              (             )*       zero or more non-ending sequences
+//                              \*     end(1)
+//                                 \/  end(2)
+%}
+\/\*\*[^/*]([^*]|\*+[^*/])*\*+\/  /* doc comments */ {
+    LexerState & lexerState = *yyget_extra(yyscanner);
+    lexerState.docCommentDistance = 0;
+    lexerState.lastDocCommentLoc.beginOffset = yylloc->beginOffset;
+    lexerState.lastDocCommentLoc.endOffset = yylloc->endOffset;
+}
+
+
+%{
+// The following rules have docCommentDistance--
+// This compensates for the docCommentDistance++ which happens by default to
+// make all the other rules invalidate the doc comment.
+%}
+[ \t\r\n]+    /* eat up whitespace */ { yyget_extra(yyscanner)->docCommentDistance--; }
+\#[^\r\n]*    /* single-line comments */ { yyget_extra(yyscanner)->docCommentDistance--; }
+\/\*([^*]|\*+[^*/])*\*+\/  /* long comments */ { yyget_extra(yyscanner)->docCommentDistance--; }
+
+{ANY}       {
+              /* Don't return a negative number, as this will cause
+                 Bison to stop parsing without an error. */
+              return (unsigned char) yytext[0];
+            }
+
+%%

subprojects/libexpr/local.mk

@@ -0,0 +1,50 @@
+libraries += libexpr
+
+libexpr_NAME = libnixexpr
+
+libexpr_DIR := $(d)
+
+libexpr_SOURCES := \
+  $(wildcard $(d)/*.cc) \
+  $(wildcard $(d)/value/*.cc) \
+  $(wildcard $(d)/primops/*.cc) \
+  $(d)/lexer-tab.cc \
+  $(d)/parser-tab.cc
+# Not just for this library itself, but also for downstream libraries using this library
+
+INCLUDE_libexpr := -I $(d)
+
+libexpr_CXXFLAGS += \
+	$(INCLUDE_libutil) $(INCLUDE_libstore) $(INCLUDE_libfetchers) $(INCLUDE_libexpr) \
+	-DGC_THREADS
+
+libexpr_LIBS = libutil libstore libfetchers
+
+libexpr_LDFLAGS += -lboost_context $(THREAD_LDFLAGS)
+ifdef HOST_LINUX
+  libexpr_LDFLAGS += -ldl
+endif
+
+# The dependency on libgc must be propagated (i.e. meaning that
+# programs/libraries that use libexpr must explicitly pass -lgc),
+# because inline functions in libexpr's header files call libgc.
+libexpr_LDFLAGS_PROPAGATED = $(BDW_GC_LIBS)
+
+libexpr_ORDER_AFTER := $(d)/parser-tab.cc $(d)/parser-tab.hh $(d)/lexer-tab.cc $(d)/lexer-tab.hh
+
+$(d)/parser-tab.cc $(d)/parser-tab.hh: $(d)/parser.y
+	$(trace-gen) bison -v -o $(libexpr_DIR)/parser-tab.cc $< -d
+
+$(d)/lexer-tab.cc $(d)/lexer-tab.hh: $(d)/lexer.l
+	$(trace-gen) flex --outfile $(libexpr_DIR)/lexer-tab.cc --header-file=$(libexpr_DIR)/lexer-tab.hh $<
+
+clean-files += $(d)/parser-tab.cc $(d)/parser-tab.hh $(d)/lexer-tab.cc $(d)/lexer-tab.hh
+
+$(eval $(call install-file-in, $(buildprefix)$(d)/nix-expr.pc, $(libdir)/pkgconfig, 0644))
+
+$(foreach i, $(wildcard $(d)/value/*.hh), \
+  $(eval $(call install-file-in, $(i), $(includedir)/nix/value, 0644)))
+
+$(d)/primops.cc: $(d)/imported-drv-to-derivation.nix.gen.hh
+
+$(d)/eval.cc: $(d)/primops/derivation.nix.gen.hh $(d)/fetchurl.nix.gen.hh $(d)/call-flake.nix.gen.hh

subprojects/libexpr/meson.build

@@ -0,0 +1,210 @@
+project('nix-expr', 'cpp',
+  version : files('.version'),
+  default_options : [
+    'cpp_std=c++2a',
+    # TODO(Qyriad): increase the warning level
+    'warning_level=1',
+    'debug=true',
+    'optimization=2',
+    'errorlogs=true', # Please print logs for tests that fail
+  ],
+  meson_version : '>= 1.1',
+  license : 'LGPL-2.1-or-later',
+)
+
+cxx = meson.get_compiler('cpp')
+
+subdir('build-utils-meson/deps-lists')
+
+configdata = configuration_data()
+
+deps_private_maybe_subproject = [
+]
+deps_public_maybe_subproject = [
+  dependency('nix-util'),
+  dependency('nix-store'),
+  dependency('nix-fetchers'),
+]
+subdir('build-utils-meson/subprojects')
+
+subdir('build-utils-meson/threads')
+
+boost = dependency(
+  'boost',
+  modules : ['container', 'context'],
+  include_type: 'system',
+)
+# boost is a public dependency, but not a pkg-config dependency unfortunately, so we
+# put in `deps_other`.
+deps_other += boost
+
+nlohmann_json = dependency('nlohmann_json', version : '>= 3.9')
+deps_public += nlohmann_json
+
+bdw_gc = dependency('bdw-gc', required : get_option('gc'))
+if bdw_gc.found()
+  deps_public += bdw_gc
+  foreach funcspec : [
+    'pthread_attr_get_np',
+    'pthread_getattr_np',
+  ]
+    define_name = 'HAVE_' + funcspec.underscorify().to_upper()
+    define_value = cxx.has_function(funcspec).to_int()
+    configdata.set(define_name, define_value)
+  endforeach
+  configdata.set('GC_THREADS', 1)
+endif
+configdata.set('HAVE_BOEHMGC', bdw_gc.found().to_int())
+
+toml11 = dependency(
+  'toml11',
+  version : '>=3.7.0',
+  method : 'cmake',
+  include_type: 'system',
+)
+deps_other += toml11
+
+config_h = configure_file(
+  configuration : configdata,
+  output : 'config-expr.hh',
+)
+
+add_project_arguments(
+  # TODO(Qyriad): Yes this is how the autoconf+Make system did it.
+  # It would be nice for our headers to be idempotent instead.
+  '-include', 'config-util.hh',
+  '-include', 'config-store.hh',
+  # '-include', 'config-fetchers.h',
+  '-include', 'config-expr.hh',
+  language : 'cpp',
+)
+
+subdir('build-utils-meson/diagnostics')
+
+parser_tab = custom_target(
+  input : 'parser.y',
+  output : [
+    'parser-tab.cc',
+    'parser-tab.hh',
+  ],
+  command : [
+    'bison',
+    '-v',
+    '-o',
+    '@OUTPUT0@',
+    '@INPUT@',
+    '-d',
+  ],
+  # NOTE(Qyriad): Meson doesn't support installing only part of a custom target, so we add
+  # an install script below which removes parser-tab.cc.
+  install : true,
+  install_dir : get_option('includedir') / 'nix',
+)
+
+lexer_tab = custom_target(
+  input : [
+    'lexer.l',
+    parser_tab,
+  ],
+  output : [
+    'lexer-tab.cc',
+    'lexer-tab.hh',
+  ],
+  command : [
+    'flex',
+    '--outfile',
+    '@OUTPUT0@',
+    '--header-file=' + '@OUTPUT1@',
+    '@INPUT0@',
+  ],
+  # NOTE(Qyriad): Meson doesn't support installing only part of a custom target, so we add
+  # an install script below which removes lexer-tab.cc.
+  install : true,
+  install_dir : get_option('includedir') / 'nix',
+)
+
+subdir('build-utils-meson/generate-header')
+
+generated_headers = []
+foreach header : [
+  'imported-drv-to-derivation.nix',
+  'fetchurl.nix',
+  'call-flake.nix',
+]
+  generated_headers += gen_header.process(header)
+endforeach
+
+sources = files(
+  'attr-path.cc',
+  'attr-set.cc',
+  'eval-cache.cc',
+  'eval-error.cc',
+  'eval-gc.cc',
+  'eval-settings.cc',
+  'eval.cc',
+  'function-trace.cc',
+  'get-drvs.cc',
+  'json-to-value.cc',
+  'lexer-helpers.cc',
+  'nixexpr.cc',
+  'paths.cc',
+  'primops.cc',
+  'print-ambiguous.cc',
+  'print.cc',
+  'search-path.cc',
+  'value-to-json.cc',
+  'value-to-xml.cc',
+  'value/context.cc',
+)
+
+include_dirs = [include_directories('.')]
+
+headers = [config_h] + files(
+  'attr-path.hh',
+  'attr-set.hh',
+  'eval-cache.hh',
+  'eval-error.hh',
+  'eval-gc.hh',
+  'eval-inline.hh',
+  'eval-settings.hh',
+  'eval.hh',
+  'function-trace.hh',
+  'gc-small-vector.hh',
+  'get-drvs.hh',
+  'json-to-value.hh',
+  # internal: 'lexer-helpers.hh',
+  'nixexpr.hh',
+  'parser-state.hh',
+  'pos-idx.hh',
+  'pos-table.hh',
+  'primops.hh',
+  'print-ambiguous.hh',
+  'print-options.hh',
+  'print.hh',
+  'repl-exit-status.hh',
+  'search-path.hh',
+  'symbol-table.hh',
+  'value-to-json.hh',
+  'value-to-xml.hh',
+  'value.hh',
+  'value/context.hh',
+)
+
+subdir('primops')
+
+this_library = library(
+  'nixexpr',
+  sources,
+  parser_tab,
+  lexer_tab,
+  generated_headers,
+  dependencies : deps_public + deps_private + deps_other,
+  prelink : true, # For C++ static initializers
+  install : true,
+)
+
+install_headers(headers, subdir : 'nix', preserve_path : true)
+
+libraries_private = []
+
+subdir('build-utils-meson/export')

subprojects/libexpr/meson.options

@@ -0,0 +1,3 @@
+option('gc', type : 'feature',
+  description : 'enable garbage collection in the Nix expression evaluator (requires Boehm GC)',
+)

subprojects/libexpr/nix-expr.pc.in

@@ -0,0 +1,10 @@
+prefix=@prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: Nix
+Description: Nix Package Manager
+Version: @PACKAGE_VERSION@
+Requires: nix-store bdw-gc
+Libs: -L${libdir} -lnixexpr
+Cflags: -I${includedir}/nix -std=c++2a

subprojects/libexpr/nixexpr.cc

@@ -0,0 +1,694 @@
+#include "nixexpr.hh"
+#include "eval.hh"
+#include "symbol-table.hh"
+#include "util.hh"
+#include "print.hh"
+
+#include <cstdlib>
+#include <sstream>
+
+#include "strings-inline.hh"
+
+namespace nix {
+
+unsigned long Expr::nrExprs = 0;
+
+ExprBlackHole eBlackHole;
+
+// FIXME: remove, because *symbols* are abstract and do not have a single
+//        textual representation; see printIdentifier()
+std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
+{
+    std::string_view s = symbol;
+    return printIdentifier(str, s);
+}
+
+void Expr::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    unreachable();
+}
+
+void ExprInt::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << v.integer();
+}
+
+void ExprFloat::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << v.fpoint();
+}
+
+void ExprString::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    printLiteralString(str, s);
+}
+
+void ExprPath::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << s;
+}
+
+void ExprVar::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << symbols[name];
+}
+
+void ExprSelect::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "(";
+    e->show(symbols, str);
+    str << ")." << showAttrPath(symbols, attrPath);
+    if (def) {
+        str << " or (";
+        def->show(symbols, str);
+        str << ")";
+    }
+}
+
+void ExprOpHasAttr::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "((";
+    e->show(symbols, str);
+    str << ") ? " << showAttrPath(symbols, attrPath) << ")";
+}
+
+void ExprAttrs::showBindings(const SymbolTable & symbols, std::ostream & str) const
+{
+    typedef const decltype(attrs)::value_type * Attr;
+    std::vector<Attr> sorted;
+    for (auto & i : attrs) sorted.push_back(&i);
+    std::sort(sorted.begin(), sorted.end(), [&](Attr a, Attr b) {
+        std::string_view sa = symbols[a->first], sb = symbols[b->first];
+        return sa < sb;
+    });
+    std::vector<Symbol> inherits;
+    // We can use the displacement as a proxy for the order in which the symbols were parsed.
+    // The assignment of displacements should be deterministic, so that showBindings is deterministic.
+    std::map<Displacement, std::vector<Symbol>> inheritsFrom;
+    for (auto & i : sorted) {
+        switch (i->second.kind) {
+        case AttrDef::Kind::Plain:
+            break;
+        case AttrDef::Kind::Inherited:
+            inherits.push_back(i->first);
+            break;
+        case AttrDef::Kind::InheritedFrom: {
+            auto & select = dynamic_cast<ExprSelect &>(*i->second.e);
+            auto & from = dynamic_cast<ExprInheritFrom &>(*select.e);
+            inheritsFrom[from.displ].push_back(i->first);
+            break;
+        }
+        }
+    }
+    if (!inherits.empty()) {
+        str << "inherit";
+        for (auto sym : inherits) str << " " << symbols[sym];
+        str << "; ";
+    }
+    for (const auto & [from, syms] : inheritsFrom) {
+        str << "inherit (";
+        (*inheritFromExprs)[from]->show(symbols, str);
+        str << ")";
+        for (auto sym : syms) str << " " << symbols[sym];
+        str << "; ";
+    }
+    for (auto & i : sorted) {
+        if (i->second.kind == AttrDef::Kind::Plain) {
+            str << symbols[i->first] << " = ";
+            i->second.e->show(symbols, str);
+            str << "; ";
+        }
+    }
+    for (auto & i : dynamicAttrs) {
+        str << "\"${";
+        i.nameExpr->show(symbols, str);
+        str << "}\" = ";
+        i.valueExpr->show(symbols, str);
+        str << "; ";
+    }
+}
+
+void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    if (recursive) str << "rec ";
+    str << "{ ";
+    showBindings(symbols, str);
+    str << "}";
+}
+
+void ExprList::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "[ ";
+    for (auto & i : elems) {
+        str << "(";
+        i->show(symbols, str);
+        str << ") ";
+    }
+    str << "]";
+}
+
+void ExprLambda::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "(";
+    if (hasFormals()) {
+        str << "{ ";
+        bool first = true;
+        // the natural Symbol ordering is by creation time, which can lead to the
+        // same expression being printed in two different ways depending on its
+        // context. always use lexicographic ordering to avoid this.
+        for (auto & i : formals->lexicographicOrder(symbols)) {
+            if (first) first = false; else str << ", ";
+            str << symbols[i.name];
+            if (i.def) {
+                str << " ? ";
+                i.def->show(symbols, str);
+            }
+        }
+        if (formals->ellipsis) {
+            if (!first) str << ", ";
+            str << "...";
+        }
+        str << " }";
+        if (arg) str << " @ ";
+    }
+    if (arg) str << symbols[arg];
+    str << ": ";
+    body->show(symbols, str);
+    str << ")";
+}
+
+void ExprCall::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << '(';
+    fun->show(symbols, str);
+    for (auto e : args) {
+        str <<  ' ';
+        e->show(symbols, str);
+    }
+    str << ')';
+}
+
+void ExprLet::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "(let ";
+    attrs->showBindings(symbols, str);
+    str << "in ";
+    body->show(symbols, str);
+    str << ")";
+}
+
+void ExprWith::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "(with ";
+    attrs->show(symbols, str);
+    str << "; ";
+    body->show(symbols, str);
+    str << ")";
+}
+
+void ExprIf::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "(if ";
+    cond->show(symbols, str);
+    str << " then ";
+    then->show(symbols, str);
+    str << " else ";
+    else_->show(symbols, str);
+    str << ")";
+}
+
+void ExprAssert::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "assert ";
+    cond->show(symbols, str);
+    str << "; ";
+    body->show(symbols, str);
+}
+
+void ExprOpNot::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "(! ";
+    e->show(symbols, str);
+    str << ")";
+}
+
+void ExprConcatStrings::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    bool first = true;
+    str << "(";
+    for (auto & i : *es) {
+        if (first) first = false; else str << " + ";
+        i.second->show(symbols, str);
+    }
+    str << ")";
+}
+
+void ExprPos::show(const SymbolTable & symbols, std::ostream & str) const
+{
+    str << "__curPos";
+}
+
+
+std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath)
+{
+    std::ostringstream out;
+    bool first = true;
+    for (auto & i : attrPath) {
+        if (!first) out << '.'; else first = false;
+        if (i.symbol)
+            out << symbols[i.symbol];
+        else {
+            out << "\"${";
+            i.expr->show(symbols, out);
+            out << "}\"";
+        }
+    }
+    return out.str();
+}
+
+
+/* Computing levels/displacements for variables. */
+
+void Expr::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    unreachable();
+}
+
+void ExprInt::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+}
+
+void ExprFloat::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+}
+
+void ExprString::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+}
+
+void ExprPath::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+}
+
+void ExprVar::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    fromWith = nullptr;
+
+    /* Check whether the variable appears in the environment.  If so,
+       set its level and displacement. */
+    const StaticEnv * curEnv;
+    Level level;
+    int withLevel = -1;
+    for (curEnv = env.get(), level = 0; curEnv; curEnv = curEnv->up, level++) {
+        if (curEnv->isWith) {
+            if (withLevel == -1) withLevel = level;
+        } else {
+            auto i = curEnv->find(name);
+            if (i != curEnv->vars.end()) {
+                this->level = level;
+                displ = i->second;
+                return;
+            }
+        }
+    }
+
+    /* Otherwise, the variable must be obtained from the nearest
+       enclosing `with'.  If there is no `with', then we can issue an
+       "undefined variable" error now. */
+    if (withLevel == -1)
+        es.error<UndefinedVarError>(
+            "undefined variable '%1%'",
+            es.symbols[name]
+        ).atPos(pos).debugThrow();
+    for (auto * e = env.get(); e && !fromWith; e = e->up)
+        fromWith = e->isWith;
+    this->level = withLevel;
+}
+
+void ExprInheritFrom::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+}
+
+void ExprSelect::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    e->bindVars(es, env);
+    if (def) def->bindVars(es, env);
+    for (auto & i : attrPath)
+        if (!i.symbol)
+            i.expr->bindVars(es, env);
+}
+
+void ExprOpHasAttr::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    e->bindVars(es, env);
+    for (auto & i : attrPath)
+        if (!i.symbol)
+            i.expr->bindVars(es, env);
+}
+
+std::shared_ptr<const StaticEnv> ExprAttrs::bindInheritSources(
+    EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (!inheritFromExprs)
+        return nullptr;
+
+    // the inherit (from) source values are inserted into an env of its own, which
+    // does not introduce any variable names.
+    // analysis must see an empty env, or an env that contains only entries with
+    // otherwise unused names to not interfere with regular names. the parser
+    // has already filled all exprs that access this env with appropriate level
+    // and displacement, and nothing else is allowed to access it. ideally we'd
+    // not even *have* an expr that grabs anything from this env since it's fully
+    // invisible, but the evaluator does not allow for this yet.
+    auto inner = std::make_shared<StaticEnv>(nullptr, env.get(), 0);
+    for (auto from : *inheritFromExprs)
+        from->bindVars(es, env);
+
+    return inner;
+}
+
+void ExprAttrs::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    if (recursive) {
+        auto newEnv = [&] () -> std::shared_ptr<const StaticEnv> {
+            auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), attrs.size());
+
+            Displacement displ = 0;
+            for (auto & i : attrs)
+                newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+            return newEnv;
+        }();
+
+        // No need to sort newEnv since attrs is in sorted order.
+
+        auto inheritFromEnv = bindInheritSources(es, newEnv);
+        for (auto & i : attrs)
+            i.second.e->bindVars(es, i.second.chooseByKind(newEnv, env, inheritFromEnv));
+
+        for (auto & i : dynamicAttrs) {
+            i.nameExpr->bindVars(es, newEnv);
+            i.valueExpr->bindVars(es, newEnv);
+        }
+    }
+    else {
+        auto inheritFromEnv = bindInheritSources(es, env);
+
+        for (auto & i : attrs)
+            i.second.e->bindVars(es, i.second.chooseByKind(env, env, inheritFromEnv));
+
+        for (auto & i : dynamicAttrs) {
+            i.nameExpr->bindVars(es, env);
+            i.valueExpr->bindVars(es, env);
+        }
+    }
+}
+
+void ExprList::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    for (auto & i : elems)
+        i->bindVars(es, env);
+}
+
+void ExprLambda::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    auto newEnv = std::make_shared<StaticEnv>(
+        nullptr, env.get(),
+        (hasFormals() ? formals->formals.size() : 0) +
+        (!arg ? 0 : 1));
+
+    Displacement displ = 0;
+
+    if (arg) newEnv->vars.emplace_back(arg, displ++);
+
+    if (hasFormals()) {
+        for (auto & i : formals->formals)
+            newEnv->vars.emplace_back(i.name, displ++);
+
+        newEnv->sort();
+
+        for (auto & i : formals->formals)
+            if (i.def) i.def->bindVars(es, newEnv);
+    }
+
+    body->bindVars(es, newEnv);
+}
+
+void ExprCall::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    fun->bindVars(es, env);
+    for (auto e : args)
+        e->bindVars(es, env);
+}
+
+void ExprLet::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    auto newEnv = [&] () -> std::shared_ptr<const StaticEnv> {
+        auto newEnv = std::make_shared<StaticEnv>(nullptr, env.get(), attrs->attrs.size());
+
+        Displacement displ = 0;
+        for (auto & i : attrs->attrs)
+            newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
+        return newEnv;
+    }();
+
+    // No need to sort newEnv since attrs->attrs is in sorted order.
+
+    auto inheritFromEnv = attrs->bindInheritSources(es, newEnv);
+    for (auto & i : attrs->attrs)
+        i.second.e->bindVars(es, i.second.chooseByKind(newEnv, env, inheritFromEnv));
+
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, newEnv));
+
+    body->bindVars(es, newEnv);
+}
+
+void ExprWith::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    parentWith = nullptr;
+    for (auto * e = env.get(); e && !parentWith; e = e->up)
+        parentWith = e->isWith;
+
+    /* Does this `with' have an enclosing `with'?  If so, record its
+       level so that `lookupVar' can look up variables in the previous
+       `with' if this one doesn't contain the desired attribute. */
+    const StaticEnv * curEnv;
+    Level level;
+    prevWith = 0;
+    for (curEnv = env.get(), level = 1; curEnv; curEnv = curEnv->up, level++)
+        if (curEnv->isWith) {
+            prevWith = level;
+            break;
+        }
+
+    attrs->bindVars(es, env);
+    auto newEnv = std::make_shared<StaticEnv>(this, env.get());
+    body->bindVars(es, newEnv);
+}
+
+void ExprIf::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    cond->bindVars(es, env);
+    then->bindVars(es, env);
+    else_->bindVars(es, env);
+}
+
+void ExprAssert::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    cond->bindVars(es, env);
+    body->bindVars(es, env);
+}
+
+void ExprOpNot::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    e->bindVars(es, env);
+}
+
+void ExprConcatStrings::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+
+    for (auto & i : *this->es)
+        i.second->bindVars(es, env);
+}
+
+void ExprPos::bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env)
+{
+    if (es.debugRepl)
+        es.exprEnvs.insert(std::make_pair(this, env));
+}
+
+
+/* Storing function names. */
+
+void Expr::setName(Symbol name)
+{
+}
+
+
+void ExprLambda::setName(Symbol name)
+{
+    this->name = name;
+    body->setName(name);
+}
+
+
+std::string ExprLambda::showNamePos(const EvalState & state) const
+{
+    std::string id(name
+        ? concatStrings("'", state.symbols[name], "'")
+        : "anonymous function");
+    return fmt("%1% at %2%", id, state.positions[pos]);
+}
+
+void ExprLambda::setDocComment(DocComment docComment) {
+    // RFC 145 specifies that the innermost doc comment wins.
+    // See https://github.com/NixOS/rfcs/blob/master/rfcs/0145-doc-strings.md#ambiguous-placement
+    if (!this->docComment) {
+        this->docComment = docComment;
+
+        // Curried functions are defined by putting a function directly
+        // in the body of another function. To render docs for those, we
+        // need to propagate the doc comment to the innermost function.
+        //
+        // If we have our own comment, we've already propagated it, so this
+        // belongs in the same conditional.
+        body->setDocComment(docComment);
+    }
+};
+
+
+
+/* Position table. */
+
+Pos PosTable::operator[](PosIdx p) const
+{
+    auto origin = resolve(p);
+    if (!origin)
+        return {};
+
+    const auto offset = origin->offsetOf(p);
+
+    Pos result{0, 0, origin->origin};
+    auto lines = this->lines.lock();
+    auto linesForInput = (*lines)[origin->offset];
+
+    if (linesForInput.empty()) {
+        auto source = result.getSource().value_or("");
+        const char * begin = source.data();
+        for (Pos::LinesIterator it(source), end; it != end; it++)
+            linesForInput.push_back(it->data() - begin);
+        if (linesForInput.empty())
+            linesForInput.push_back(0);
+    }
+    // as above: the first line starts at byte 0 and is always present
+    auto lineStartOffset = std::prev(
+        std::upper_bound(linesForInput.begin(), linesForInput.end(), offset));
+
+    result.line = 1 + (lineStartOffset - linesForInput.begin());
+    result.column = 1 + (offset - *lineStartOffset);
+    return result;
+}
+
+
+
+/* Symbol table. */
+
+size_t SymbolTable::totalSize() const
+{
+    size_t n = 0;
+    dump([&] (const std::string & s) { n += s.size(); });
+    return n;
+}
+
+std::string DocComment::getInnerText(const PosTable & positions) const {
+    auto beginPos = positions[begin];
+    auto endPos = positions[end];
+    auto docCommentStr = beginPos.getSnippetUpTo(endPos).value_or("");
+
+    // Strip "/**" and "*/"
+    constexpr size_t prefixLen = 3;
+    constexpr size_t suffixLen = 2;
+    std::string docStr = docCommentStr.substr(prefixLen, docCommentStr.size() - prefixLen - suffixLen);
+    if (docStr.empty())
+        return {};
+    // Turn the now missing "/**" into indentation
+    docStr = "   " + docStr;
+    // Strip indentation (for the whole, potentially multi-line string)
+    docStr = stripIndentation(docStr);
+    return docStr;
+}
+
+
+
+/* ‘Cursed or’ handling.
+ *
+ * In parser.y, every use of expr_select in a production must call one of the
+ * two below functions.
+ *
+ * To be removed by https://github.com/NixOS/nix/pull/11121
+ */
+
+void ExprCall::resetCursedOr()
+{
+    cursedOrEndPos.reset();
+}
+
+void ExprCall::warnIfCursedOr(const SymbolTable & symbols, const PosTable & positions)
+{
+    if (cursedOrEndPos.has_value()) {
+        std::ostringstream out;
+        out << "at " << positions[pos] << ": "
+               "This expression uses `or` as an identifier in a way that will change in a future Nix release.\n"
+               "Wrap this entire expression in parentheses to preserve its current meaning:\n"
+               "    (" << positions[pos].getSnippetUpTo(positions[*cursedOrEndPos]).value_or("could not read expression") << ")\n"
+               "Give feedback at https://github.com/NixOS/nix/pull/11121";
+        warn(out.str());
+    }
+}
+
+}

subprojects/libexpr/nixexpr.hh

@@ -0,0 +1,519 @@
+#pragma once
+///@file
+
+#include <map>
+#include <vector>
+
+#include "value.hh"
+#include "symbol-table.hh"
+#include "eval-error.hh"
+#include "pos-idx.hh"
+
+namespace nix {
+
+class EvalState;
+class PosTable;
+struct Env;
+struct ExprWith;
+struct StaticEnv;
+struct Value;
+
+/**
+ * A documentation comment, in the sense of [RFC 145](https://github.com/NixOS/rfcs/blob/master/rfcs/0145-doc-strings.md)
+ *
+ * Note that this does not implement the following:
+ *  - argument attribute names ("formals"): TBD
+ *  - argument names: these are internal to the function and their names may not be optimal for documentation
+ *  - function arity (degree of currying or number of ':'s):
+ *      - Functions returning partially applied functions have a higher arity
+ *        than can be determined locally and without evaluation.
+ *        We do not want to present false data.
+ *      - Some functions should be thought of as transformations of other
+ *        functions. For instance `overlay -> overlay -> overlay` is the simplest
+ *        way to understand `composeExtensions`, but its implementation looks like
+ *        `f: g: final: prev: <...>`. The parameters `final` and `prev` are part
+ *        of the overlay concept, while distracting from the function's purpose.
+ */
+struct DocComment {
+
+    /**
+     * Start of the comment, including the opening, ie `/` and `**`.
+     */
+    PosIdx begin;
+
+    /**
+     * Position right after the final asterisk and `/` that terminate the comment.
+     */
+    PosIdx end;
+
+    /**
+     * Whether the comment is set.
+     *
+     * A `DocComment` is small enough that it makes sense to pass by value, and
+     * therefore baking optionality into it is also useful, to avoiding the memory
+     * overhead of `std::optional`.
+     */
+    operator bool() const { return static_cast<bool>(begin); }
+
+    std::string getInnerText(const PosTable & positions) const;
+
+};
+
+/**
+ * An attribute path is a sequence of attribute names.
+ */
+struct AttrName
+{
+    Symbol symbol;
+    Expr * expr;
+    AttrName(Symbol s) : symbol(s) {};
+    AttrName(Expr * e) : expr(e) {};
+};
+
+typedef std::vector<AttrName> AttrPath;
+
+std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath);
+
+
+/* Abstract syntax of Nix expressions. */
+
+struct Expr
+{
+    struct AstSymbols {
+        Symbol sub, lessThan, mul, div, or_, findFile, nixPath, body;
+    };
+
+
+    static unsigned long nrExprs;
+    Expr() {
+        nrExprs++;
+    }
+    virtual ~Expr() { };
+    virtual void show(const SymbolTable & symbols, std::ostream & str) const;
+    virtual void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env);
+    virtual void eval(EvalState & state, Env & env, Value & v);
+    virtual Value * maybeThunk(EvalState & state, Env & env);
+    virtual void setName(Symbol name);
+    virtual void setDocComment(DocComment docComment) { };
+    virtual PosIdx getPos() const { return noPos; }
+
+    // These are temporary methods to be used only in parser.y
+    virtual void resetCursedOr() { };
+    virtual void warnIfCursedOr(const SymbolTable & symbols, const PosTable & positions) { };
+};
+
+#define COMMON_METHODS \
+    void show(const SymbolTable & symbols, std::ostream & str) const override; \
+    void eval(EvalState & state, Env & env, Value & v) override; \
+    void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env) override;
+
+struct ExprInt : Expr
+{
+    Value v;
+    ExprInt(NixInt n) { v.mkInt(n); };
+    ExprInt(NixInt::Inner n) { v.mkInt(n); };
+    Value * maybeThunk(EvalState & state, Env & env) override;
+    COMMON_METHODS
+};
+
+struct ExprFloat : Expr
+{
+    Value v;
+    ExprFloat(NixFloat nf) { v.mkFloat(nf); };
+    Value * maybeThunk(EvalState & state, Env & env) override;
+    COMMON_METHODS
+};
+
+struct ExprString : Expr
+{
+    std::string s;
+    Value v;
+    ExprString(std::string &&s) : s(std::move(s)) { v.mkString(this->s.data()); };
+    Value * maybeThunk(EvalState & state, Env & env) override;
+    COMMON_METHODS
+};
+
+struct ExprPath : Expr
+{
+    ref<SourceAccessor> accessor;
+    std::string s;
+    Value v;
+    ExprPath(ref<SourceAccessor> accessor, std::string s) : accessor(accessor), s(std::move(s))
+    {
+        v.mkPath(&*accessor, this->s.c_str());
+    }
+    Value * maybeThunk(EvalState & state, Env & env) override;
+    COMMON_METHODS
+};
+
+typedef uint32_t Level;
+typedef uint32_t Displacement;
+
+struct ExprVar : Expr
+{
+    PosIdx pos;
+    Symbol name;
+
+    /* Whether the variable comes from an environment (e.g. a rec, let
+       or function argument) or from a "with".
+
+       `nullptr`: Not from a `with`.
+       Valid pointer: the nearest, innermost `with` expression to query first. */
+    ExprWith * fromWith;
+
+    /* In the former case, the value is obtained by going `level`
+       levels up from the current environment and getting the
+       `displ`th value in that environment.  In the latter case, the
+       value is obtained by getting the attribute named `name` from
+       the set stored in the environment that is `level` levels up
+       from the current one.*/
+    Level level;
+    Displacement displ;
+
+    ExprVar(Symbol name) : name(name) { };
+    ExprVar(const PosIdx & pos, Symbol name) : pos(pos), name(name) { };
+    Value * maybeThunk(EvalState & state, Env & env) override;
+    PosIdx getPos() const override { return pos; }
+    COMMON_METHODS
+};
+
+/**
+ * A pseudo-expression for the purpose of evaluating the `from` expression in `inherit (from)` syntax.
+ * Unlike normal variable references, the displacement is set during parsing, and always refers to
+ * `ExprAttrs::inheritFromExprs` (by itself or in `ExprLet`), whose values are put into their own `Env`.
+ */
+struct ExprInheritFrom : ExprVar
+{
+    ExprInheritFrom(PosIdx pos, Displacement displ): ExprVar(pos, {})
+    {
+        this->level = 0;
+        this->displ = displ;
+        this->fromWith = nullptr;
+    }
+
+    void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env) override;
+};
+
+struct ExprSelect : Expr
+{
+    PosIdx pos;
+    Expr * e, * def;
+    AttrPath attrPath;
+    ExprSelect(const PosIdx & pos, Expr * e, AttrPath attrPath, Expr * def) : pos(pos), e(e), def(def), attrPath(std::move(attrPath)) { };
+    ExprSelect(const PosIdx & pos, Expr * e, Symbol name) : pos(pos), e(e), def(0) { attrPath.push_back(AttrName(name)); };
+    PosIdx getPos() const override { return pos; }
+
+    /**
+     * Evaluate the `a.b.c` part of `a.b.c.d`. This exists mostly for the purpose of :doc in the repl.
+     *
+     * @param[out] v The attribute set that should contain the last attribute name (if it exists).
+     * @return The last attribute name in `attrPath`
+     *
+     * @note This does *not* evaluate the final attribute, and does not fail if that's the only attribute that does not exist.
+     */
+    Symbol evalExceptFinalSelect(EvalState & state, Env & env, Value & attrs);
+
+    COMMON_METHODS
+};
+
+struct ExprOpHasAttr : Expr
+{
+    Expr * e;
+    AttrPath attrPath;
+    ExprOpHasAttr(Expr * e, AttrPath attrPath) : e(e), attrPath(std::move(attrPath)) { };
+    PosIdx getPos() const override { return e->getPos(); }
+    COMMON_METHODS
+};
+
+struct ExprAttrs : Expr
+{
+    bool recursive;
+    PosIdx pos;
+    struct AttrDef {
+        enum class Kind {
+            /** `attr = expr;` */
+            Plain,
+            /** `inherit attr1 attrn;` */
+            Inherited,
+            /** `inherit (expr) attr1 attrn;` */
+            InheritedFrom,
+        };
+
+        Kind kind;
+        Expr * e;
+        PosIdx pos;
+        Displacement displ; // displacement
+        AttrDef(Expr * e, const PosIdx & pos, Kind kind = Kind::Plain)
+            : kind(kind), e(e), pos(pos) { };
+        AttrDef() { };
+
+        template<typename T>
+        const T & chooseByKind(const T & plain, const T & inherited, const T & inheritedFrom) const
+        {
+            switch (kind) {
+            case Kind::Plain:
+                return plain;
+            case Kind::Inherited:
+                return inherited;
+            default:
+            case Kind::InheritedFrom:
+                return inheritedFrom;
+            }
+        }
+    };
+    typedef std::map<Symbol, AttrDef> AttrDefs;
+    AttrDefs attrs;
+    std::unique_ptr<std::vector<Expr *>> inheritFromExprs;
+    struct DynamicAttrDef {
+        Expr * nameExpr, * valueExpr;
+        PosIdx pos;
+        DynamicAttrDef(Expr * nameExpr, Expr * valueExpr, const PosIdx & pos)
+            : nameExpr(nameExpr), valueExpr(valueExpr), pos(pos) { };
+    };
+    typedef std::vector<DynamicAttrDef> DynamicAttrDefs;
+    DynamicAttrDefs dynamicAttrs;
+    ExprAttrs(const PosIdx &pos) : recursive(false), pos(pos) { };
+    ExprAttrs() : recursive(false) { };
+    PosIdx getPos() const override { return pos; }
+    COMMON_METHODS
+
+    std::shared_ptr<const StaticEnv> bindInheritSources(
+        EvalState & es, const std::shared_ptr<const StaticEnv> & env);
+    Env * buildInheritFromEnv(EvalState & state, Env & up);
+    void showBindings(const SymbolTable & symbols, std::ostream & str) const;
+};
+
+struct ExprList : Expr
+{
+    std::vector<Expr *> elems;
+    ExprList() { };
+    COMMON_METHODS
+    Value * maybeThunk(EvalState & state, Env & env) override;
+
+    PosIdx getPos() const override
+    {
+        return elems.empty() ? noPos : elems.front()->getPos();
+    }
+};
+
+struct Formal
+{
+    PosIdx pos;
+    Symbol name;
+    Expr * def;
+};
+
+struct Formals
+{
+    typedef std::vector<Formal> Formals_;
+    Formals_ formals;
+    bool ellipsis;
+
+    bool has(Symbol arg) const
+    {
+        auto it = std::lower_bound(formals.begin(), formals.end(), arg,
+            [] (const Formal & f, const Symbol & sym) { return f.name < sym; });
+        return it != formals.end() && it->name == arg;
+    }
+
+    std::vector<Formal> lexicographicOrder(const SymbolTable & symbols) const
+    {
+        std::vector<Formal> result(formals.begin(), formals.end());
+        std::sort(result.begin(), result.end(),
+            [&] (const Formal & a, const Formal & b) {
+                std::string_view sa = symbols[a.name], sb = symbols[b.name];
+                return sa < sb;
+            });
+        return result;
+    }
+};
+
+struct ExprLambda : Expr
+{
+    PosIdx pos;
+    Symbol name;
+    Symbol arg;
+    Formals * formals;
+    Expr * body;
+    DocComment docComment;
+
+    ExprLambda(PosIdx pos, Symbol arg, Formals * formals, Expr * body)
+        : pos(pos), arg(arg), formals(formals), body(body)
+    {
+    };
+    ExprLambda(PosIdx pos, Formals * formals, Expr * body)
+        : pos(pos), formals(formals), body(body)
+    {
+    }
+    void setName(Symbol name) override;
+    std::string showNamePos(const EvalState & state) const;
+    inline bool hasFormals() const { return formals != nullptr; }
+    PosIdx getPos() const override { return pos; }
+    virtual void setDocComment(DocComment docComment) override;
+    COMMON_METHODS
+};
+
+struct ExprCall : Expr
+{
+    Expr * fun;
+    std::vector<Expr *> args;
+    PosIdx pos;
+    std::optional<PosIdx> cursedOrEndPos; // used during parsing to warn about https://github.com/NixOS/nix/issues/11118
+    ExprCall(const PosIdx & pos, Expr * fun, std::vector<Expr *> && args)
+        : fun(fun), args(args), pos(pos), cursedOrEndPos({})
+    { }
+    ExprCall(const PosIdx & pos, Expr * fun, std::vector<Expr *> && args, PosIdx && cursedOrEndPos)
+        : fun(fun), args(args), pos(pos), cursedOrEndPos(cursedOrEndPos)
+    { }
+    PosIdx getPos() const override { return pos; }
+    virtual void resetCursedOr() override;
+    virtual void warnIfCursedOr(const SymbolTable & symbols, const PosTable & positions) override;
+    COMMON_METHODS
+};
+
+struct ExprLet : Expr
+{
+    ExprAttrs * attrs;
+    Expr * body;
+    ExprLet(ExprAttrs * attrs, Expr * body) : attrs(attrs), body(body) { };
+    COMMON_METHODS
+};
+
+struct ExprWith : Expr
+{
+    PosIdx pos;
+    Expr * attrs, * body;
+    size_t prevWith;
+    ExprWith * parentWith;
+    ExprWith(const PosIdx & pos, Expr * attrs, Expr * body) : pos(pos), attrs(attrs), body(body) { };
+    PosIdx getPos() const override { return pos; }
+    COMMON_METHODS
+};
+
+struct ExprIf : Expr
+{
+    PosIdx pos;
+    Expr * cond, * then, * else_;
+    ExprIf(const PosIdx & pos, Expr * cond, Expr * then, Expr * else_) : pos(pos), cond(cond), then(then), else_(else_) { };
+    PosIdx getPos() const override { return pos; }
+    COMMON_METHODS
+};
+
+struct ExprAssert : Expr
+{
+    PosIdx pos;
+    Expr * cond, * body;
+    ExprAssert(const PosIdx & pos, Expr * cond, Expr * body) : pos(pos), cond(cond), body(body) { };
+    PosIdx getPos() const override { return pos; }
+    COMMON_METHODS
+};
+
+struct ExprOpNot : Expr
+{
+    Expr * e;
+    ExprOpNot(Expr * e) : e(e) { };
+    PosIdx getPos() const override { return e->getPos(); }
+    COMMON_METHODS
+};
+
+#define MakeBinOp(name, s) \
+    struct name : Expr \
+    { \
+        PosIdx pos; \
+        Expr * e1, * e2; \
+        name(Expr * e1, Expr * e2) : e1(e1), e2(e2) { }; \
+        name(const PosIdx & pos, Expr * e1, Expr * e2) : pos(pos), e1(e1), e2(e2) { }; \
+        void show(const SymbolTable & symbols, std::ostream & str) const override \
+        { \
+            str << "("; e1->show(symbols, str); str << " " s " "; e2->show(symbols, str); str << ")"; \
+        } \
+        void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env) override \
+        { \
+            e1->bindVars(es, env); e2->bindVars(es, env);    \
+        } \
+        void eval(EvalState & state, Env & env, Value & v) override; \
+        PosIdx getPos() const override { return pos; } \
+    };
+
+MakeBinOp(ExprOpEq, "==")
+MakeBinOp(ExprOpNEq, "!=")
+MakeBinOp(ExprOpAnd, "&&")
+MakeBinOp(ExprOpOr, "||")
+MakeBinOp(ExprOpImpl, "->")
+MakeBinOp(ExprOpUpdate, "//")
+MakeBinOp(ExprOpConcatLists, "++")
+
+struct ExprConcatStrings : Expr
+{
+    PosIdx pos;
+    bool forceString;
+    std::vector<std::pair<PosIdx, Expr *>> * es;
+    ExprConcatStrings(const PosIdx & pos, bool forceString, std::vector<std::pair<PosIdx, Expr *>> * es)
+        : pos(pos), forceString(forceString), es(es) { };
+    PosIdx getPos() const override { return pos; }
+    COMMON_METHODS
+};
+
+struct ExprPos : Expr
+{
+    PosIdx pos;
+    ExprPos(const PosIdx & pos) : pos(pos) { };
+    PosIdx getPos() const override { return pos; }
+    COMMON_METHODS
+};
+
+/* only used to mark thunks as black holes. */
+struct ExprBlackHole : Expr
+{
+    void show(const SymbolTable & symbols, std::ostream & str) const override {}
+    void eval(EvalState & state, Env & env, Value & v) override;
+    void bindVars(EvalState & es, const std::shared_ptr<const StaticEnv> & env) override {}
+};
+
+extern ExprBlackHole eBlackHole;
+
+
+/* Static environments are used to map variable names onto (level,
+   displacement) pairs used to obtain the value of the variable at
+   runtime. */
+struct StaticEnv
+{
+    ExprWith * isWith;
+    const StaticEnv * up;
+
+    // Note: these must be in sorted order.
+    typedef std::vector<std::pair<Symbol, Displacement>> Vars;
+    Vars vars;
+
+    StaticEnv(ExprWith * isWith, const StaticEnv * up, size_t expectedSize = 0) : isWith(isWith), up(up) {
+        vars.reserve(expectedSize);
+    };
+
+    void sort()
+    {
+        std::stable_sort(vars.begin(), vars.end(),
+            [](const Vars::value_type & a, const Vars::value_type & b) { return a.first < b.first; });
+    }
+
+    void deduplicate()
+    {
+        auto it = vars.begin(), jt = it, end = vars.end();
+        while (jt != end) {
+            *it = *jt++;
+            while (jt != end && it->first == jt->first) *it = *jt++;
+            it++;
+        }
+        vars.erase(it, end);
+    }
+
+    Vars::const_iterator find(Symbol name) const
+    {
+        Vars::value_type key(name, 0);
+        auto i = std::lower_bound(vars.begin(), vars.end(), key);
+        if (i != vars.end() && i->first == name) return i;
+        return vars.end();
+    }
+};
+
+
+}

subprojects/libexpr/package.nix

@@ -0,0 +1,113 @@
+{ lib
+, stdenv
+, mkMesonDerivation
+, releaseTools
+
+, meson
+, ninja
+, pkg-config
+, bison
+, flex
+, cmake # for resolving toml11 dep
+
+, nix-util
+, nix-store
+, nix-fetchers
+, boost
+, boehmgc
+, nlohmann_json
+, toml11
+
+# Configuration Options
+
+, version
+
+# Whether to use garbage collection for the Nix language evaluator.
+#
+# If it is disabled, we just leak memory, but this is not as bad as it
+# sounds so long as evaluation just takes places within short-lived
+# processes. (When the process exits, the memory is reclaimed; it is
+# only leaked *within* the process.)
+#
+# Temporarily disabled on Windows because the `GC_throw_bad_alloc`
+# symbol is missing during linking.
+, enableGC ? !stdenv.hostPlatform.isWindows
+}:
+
+let
+  inherit (lib) fileset;
+in
+
+mkMesonDerivation (finalAttrs: {
+  pname = "nix-expr";
+  inherit version;
+
+  workDir = ./.;
+  fileset = fileset.unions [
+    ../../build-utils-meson
+    ./build-utils-meson
+    ../../.version
+    ./.version
+    ./meson.build
+    ./meson.options
+    ./primops/meson.build
+    (fileset.fileFilter (file: file.hasExt "cc") ./.)
+    (fileset.fileFilter (file: file.hasExt "hh") ./.)
+    ./lexer.l
+    ./parser.y
+    (fileset.fileFilter (file: file.hasExt "nix") ./.)
+  ];
+
+  outputs = [ "out" "dev" ];
+
+  nativeBuildInputs = [
+    meson
+    ninja
+    pkg-config
+    bison
+    flex
+    cmake
+  ];
+
+  buildInputs = [
+    toml11
+  ];
+
+  propagatedBuildInputs = [
+    nix-util
+    nix-store
+    nix-fetchers
+    boost
+    nlohmann_json
+  ] ++ lib.optional enableGC boehmgc;
+
+  preConfigure =
+    # "Inline" .version so it's not a symlink, and includes the suffix.
+    # Do the meson utils, without modification.
+    ''
+      chmod u+w ./.version
+      echo ${version} > ../../.version
+    '';
+
+  mesonFlags = [
+    (lib.mesonEnable "gc" enableGC)
+  ];
+
+  env = {
+    # Needed for Meson to find Boost.
+    # https://github.com/NixOS/nixpkgs/issues/86131.
+    BOOST_INCLUDEDIR = "${lib.getDev boost}/include";
+    BOOST_LIBRARYDIR = "${lib.getLib boost}/lib";
+  } // lib.optionalAttrs (stdenv.isLinux && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")) {
+    LDFLAGS = "-fuse-ld=gold";
+  };
+
+  separateDebugInfo = !stdenv.hostPlatform.isStatic;
+
+  hardeningDisable = lib.optional stdenv.hostPlatform.isStatic "pie";
+
+  meta = {
+    platforms = lib.platforms.unix ++ lib.platforms.windows;
+  };
+
+})

subprojects/libexpr/parser-state.hh

@@ -0,0 +1,338 @@
+#pragma once
+///@file
+
+#include <limits>
+
+#include "eval.hh"
+
+namespace nix {
+
+/**
+ * @note Storing a C-style `char *` and `size_t` allows us to avoid
+ * having to define the special members that using string_view here
+ * would implicitly delete.
+ */
+struct StringToken
+{
+    const char * p;
+    size_t l;
+    bool hasIndentation;
+    operator std::string_view() const { return {p, l}; }
+};
+
+// This type must be trivially copyable; see YYLTYPE_IS_TRIVIAL in parser.y.
+struct ParserLocation
+{
+    int beginOffset;
+    int endOffset;
+
+    // backup to recover from yyless(0)
+    int stashedBeginOffset, stashedEndOffset;
+
+    void stash() {
+        stashedBeginOffset = beginOffset;
+        stashedEndOffset = endOffset;
+    }
+
+    void unstash() {
+        beginOffset = stashedBeginOffset;
+        endOffset = stashedEndOffset;
+    }
+
+    /** Latest doc comment position, or 0. */
+    int doc_comment_first_column, doc_comment_last_column;
+};
+
+struct LexerState
+{
+    /**
+     * Tracks the distance to the last doc comment, in terms of lexer tokens.
+     *
+     * The lexer sets this to 0 when reading a doc comment, and increments it
+     * for every matched rule; see `lexer-helpers.cc`.
+     * Whitespace and comment rules decrement the distance, so that they result
+     * in a net 0 change in distance.
+     */
+    int docCommentDistance = std::numeric_limits<int>::max();
+
+    /**
+     * The location of the last doc comment.
+     *
+     * (stashing fields are not used)
+     */
+    ParserLocation lastDocCommentLoc;
+
+    /**
+     * @brief Maps some positions to a DocComment, where the comment is relevant to the location.
+     */
+    std::unordered_map<PosIdx, DocComment> & positionToDocComment;
+
+    PosTable & positions;
+    PosTable::Origin origin;
+
+    PosIdx at(const ParserLocation & loc);
+};
+
+struct ParserState
+{
+    const LexerState & lexerState;
+    SymbolTable & symbols;
+    PosTable & positions;
+    Expr * result;
+    SourcePath basePath;
+    PosTable::Origin origin;
+    const ref<SourceAccessor> rootFS;
+    const Expr::AstSymbols & s;
+    const EvalSettings & settings;
+
+    void dupAttr(const AttrPath & attrPath, const PosIdx pos, const PosIdx prevPos);
+    void dupAttr(Symbol attr, const PosIdx pos, const PosIdx prevPos);
+    void addAttr(ExprAttrs * attrs, AttrPath && attrPath, const ParserLocation & loc, Expr * e, const ParserLocation & exprLoc);
+    Formals * validateFormals(Formals * formals, PosIdx pos = noPos, Symbol arg = {});
+    Expr * stripIndentation(const PosIdx pos,
+        std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>> && es);
+    PosIdx at(const ParserLocation & loc);
+};
+
+inline void ParserState::dupAttr(const AttrPath & attrPath, const PosIdx pos, const PosIdx prevPos)
+{
+    throw ParseError({
+         .msg = HintFmt("attribute '%1%' already defined at %2%",
+             showAttrPath(symbols, attrPath), positions[prevPos]),
+         .pos = positions[pos]
+    });
+}
+
+inline void ParserState::dupAttr(Symbol attr, const PosIdx pos, const PosIdx prevPos)
+{
+    throw ParseError({
+        .msg = HintFmt("attribute '%1%' already defined at %2%", symbols[attr], positions[prevPos]),
+        .pos = positions[pos]
+    });
+}
+
+inline void ParserState::addAttr(ExprAttrs * attrs, AttrPath && attrPath, const ParserLocation & loc, Expr * e, const ParserLocation & exprLoc)
+{
+    AttrPath::iterator i;
+    // All attrpaths have at least one attr
+    assert(!attrPath.empty());
+    auto pos = at(loc);
+    // Checking attrPath validity.
+    // ===========================
+    for (i = attrPath.begin(); i + 1 < attrPath.end(); i++) {
+        if (i->symbol) {
+            ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
+            if (j != attrs->attrs.end()) {
+                if (j->second.kind != ExprAttrs::AttrDef::Kind::Inherited) {
+                    ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
+                    if (!attrs2) dupAttr(attrPath, pos, j->second.pos);
+                    attrs = attrs2;
+                } else
+                    dupAttr(attrPath, pos, j->second.pos);
+            } else {
+                ExprAttrs * nested = new ExprAttrs;
+                attrs->attrs[i->symbol] = ExprAttrs::AttrDef(nested, pos);
+                attrs = nested;
+            }
+        } else {
+            ExprAttrs *nested = new ExprAttrs;
+            attrs->dynamicAttrs.push_back(ExprAttrs::DynamicAttrDef(i->expr, nested, pos));
+            attrs = nested;
+        }
+    }
+    // Expr insertion.
+    // ==========================
+    if (i->symbol) {
+        ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
+        if (j != attrs->attrs.end()) {
+            // This attr path is already defined. However, if both
+            // e and the expr pointed by the attr path are two attribute sets,
+            // we want to merge them.
+            // Otherwise, throw an error.
+            auto ae = dynamic_cast<ExprAttrs *>(e);
+            auto jAttrs = dynamic_cast<ExprAttrs *>(j->second.e);
+            if (jAttrs && ae) {
+                if (ae->inheritFromExprs && !jAttrs->inheritFromExprs)
+                    jAttrs->inheritFromExprs = std::make_unique<std::vector<Expr *>>();
+                for (auto & ad : ae->attrs) {
+                    auto j2 = jAttrs->attrs.find(ad.first);
+                    if (j2 != jAttrs->attrs.end()) // Attr already defined in iAttrs, error.
+                        dupAttr(ad.first, j2->second.pos, ad.second.pos);
+                    jAttrs->attrs.emplace(ad.first, ad.second);
+                    if (ad.second.kind == ExprAttrs::AttrDef::Kind::InheritedFrom) {
+                        auto & sel = dynamic_cast<ExprSelect &>(*ad.second.e);
+                        auto & from = dynamic_cast<ExprInheritFrom &>(*sel.e);
+                        from.displ += jAttrs->inheritFromExprs->size();
+                    }
+                }
+                jAttrs->dynamicAttrs.insert(jAttrs->dynamicAttrs.end(), ae->dynamicAttrs.begin(), ae->dynamicAttrs.end());
+                if (ae->inheritFromExprs) {
+                    jAttrs->inheritFromExprs->insert(jAttrs->inheritFromExprs->end(),
+                        ae->inheritFromExprs->begin(), ae->inheritFromExprs->end());
+                }
+            } else {
+                dupAttr(attrPath, pos, j->second.pos);
+            }
+        } else {
+            // This attr path is not defined. Let's create it.
+            attrs->attrs.emplace(i->symbol, ExprAttrs::AttrDef(e, pos));
+            e->setName(i->symbol);
+        }
+    } else {
+        attrs->dynamicAttrs.push_back(ExprAttrs::DynamicAttrDef(i->expr, e, pos));
+    }
+
+    auto it = lexerState.positionToDocComment.find(pos);
+    if (it != lexerState.positionToDocComment.end()) {
+        e->setDocComment(it->second);
+        lexerState.positionToDocComment.emplace(at(exprLoc), it->second);
+    }
+}
+
+inline Formals * ParserState::validateFormals(Formals * formals, PosIdx pos, Symbol arg)
+{
+    std::sort(formals->formals.begin(), formals->formals.end(),
+        [] (const auto & a, const auto & b) {
+            return std::tie(a.name, a.pos) < std::tie(b.name, b.pos);
+        });
+
+    std::optional<std::pair<Symbol, PosIdx>> duplicate;
+    for (size_t i = 0; i + 1 < formals->formals.size(); i++) {
+        if (formals->formals[i].name != formals->formals[i + 1].name)
+            continue;
+        std::pair thisDup{formals->formals[i].name, formals->formals[i + 1].pos};
+        duplicate = std::min(thisDup, duplicate.value_or(thisDup));
+    }
+    if (duplicate)
+        throw ParseError({
+            .msg = HintFmt("duplicate formal function argument '%1%'", symbols[duplicate->first]),
+            .pos = positions[duplicate->second]
+        });
+
+    if (arg && formals->has(arg))
+        throw ParseError({
+            .msg = HintFmt("duplicate formal function argument '%1%'", symbols[arg]),
+            .pos = positions[pos]
+        });
+
+    return formals;
+}
+
+inline Expr * ParserState::stripIndentation(const PosIdx pos,
+    std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>> && es)
+{
+    if (es.empty()) return new ExprString("");
+
+    /* Figure out the minimum indentation.  Note that by design
+       whitespace-only final lines are not taken into account.  (So
+       the " " in "\n ''" is ignored, but the " " in "\n foo''" is.) */
+    bool atStartOfLine = true; /* = seen only whitespace in the current line */
+    size_t minIndent = 1000000;
+    size_t curIndent = 0;
+    for (auto & [i_pos, i] : es) {
+        auto * str = std::get_if<StringToken>(&i);
+        if (!str || !str->hasIndentation) {
+            /* Anti-quotations and escaped characters end the current start-of-line whitespace. */
+            if (atStartOfLine) {
+                atStartOfLine = false;
+                if (curIndent < minIndent) minIndent = curIndent;
+            }
+            continue;
+        }
+        for (size_t j = 0; j < str->l; ++j) {
+            if (atStartOfLine) {
+                if (str->p[j] == ' ')
+                    curIndent++;
+                else if (str->p[j] == '\n') {
+                    /* Empty line, doesn't influence minimum
+                       indentation. */
+                    curIndent = 0;
+                } else {
+                    atStartOfLine = false;
+                    if (curIndent < minIndent) minIndent = curIndent;
+                }
+            } else if (str->p[j] == '\n') {
+                atStartOfLine = true;
+                curIndent = 0;
+            }
+        }
+    }
+
+    /* Strip spaces from each line. */
+    auto * es2 = new std::vector<std::pair<PosIdx, Expr *>>;
+    atStartOfLine = true;
+    size_t curDropped = 0;
+    size_t n = es.size();
+    auto i = es.begin();
+    const auto trimExpr = [&] (Expr * e) {
+        atStartOfLine = false;
+        curDropped = 0;
+        es2->emplace_back(i->first, e);
+    };
+    const auto trimString = [&] (const StringToken & t) {
+        std::string s2;
+        for (size_t j = 0; j < t.l; ++j) {
+            if (atStartOfLine) {
+                if (t.p[j] == ' ') {
+                    if (curDropped++ >= minIndent)
+                        s2 += t.p[j];
+                }
+                else if (t.p[j] == '\n') {
+                    curDropped = 0;
+                    s2 += t.p[j];
+                } else {
+                    atStartOfLine = false;
+                    curDropped = 0;
+                    s2 += t.p[j];
+                }
+            } else {
+                s2 += t.p[j];
+                if (t.p[j] == '\n') atStartOfLine = true;
+            }
+        }
+
+        /* Remove the last line if it is empty and consists only of
+           spaces. */
+        if (n == 1) {
+            std::string::size_type p = s2.find_last_of('\n');
+            if (p != std::string::npos && s2.find_first_not_of(' ', p + 1) == std::string::npos)
+                s2 = std::string(s2, 0, p + 1);
+        }
+
+        // Ignore empty strings for a minor optimisation and AST simplification
+        if (s2 != "") {
+            es2->emplace_back(i->first, new ExprString(std::move(s2)));
+        }
+    };
+    for (; i != es.end(); ++i, --n) {
+        std::visit(overloaded { trimExpr, trimString }, i->second);
+    }
+
+    // If there is nothing at all, return the empty string directly.
+    // This also ensures that equivalent empty strings result in the same ast, which is helpful when testing formatters.
+    if (es2->size() == 0) {
+        auto *const result = new ExprString("");
+        delete es2;
+        return result;
+    }
+
+    /* If this is a single string, then don't do a concatenation. */
+    if (es2->size() == 1 && dynamic_cast<ExprString *>((*es2)[0].second)) {
+        auto *const result = (*es2)[0].second;
+        delete es2;
+        return result;
+    }
+    return new ExprConcatStrings(pos, true, es2);
+}
+
+inline PosIdx LexerState::at(const ParserLocation & loc)
+{
+    return positions.add(origin, loc.beginOffset);
+}
+
+inline PosIdx ParserState::at(const ParserLocation & loc)
+{
+    return positions.add(origin, loc.beginOffset);
+}
+
+}

subprojects/libexpr/parser.y

@@ -0,0 +1,554 @@
+%define api.location.type { ::nix::ParserLocation }
+%define api.pure
+%locations
+%define parse.error verbose
+%defines
+/* %no-lines */
+%parse-param { void * scanner }
+%parse-param { nix::ParserState * state }
+%lex-param { void * scanner }
+%lex-param { nix::ParserState * state }
+%expect 0
+
+%code requires {
+
+#ifndef BISON_HEADER
+#define BISON_HEADER
+
+#include <variant>
+
+#include "finally.hh"
+#include "util.hh"
+#include "users.hh"
+
+#include "nixexpr.hh"
+#include "eval.hh"
+#include "eval-settings.hh"
+#include "parser-state.hh"
+
+// Bison seems to have difficulty growing the parser stack when using C++ with
+// a custom location type. This undocumented macro tells Bison that our
+// location type is "trivially copyable" in C++-ese, so it is safe to use the
+// same memcpy macro it uses to grow the stack that it uses with its own
+// default location type. Without this, we get "error: memory exhausted" when
+// parsing some large Nix files. Our other options are to increase the initial
+// stack size (200 by default) to be as large as we ever want to support (so
+// that growing the stack is unnecessary), or redefine the stack-relocation
+// macro ourselves (which is also undocumented).
+#define YYLTYPE_IS_TRIVIAL 1
+
+#define YY_DECL int yylex \
+    (YYSTYPE * yylval_param, YYLTYPE * yylloc_param, yyscan_t yyscanner, nix::ParserState * state)
+
+// For efficiency, we only track offsets; not line,column coordinates
+# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
+    do                                                                  \
+      if (N)                                                            \
+        {                                                               \
+          (Current).beginOffset = YYRHSLOC (Rhs, 1).beginOffset;        \
+          (Current).endOffset  = YYRHSLOC (Rhs, N).endOffset;           \
+        }                                                               \
+      else                                                              \
+        {                                                               \
+          (Current).beginOffset = (Current).endOffset =                 \
+            YYRHSLOC (Rhs, 0).endOffset;                                \
+        }                                                               \
+    while (0)
+
+namespace nix {
+
+typedef std::unordered_map<PosIdx, DocComment> DocCommentMap;
+
+Expr * parseExprFromBuf(
+    char * text,
+    size_t length,
+    Pos::Origin origin,
+    const SourcePath & basePath,
+    SymbolTable & symbols,
+    const EvalSettings & settings,
+    PosTable & positions,
+    DocCommentMap & docComments,
+    const ref<SourceAccessor> rootFS,
+    const Expr::AstSymbols & astSymbols);
+
+}
+
+#endif
+
+}
+
+%{
+
+#include "parser-tab.hh"
+#include "lexer-tab.hh"
+
+YY_DECL;
+
+using namespace nix;
+
+#define CUR_POS state->at(yyloc)
+
+
+void yyerror(YYLTYPE * loc, yyscan_t scanner, ParserState * state, const char * error)
+{
+    if (std::string_view(error).starts_with("syntax error, unexpected end of file")) {
+        loc->beginOffset = loc->endOffset;
+    }
+    throw ParseError({
+        .msg = HintFmt(error),
+        .pos = state->positions[state->at(*loc)]
+    });
+}
+
+#define SET_DOC_POS(lambda, pos) setDocPosition(state->lexerState, lambda, state->at(pos))
+static void setDocPosition(const LexerState & lexerState, ExprLambda * lambda, PosIdx start) {
+    auto it = lexerState.positionToDocComment.find(start);
+    if (it != lexerState.positionToDocComment.end()) {
+        lambda->setDocComment(it->second);
+    }
+}
+
+static Expr * makeCall(PosIdx pos, Expr * fn, Expr * arg) {
+    if (auto e2 = dynamic_cast<ExprCall *>(fn)) {
+        e2->args.push_back(arg);
+        return fn;
+    }
+    return new ExprCall(pos, fn, {arg});
+}
+
+
+%}
+
+%union {
+  // !!! We're probably leaking stuff here.
+  nix::Expr * e;
+  nix::ExprList * list;
+  nix::ExprAttrs * attrs;
+  nix::Formals * formals;
+  nix::Formal * formal;
+  nix::NixInt n;
+  nix::NixFloat nf;
+  nix::StringToken id; // !!! -> Symbol
+  nix::StringToken path;
+  nix::StringToken uri;
+  nix::StringToken str;
+  std::vector<nix::AttrName> * attrNames;
+  std::vector<std::pair<nix::AttrName, nix::PosIdx>> * inheritAttrs;
+  std::vector<std::pair<nix::PosIdx, nix::Expr *>> * string_parts;
+  std::vector<std::pair<nix::PosIdx, std::variant<nix::Expr *, nix::StringToken>>> * ind_string_parts;
+}
+
+%type <e> start expr expr_function expr_if expr_op
+%type <e> expr_select expr_simple expr_app
+%type <e> expr_pipe_from expr_pipe_into
+%type <list> expr_list
+%type <attrs> binds binds1
+%type <formals> formals formal_set
+%type <formal> formal
+%type <attrNames> attrpath
+%type <inheritAttrs> attrs
+%type <string_parts> string_parts_interpolated
+%type <ind_string_parts> ind_string_parts
+%type <e> path_start string_parts string_attr
+%type <id> attr
+%token <id> ID
+%token <str> STR IND_STR
+%token <n> INT_LIT
+%token <nf> FLOAT_LIT
+%token <path> PATH HPATH SPATH PATH_END
+%token <uri> URI
+%token IF THEN ELSE ASSERT WITH LET IN_KW REC INHERIT EQ NEQ AND OR IMPL OR_KW
+%token PIPE_FROM PIPE_INTO /* <| and |> */
+%token DOLLAR_CURLY /* == ${ */
+%token IND_STRING_OPEN IND_STRING_CLOSE
+%token ELLIPSIS
+
+
+%right IMPL
+%left OR
+%left AND
+%nonassoc EQ NEQ
+%nonassoc '<' '>' LEQ GEQ
+%right UPDATE
+%left NOT
+%left '+' '-'
+%left '*' '/'
+%right CONCAT
+%nonassoc '?'
+%nonassoc NEGATE
+
+%%
+
+start: expr { state->result = $1; };
+
+expr: expr_function;
+
+expr_function
+  : ID ':' expr_function
+    { auto me = new ExprLambda(CUR_POS, state->symbols.create($1), 0, $3);
+      $$ = me;
+      SET_DOC_POS(me, @1);
+    }
+  | formal_set ':' expr_function[body]
+    { auto me = new ExprLambda(CUR_POS, state->validateFormals($formal_set), $body);
+      $$ = me;
+      SET_DOC_POS(me, @1);
+    }
+  | formal_set '@' ID ':' expr_function[body]
+    {
+      auto arg = state->symbols.create($ID);
+      auto me = new ExprLambda(CUR_POS, arg, state->validateFormals($formal_set, CUR_POS, arg), $body);
+      $$ = me;
+      SET_DOC_POS(me, @1);
+    }
+  | ID '@' formal_set ':' expr_function[body]
+    {
+      auto arg = state->symbols.create($ID);
+      auto me = new ExprLambda(CUR_POS, arg, state->validateFormals($formal_set, CUR_POS, arg), $body);
+      $$ = me;
+      SET_DOC_POS(me, @1);
+    }
+  | ASSERT expr ';' expr_function
+    { $$ = new ExprAssert(CUR_POS, $2, $4); }
+  | WITH expr ';' expr_function
+    { $$ = new ExprWith(CUR_POS, $2, $4); }
+  | LET binds IN_KW expr_function
+    { if (!$2->dynamicAttrs.empty())
+        throw ParseError({
+            .msg = HintFmt("dynamic attributes not allowed in let"),
+            .pos = state->positions[CUR_POS]
+        });
+      $$ = new ExprLet($2, $4);
+    }
+  | expr_if
+  ;
+
+expr_if
+  : IF expr THEN expr ELSE expr { $$ = new ExprIf(CUR_POS, $2, $4, $6); }
+  | expr_pipe_from
+  | expr_pipe_into
+  | expr_op
+  ;
+
+expr_pipe_from
+  : expr_op PIPE_FROM expr_pipe_from { $$ = makeCall(state->at(@2), $1, $3); }
+  | expr_op PIPE_FROM expr_op        { $$ = makeCall(state->at(@2), $1, $3); }
+  ;
+
+expr_pipe_into
+  : expr_pipe_into PIPE_INTO expr_op { $$ = makeCall(state->at(@2), $3, $1); }
+  | expr_op        PIPE_INTO expr_op { $$ = makeCall(state->at(@2), $3, $1); }
+  ;
+
+expr_op
+  : '!' expr_op %prec NOT { $$ = new ExprOpNot($2); }
+  | '-' expr_op %prec NEGATE { $$ = new ExprCall(CUR_POS, new ExprVar(state->s.sub), {new ExprInt(0), $2}); }
+  | expr_op EQ expr_op { $$ = new ExprOpEq($1, $3); }
+  | expr_op NEQ expr_op { $$ = new ExprOpNEq($1, $3); }
+  | expr_op '<' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.lessThan), {$1, $3}); }
+  | expr_op LEQ expr_op { $$ = new ExprOpNot(new ExprCall(state->at(@2), new ExprVar(state->s.lessThan), {$3, $1})); }
+  | expr_op '>' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.lessThan), {$3, $1}); }
+  | expr_op GEQ expr_op { $$ = new ExprOpNot(new ExprCall(state->at(@2), new ExprVar(state->s.lessThan), {$1, $3})); }
+  | expr_op AND expr_op { $$ = new ExprOpAnd(state->at(@2), $1, $3); }
+  | expr_op OR expr_op { $$ = new ExprOpOr(state->at(@2), $1, $3); }
+  | expr_op IMPL expr_op { $$ = new ExprOpImpl(state->at(@2), $1, $3); }
+  | expr_op UPDATE expr_op { $$ = new ExprOpUpdate(state->at(@2), $1, $3); }
+  | expr_op '?' attrpath { $$ = new ExprOpHasAttr($1, std::move(*$3)); delete $3; }
+  | expr_op '+' expr_op
+    { $$ = new ExprConcatStrings(state->at(@2), false, new std::vector<std::pair<PosIdx, Expr *> >({{state->at(@1), $1}, {state->at(@3), $3}})); }
+  | expr_op '-' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.sub), {$1, $3}); }
+  | expr_op '*' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.mul), {$1, $3}); }
+  | expr_op '/' expr_op { $$ = new ExprCall(state->at(@2), new ExprVar(state->s.div), {$1, $3}); }
+  | expr_op CONCAT expr_op { $$ = new ExprOpConcatLists(state->at(@2), $1, $3); }
+  | expr_app
+  ;
+
+expr_app
+  : expr_app expr_select { $$ = makeCall(CUR_POS, $1, $2); $2->warnIfCursedOr(state->symbols, state->positions); }
+  | /* Once a ‘cursed or’ reaches this nonterminal, it is no longer cursed,
+       because the uncursed parse would also produce an expr_app. But we need
+       to remove the cursed status in order to prevent valid things like
+       `f (g or)` from triggering the warning. */
+    expr_select { $$ = $1; $$->resetCursedOr(); }
+  ;
+
+expr_select
+  : expr_simple '.' attrpath
+    { $$ = new ExprSelect(CUR_POS, $1, std::move(*$3), nullptr); delete $3; }
+  | expr_simple '.' attrpath OR_KW expr_select
+    { $$ = new ExprSelect(CUR_POS, $1, std::move(*$3), $5); delete $3; $5->warnIfCursedOr(state->symbols, state->positions); }
+  | /* Backwards compatibility: because Nixpkgs has a function named ‘or’,
+       allow stuff like ‘map or [...]’. This production is problematic (see
+       https://github.com/NixOS/nix/issues/11118) and will be refactored in the
+       future by treating `or` as a regular identifier. The refactor will (in
+       very rare cases, we think) change the meaning of expressions, so we mark
+       the ExprCall with data (establishing that it is a ‘cursed or’) that can
+       be used to emit a warning when an affected expression is parsed. */
+    expr_simple OR_KW
+    { $$ = new ExprCall(CUR_POS, $1, {new ExprVar(CUR_POS, state->s.or_)}, state->positions.add(state->origin, @$.endOffset)); }
+  | expr_simple
+  ;
+
+expr_simple
+  : ID {
+      std::string_view s = "__curPos";
+      if ($1.l == s.size() && strncmp($1.p, s.data(), s.size()) == 0)
+          $$ = new ExprPos(CUR_POS);
+      else
+          $$ = new ExprVar(CUR_POS, state->symbols.create($1));
+  }
+  | INT_LIT { $$ = new ExprInt($1); }
+  | FLOAT_LIT { $$ = new ExprFloat($1); }
+  | '"' string_parts '"' { $$ = $2; }
+  | IND_STRING_OPEN ind_string_parts IND_STRING_CLOSE {
+      $$ = state->stripIndentation(CUR_POS, std::move(*$2));
+      delete $2;
+  }
+  | path_start PATH_END
+  | path_start string_parts_interpolated PATH_END {
+      $2->insert($2->begin(), {state->at(@1), $1});
+      $$ = new ExprConcatStrings(CUR_POS, false, $2);
+  }
+  | SPATH {
+      std::string path($1.p + 1, $1.l - 2);
+      $$ = new ExprCall(CUR_POS,
+          new ExprVar(state->s.findFile),
+          {new ExprVar(state->s.nixPath),
+           new ExprString(std::move(path))});
+  }
+  | URI {
+      static bool noURLLiterals = experimentalFeatureSettings.isEnabled(Xp::NoUrlLiterals);
+      if (noURLLiterals)
+          throw ParseError({
+              .msg = HintFmt("URL literals are disabled"),
+              .pos = state->positions[CUR_POS]
+          });
+      $$ = new ExprString(std::string($1));
+  }
+  | '(' expr ')' { $$ = $2; }
+  /* Let expressions `let {..., body = ...}' are just desugared
+     into `(rec {..., body = ...}).body'. */
+  | LET '{' binds '}'
+    { $3->recursive = true; $3->pos = CUR_POS; $$ = new ExprSelect(noPos, $3, state->s.body); }
+  | REC '{' binds '}'
+    { $3->recursive = true; $3->pos = CUR_POS; $$ = $3; }
+  | '{' binds1 '}'
+    { $2->pos = CUR_POS; $$ = $2; }
+  | '{' '}'
+    { $$ = new ExprAttrs(CUR_POS); }
+  | '[' expr_list ']' { $$ = $2; }
+  ;
+
+string_parts
+  : STR { $$ = new ExprString(std::string($1)); }
+  | string_parts_interpolated { $$ = new ExprConcatStrings(CUR_POS, true, $1); }
+  | { $$ = new ExprString(""); }
+  ;
+
+string_parts_interpolated
+  : string_parts_interpolated STR
+  { $$ = $1; $1->emplace_back(state->at(@2), new ExprString(std::string($2))); }
+  | string_parts_interpolated DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(state->at(@2), $3); }
+  | DOLLAR_CURLY expr '}' { $$ = new std::vector<std::pair<PosIdx, Expr *>>; $$->emplace_back(state->at(@1), $2); }
+  | STR DOLLAR_CURLY expr '}' {
+      $$ = new std::vector<std::pair<PosIdx, Expr *>>;
+      $$->emplace_back(state->at(@1), new ExprString(std::string($1)));
+      $$->emplace_back(state->at(@2), $3);
+    }
+  ;
+
+path_start
+  : PATH {
+    Path path(absPath(std::string_view{$1.p, $1.l}, state->basePath.path.abs()));
+    /* add back in the trailing '/' to the first segment */
+    if ($1.p[$1.l-1] == '/' && $1.l > 1)
+      path += "/";
+    $$ = new ExprPath(ref<SourceAccessor>(state->rootFS), std::move(path));
+  }
+  | HPATH {
+    if (state->settings.pureEval) {
+        throw Error(
+            "the path '%s' can not be resolved in pure mode",
+            std::string_view($1.p, $1.l)
+        );
+    }
+    Path path(getHome() + std::string($1.p + 1, $1.l - 1));
+    $$ = new ExprPath(ref<SourceAccessor>(state->rootFS), std::move(path));
+  }
+  ;
+
+ind_string_parts
+  : ind_string_parts IND_STR { $$ = $1; $1->emplace_back(state->at(@2), $2); }
+  | ind_string_parts DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(state->at(@2), $3); }
+  | { $$ = new std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken>>>; }
+  ;
+
+binds
+  : binds1
+  | { $$ = new ExprAttrs; }
+  ;
+
+binds1
+  : binds1[accum] attrpath '=' expr ';'
+    { $$ = $accum;
+      state->addAttr($$, std::move(*$attrpath), @attrpath, $expr, @expr);
+      delete $attrpath;
+    }
+  | binds[accum] INHERIT attrs ';'
+    { $$ = $accum;
+      for (auto & [i, iPos] : *$attrs) {
+          if ($accum->attrs.find(i.symbol) != $accum->attrs.end())
+              state->dupAttr(i.symbol, iPos, $accum->attrs[i.symbol].pos);
+          $accum->attrs.emplace(
+              i.symbol,
+              ExprAttrs::AttrDef(new ExprVar(iPos, i.symbol), iPos, ExprAttrs::AttrDef::Kind::Inherited));
+      }
+      delete $attrs;
+    }
+  | binds[accum] INHERIT '(' expr ')' attrs ';'
+    { $$ = $accum;
+      if (!$accum->inheritFromExprs)
+          $accum->inheritFromExprs = std::make_unique<std::vector<Expr *>>();
+      $accum->inheritFromExprs->push_back($expr);
+      auto from = new nix::ExprInheritFrom(state->at(@expr), $accum->inheritFromExprs->size() - 1);
+      for (auto & [i, iPos] : *$attrs) {
+          if ($accum->attrs.find(i.symbol) != $accum->attrs.end())
+              state->dupAttr(i.symbol, iPos, $accum->attrs[i.symbol].pos);
+          $accum->attrs.emplace(
+              i.symbol,
+              ExprAttrs::AttrDef(
+                  new ExprSelect(iPos, from, i.symbol),
+                  iPos,
+                  ExprAttrs::AttrDef::Kind::InheritedFrom));
+      }
+      delete $attrs;
+    }
+  | attrpath '=' expr ';'
+    { $$ = new ExprAttrs;
+      state->addAttr($$, std::move(*$attrpath), @attrpath, $expr, @expr);
+      delete $attrpath;
+    }
+  ;
+
+attrs
+  : attrs attr { $$ = $1; $1->emplace_back(AttrName(state->symbols.create($2)), state->at(@2)); }
+  | attrs string_attr
+    { $$ = $1;
+      ExprString * str = dynamic_cast<ExprString *>($2);
+      if (str) {
+          $$->emplace_back(AttrName(state->symbols.create(str->s)), state->at(@2));
+          delete str;
+      } else
+          throw ParseError({
+              .msg = HintFmt("dynamic attributes not allowed in inherit"),
+              .pos = state->positions[state->at(@2)]
+          });
+    }
+  | { $$ = new std::vector<std::pair<AttrName, PosIdx>>; }
+  ;
+
+attrpath
+  : attrpath '.' attr { $$ = $1; $1->push_back(AttrName(state->symbols.create($3))); }
+  | attrpath '.' string_attr
+    { $$ = $1;
+      ExprString * str = dynamic_cast<ExprString *>($3);
+      if (str) {
+          $$->push_back(AttrName(state->symbols.create(str->s)));
+          delete str;
+      } else
+          $$->push_back(AttrName($3));
+    }
+  | attr { $$ = new std::vector<AttrName>; $$->push_back(AttrName(state->symbols.create($1))); }
+  | string_attr
+    { $$ = new std::vector<AttrName>;
+      ExprString *str = dynamic_cast<ExprString *>($1);
+      if (str) {
+          $$->push_back(AttrName(state->symbols.create(str->s)));
+          delete str;
+      } else
+          $$->push_back(AttrName($1));
+    }
+  ;
+
+attr
+  : ID
+  | OR_KW { $$ = {"or", 2}; }
+  ;
+
+string_attr
+  : '"' string_parts '"' { $$ = $2; }
+  | DOLLAR_CURLY expr '}' { $$ = $2; }
+  ;
+
+expr_list
+  : expr_list expr_select { $$ = $1; $1->elems.push_back($2); /* !!! dangerous */; $2->warnIfCursedOr(state->symbols, state->positions); }
+  | { $$ = new ExprList; }
+  ;
+
+formal_set
+  : '{' formals ',' ELLIPSIS '}' { $$ = $formals;    $$->ellipsis = true; }
+  | '{' ELLIPSIS '}'             { $$ = new Formals; $$->ellipsis = true; }
+  | '{' formals ',' '}'          { $$ = $formals;    $$->ellipsis = false; }
+  | '{' formals '}'              { $$ = $formals;    $$->ellipsis = false; }
+  | '{' '}'                      { $$ = new Formals; $$->ellipsis = false; }
+  ;
+
+formals
+  : formals[accum] ',' formal
+    { $$ = $accum; $$->formals.emplace_back(*$formal); delete $formal; }
+  | formal
+    { $$ = new Formals; $$->formals.emplace_back(*$formal); delete $formal; }
+  ;
+
+formal
+  : ID { $$ = new Formal{CUR_POS, state->symbols.create($1), 0}; }
+  | ID '?' expr { $$ = new Formal{CUR_POS, state->symbols.create($1), $3}; }
+  ;
+
+%%
+
+#include "eval.hh"
+
+
+namespace nix {
+
+Expr * parseExprFromBuf(
+    char * text,
+    size_t length,
+    Pos::Origin origin,
+    const SourcePath & basePath,
+    SymbolTable & symbols,
+    const EvalSettings & settings,
+    PosTable & positions,
+    DocCommentMap & docComments,
+    const ref<SourceAccessor> rootFS,
+    const Expr::AstSymbols & astSymbols)
+{
+    yyscan_t scanner;
+    LexerState lexerState {
+        .positionToDocComment = docComments,
+        .positions = positions,
+        .origin = positions.addOrigin(origin, length),
+    };
+    ParserState state {
+        .lexerState = lexerState,
+        .symbols = symbols,
+        .positions = positions,
+        .basePath = basePath,
+        .origin = lexerState.origin,
+        .rootFS = rootFS,
+        .s = astSymbols,
+        .settings = settings,
+    };
+
+    yylex_init_extra(&lexerState, &scanner);
+    Finally _destroy([&] { yylex_destroy(scanner); });
+
+    yy_scan_buffer(text, length, scanner);
+    yyparse(scanner, &state);
+
+    return state.result;
+}
+
+
+}

subprojects/libexpr/paths.cc

@@ -0,0 +1,15 @@
+#include "eval.hh"
+
+namespace nix {
+
+SourcePath EvalState::rootPath(CanonPath path)
+{
+    return {rootFS, std::move(path)};
+}
+
+SourcePath EvalState::rootPath(PathView path)
+{
+    return {rootFS, CanonPath(absPath(path))};
+}
+
+}

subprojects/libexpr/pos-idx.hh

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <cinttypes>
+#include <functional>
+
+namespace nix {
+
+class PosIdx
+{
+    friend struct LazyPosAcessors;
+    friend class PosTable;
+    friend class std::hash<PosIdx>;
+
+private:
+    uint32_t id;
+
+    explicit PosIdx(uint32_t id)
+        : id(id)
+    {
+    }
+
+public:
+    PosIdx()
+        : id(0)
+    {
+    }
+
+    explicit operator bool() const
+    {
+        return id > 0;
+    }
+
+    auto operator<=>(const PosIdx other) const
+    {
+        return id <=> other.id;
+    }
+
+    bool operator==(const PosIdx other) const
+    {
+        return id == other.id;
+    }
+
+    size_t hash() const noexcept
+    {
+        return std::hash<uint32_t>{}(id);
+    }
+};
+
+inline PosIdx noPos = {};
+
+}
+
+namespace std {
+
+template<>
+struct hash<nix::PosIdx>
+{
+    std::size_t operator()(nix::PosIdx pos) const noexcept
+    {
+        return pos.hash();
+    }
+};
+
+} // namespace std

subprojects/libexpr/pos-table.hh

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+#include "pos-idx.hh"
+#include "position.hh"
+#include "sync.hh"
+
+namespace nix {
+
+class PosTable
+{
+public:
+    class Origin
+    {
+        friend PosTable;
+    private:
+        uint32_t offset;
+
+        Origin(Pos::Origin origin, uint32_t offset, size_t size):
+            offset(offset), origin(origin), size(size)
+        {}
+
+    public:
+        const Pos::Origin origin;
+        const size_t size;
+
+        uint32_t offsetOf(PosIdx p) const
+        {
+            return p.id - 1 - offset;
+        }
+    };
+
+private:
+    using Lines = std::vector<uint32_t>;
+
+    std::map<uint32_t, Origin> origins;
+    mutable Sync<std::map<uint32_t, Lines>> lines;
+
+    const Origin * resolve(PosIdx p) const
+    {
+        if (p.id == 0)
+            return nullptr;
+
+        const auto idx = p.id - 1;
+        /* we want the last key <= idx, so we'll take prev(first key > idx).
+            this is guaranteed to never rewind origin.begin because the first
+            key is always 0. */
+        const auto pastOrigin = origins.upper_bound(idx);
+        return &std::prev(pastOrigin)->second;
+    }
+
+public:
+    Origin addOrigin(Pos::Origin origin, size_t size)
+    {
+        uint32_t offset = 0;
+        if (auto it = origins.rbegin(); it != origins.rend())
+            offset = it->first + it->second.size;
+        // +1 because all PosIdx are offset by 1 to begin with, and
+        // another +1 to ensure that all origins can point to EOF, eg
+        // on (invalid) empty inputs.
+        if (2 + offset + size < offset)
+            return Origin{origin, offset, 0};
+        return origins.emplace(offset, Origin{origin, offset, size}).first->second;
+    }
+
+    PosIdx add(const Origin & origin, size_t offset)
+    {
+        if (offset > origin.size)
+            return PosIdx();
+        return PosIdx(1 + origin.offset + offset);
+    }
+
+    Pos operator[](PosIdx p) const;
+
+    Pos::Origin originOf(PosIdx p) const
+    {
+        if (auto o = resolve(p))
+            return o->origin;
+        return std::monostate{};
+    }
+};
+
+}

subprojects/libexpr/primops.hh

@@ -0,0 +1,56 @@
+#pragma once
+///@file
+
+#include "eval.hh"
+
+#include <tuple>
+#include <vector>
+
+namespace nix {
+
+/**
+ * For functions where we do not expect deep recursion, we can use a sizable
+ * part of the stack a free allocation space.
+ *
+ * Note: this is expected to be multiplied by sizeof(Value), or about 24 bytes.
+ */
+constexpr size_t nonRecursiveStackReservation = 128;
+
+/**
+ * Functions that maybe applied to self-similar inputs, such as concatMap on a
+ * tree, should reserve a smaller part of the stack for allocation.
+ *
+ * Note: this is expected to be multiplied by sizeof(Value), or about 24 bytes.
+ */
+constexpr size_t conservativeStackReservation = 16;
+
+struct RegisterPrimOp
+{
+    typedef std::vector<PrimOp> PrimOps;
+    static PrimOps * primOps;
+
+    /**
+     * You can register a constant by passing an arity of 0. fun
+     * will get called during EvalState initialization, so there
+     * may be primops not yet added and builtins is not yet sorted.
+     */
+    RegisterPrimOp(PrimOp && primOp);
+};
+
+/* These primops are disabled without enableNativeCode, but plugins
+   may wish to use them in limited contexts without globally enabling
+   them. */
+
+/**
+ * Load a ValueInitializer from a DSO and return whatever it initializes
+ */
+void prim_importNative(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+
+/**
+ * Execute a program and parse its output
+ */
+void prim_exec(EvalState & state, const PosIdx pos, Value * * args, Value & v);
+
+void makePositionThunks(EvalState & state, const PosIdx pos, Value & line, Value & column);
+
+}

subprojects/libexpr/primops/context.cc

@@ -0,0 +1,332 @@
+#include "primops.hh"
+#include "eval-inline.hh"
+#include "derivations.hh"
+#include "store-api.hh"
+
+namespace nix {
+
+static void prim_unsafeDiscardStringContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    NixStringContext context;
+    auto s = state.coerceToString(pos, *args[0], context, "while evaluating the argument passed to builtins.unsafeDiscardStringContext");
+    v.mkString(*s);
+}
+
+static RegisterPrimOp primop_unsafeDiscardStringContext({
+    .name = "__unsafeDiscardStringContext",
+    .args = {"s"},
+    .doc = R"(
+        Discard the [string context](@docroot@/language/string-context.md) from a value that can be coerced to a string.
+    )",
+    .fun = prim_unsafeDiscardStringContext,
+});
+
+
+static void prim_hasContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    NixStringContext context;
+    state.forceString(*args[0], context, pos, "while evaluating the argument passed to builtins.hasContext");
+    v.mkBool(!context.empty());
+}
+
+static RegisterPrimOp primop_hasContext({
+    .name = "__hasContext",
+    .args = {"s"},
+    .doc = R"(
+      Return `true` if string *s* has a non-empty context.
+      The context can be obtained with
+      [`getContext`](#builtins-getContext).
+
+      > **Example**
+      >
+      > Many operations require a string context to be empty because they are intended only to work with "regular" strings, and also to help users avoid unintentionally loosing track of string context elements.
+      > `builtins.hasContext` can help create better domain-specific errors in those case.
+      >
+      > ```nix
+      > name: meta:
+      >
+      > if builtins.hasContext name
+      > then throw "package name cannot contain string context"
+      > else { ${name} = meta; }
+      > ```
+    )",
+    .fun = prim_hasContext
+});
+
+
+static void prim_unsafeDiscardOutputDependency(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    NixStringContext context;
+    auto s = state.coerceToString(pos, *args[0], context, "while evaluating the argument passed to builtins.unsafeDiscardOutputDependency");
+
+    NixStringContext context2;
+    for (auto && c : context) {
+        if (auto * ptr = std::get_if<NixStringContextElem::DrvDeep>(&c.raw)) {
+            context2.emplace(NixStringContextElem::Opaque {
+                .path = ptr->drvPath
+            });
+        } else {
+            /* Can reuse original item */
+            context2.emplace(std::move(c).raw);
+        }
+    }
+
+    v.mkString(*s, context2);
+}
+
+static RegisterPrimOp primop_unsafeDiscardOutputDependency({
+    .name = "__unsafeDiscardOutputDependency",
+    .args = {"s"},
+    .doc = R"(
+      Create a copy of the given string where every
+      [derivation deep](@docroot@/language/string-context.md#string-context-element-derivation-deep)
+      string context element is turned into a
+      [constant](@docroot@/language/string-context.md#string-context-element-constant)
+      string context element.
+
+      This is the opposite of [`builtins.addDrvOutputDependencies`](#builtins-addDrvOutputDependencies).
+
+      This is unsafe because it allows us to "forget" store objects we would have otherwise referred to with the string context,
+      whereas Nix normally tracks all dependencies consistently.
+      Safe operations "grow" but never "shrink" string contexts.
+      [`builtins.addDrvOutputDependencies`] in contrast is safe because "derivation deep" string context element always refers to the underlying derivation (among many more things).
+      Replacing a constant string context element with a "derivation deep" element is a safe operation that just enlargens the string context without forgetting anything.
+
+      [`builtins.addDrvOutputDependencies`]: #builtins-addDrvOutputDependencies
+    )",
+    .fun = prim_unsafeDiscardOutputDependency
+});
+
+
+static void prim_addDrvOutputDependencies(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    NixStringContext context;
+    auto s = state.coerceToString(pos, *args[0], context, "while evaluating the argument passed to builtins.addDrvOutputDependencies");
+
+	auto contextSize = context.size();
+    if (contextSize != 1) {
+        state.error<EvalError>(
+            "context of string '%s' must have exactly one element, but has %d",
+            *s,
+            contextSize
+        ).atPos(pos).debugThrow();
+    }
+    NixStringContext context2 {
+        (NixStringContextElem { std::visit(overloaded {
+            [&](const NixStringContextElem::Opaque & c) -> NixStringContextElem::DrvDeep {
+                if (!c.path.isDerivation()) {
+                    state.error<EvalError>(
+                        "path '%s' is not a derivation",
+                        state.store->printStorePath(c.path)
+                    ).atPos(pos).debugThrow();
+                }
+                return NixStringContextElem::DrvDeep {
+                    .drvPath = c.path,
+                };
+            },
+            [&](const NixStringContextElem::Built & c) -> NixStringContextElem::DrvDeep {
+                state.error<EvalError>(
+                    "`addDrvOutputDependencies` can only act on derivations, not on a derivation output such as '%1%'",
+                    c.output
+                ).atPos(pos).debugThrow();
+            },
+            [&](const NixStringContextElem::DrvDeep & c) -> NixStringContextElem::DrvDeep {
+                /* Reuse original item because we want this to be idempotent. */
+                return std::move(c);
+            },
+        }, context.begin()->raw) }),
+    };
+
+    v.mkString(*s, context2);
+}
+
+static RegisterPrimOp primop_addDrvOutputDependencies({
+    .name = "__addDrvOutputDependencies",
+    .args = {"s"},
+    .doc = R"(
+      Create a copy of the given string where a single
+      [constant](@docroot@/language/string-context.md#string-context-element-constant)
+      string context element is turned into a
+      [derivation deep](@docroot@/language/string-context.md#string-context-element-derivation-deep)
+      string context element.
+
+      The store path that is the constant string context element should point to a valid derivation, and end in `.drv`.
+
+      The original string context element must not be empty or have multiple elements, and it must not have any other type of element other than a constant or derivation deep element.
+      The latter is supported so this function is idempotent.
+
+      This is the opposite of [`builtins.unsafeDiscardOutputDependency`](#builtins-unsafeDiscardOutputDependency).
+    )",
+    .fun = prim_addDrvOutputDependencies
+});
+
+
+/* Extract the context of a string as a structured Nix value.
+
+   The context is represented as an attribute set whose keys are the
+   paths in the context set and whose values are attribute sets with
+   the following keys:
+     path: True if the relevant path is in the context as a plain store
+           path (i.e. the kind of context you get when interpolating
+           a Nix path (e.g. ./.) into a string). False if missing.
+     allOutputs: True if the relevant path is a derivation and it is
+                  in the context as a drv file with all of its outputs
+                  (i.e. the kind of context you get when referencing
+                  .drvPath of some derivation). False if missing.
+     outputs: If a non-empty list, the relevant path is a derivation
+              and the provided outputs are referenced in the context
+              (i.e. the kind of context you get when referencing
+              .outPath of some derivation). Empty list if missing.
+   Note that for a given path any combination of the above attributes
+   may be present.
+*/
+static void prim_getContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    struct ContextInfo {
+        bool path = false;
+        bool allOutputs = false;
+        Strings outputs;
+    };
+    NixStringContext context;
+    state.forceString(*args[0], context, pos, "while evaluating the argument passed to builtins.getContext");
+    auto contextInfos = std::map<StorePath, ContextInfo>();
+    for (auto && i : context) {
+        std::visit(overloaded {
+            [&](NixStringContextElem::DrvDeep && d) {
+                contextInfos[std::move(d.drvPath)].allOutputs = true;
+            },
+            [&](NixStringContextElem::Built && b) {
+                // FIXME should eventually show string context as is, no
+                // resolving here.
+                auto drvPath = resolveDerivedPath(*state.store, *b.drvPath);
+                contextInfos[std::move(drvPath)].outputs.emplace_back(std::move(b.output));
+            },
+            [&](NixStringContextElem::Opaque && o) {
+                contextInfos[std::move(o.path)].path = true;
+            },
+        }, ((NixStringContextElem &&) i).raw);
+    }
+
+    auto attrs = state.buildBindings(contextInfos.size());
+
+    auto sPath = state.symbols.create("path");
+    auto sAllOutputs = state.symbols.create("allOutputs");
+    for (const auto & info : contextInfos) {
+        auto infoAttrs = state.buildBindings(3);
+        if (info.second.path)
+            infoAttrs.alloc(sPath).mkBool(true);
+        if (info.second.allOutputs)
+            infoAttrs.alloc(sAllOutputs).mkBool(true);
+        if (!info.second.outputs.empty()) {
+            auto list = state.buildList(info.second.outputs.size());
+            for (const auto & [i, output] : enumerate(info.second.outputs))
+                (list[i] = state.allocValue())->mkString(output);
+            infoAttrs.alloc(state.sOutputs).mkList(list);
+        }
+        attrs.alloc(state.store->printStorePath(info.first)).mkAttrs(infoAttrs);
+    }
+
+    v.mkAttrs(attrs);
+}
+
+static RegisterPrimOp primop_getContext({
+    .name = "__getContext",
+    .args = {"s"},
+    .doc = R"(
+      Return the string context of *s*.
+
+      The string context tracks references to derivations within a string.
+      It is represented as an attribute set of [store derivation](@docroot@/glossary.md#gloss-store-derivation) paths mapping to output names.
+
+      Using [string interpolation](@docroot@/language/string-interpolation.md) on a derivation will add that derivation to the string context.
+      For example,
+
+      ```nix
+      builtins.getContext "${derivation { name = "a"; builder = "b"; system = "c"; }}"
+      ```
+
+      evaluates to
+
+      ```
+      { "/nix/store/arhvjaf6zmlyn8vh8fgn55rpwnxq0n7l-a.drv" = { outputs = [ "out" ]; }; }
+      ```
+    )",
+    .fun = prim_getContext
+});
+
+
+/* Append the given context to a given string.
+
+   See the commentary above getContext for details of the
+   context representation.
+*/
+static void prim_appendContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    NixStringContext context;
+    auto orig = state.forceString(*args[0], context, noPos, "while evaluating the first argument passed to builtins.appendContext");
+
+    state.forceAttrs(*args[1], pos, "while evaluating the second argument passed to builtins.appendContext");
+
+    auto sPath = state.symbols.create("path");
+    auto sAllOutputs = state.symbols.create("allOutputs");
+    for (auto & i : *args[1]->attrs()) {
+        const auto & name = state.symbols[i.name];
+        if (!state.store->isStorePath(name))
+            state.error<EvalError>(
+                "context key '%s' is not a store path",
+                name
+            ).atPos(i.pos).debugThrow();
+        auto namePath = state.store->parseStorePath(name);
+        if (!settings.readOnlyMode)
+            state.store->ensurePath(namePath);
+        state.forceAttrs(*i.value, i.pos, "while evaluating the value of a string context");
+
+        if (auto attr = i.value->attrs()->get(sPath)) {
+            if (state.forceBool(*attr->value, attr->pos, "while evaluating the `path` attribute of a string context"))
+                context.emplace(NixStringContextElem::Opaque {
+                    .path = namePath,
+                });
+        }
+
+        if (auto attr = i.value->attrs()->get(sAllOutputs)) {
+            if (state.forceBool(*attr->value, attr->pos, "while evaluating the `allOutputs` attribute of a string context")) {
+                if (!isDerivation(name)) {
+                    state.error<EvalError>(
+                        "tried to add all-outputs context of %s, which is not a derivation, to a string",
+                        name
+                    ).atPos(i.pos).debugThrow();
+                }
+                context.emplace(NixStringContextElem::DrvDeep {
+                    .drvPath = namePath,
+                });
+            }
+        }
+
+        if (auto attr = i.value->attrs()->get(state.sOutputs)) {
+            state.forceList(*attr->value, attr->pos, "while evaluating the `outputs` attribute of a string context");
+            if (attr->value->listSize() && !isDerivation(name)) {
+                state.error<EvalError>(
+                    "tried to add derivation output context of %s, which is not a derivation, to a string",
+                    name
+                ).atPos(i.pos).debugThrow();
+            }
+            for (auto elem : attr->value->listItems()) {
+                auto outputName = state.forceStringNoCtx(*elem, attr->pos, "while evaluating an output name within a string context");
+                context.emplace(NixStringContextElem::Built {
+                    .drvPath = makeConstantStorePathRef(namePath),
+                    .output = std::string { outputName },
+                });
+            }
+        }
+    }
+
+    v.mkString(orig, context);
+}
+
+static RegisterPrimOp primop_appendContext({
+    .name = "__appendContext",
+    .arity = 2,
+    .fun = prim_appendContext
+});
+
+}

subprojects/libexpr/primops/derivation.nix

@@ -0,0 +1,52 @@
+# This is the implementation of the ‘derivation’ builtin function.
+# It's actually a wrapper around the ‘derivationStrict’ primop.
+# Note that the following comment will be shown in :doc in the repl, but not in the manual.
+
+/**
+  Create a derivation.
+
+  # Inputs
+
+  The single argument is an attribute set that describes what to build and how to build it.
+  See https://nix.dev/manual/nix/2.23/language/derivations
+
+  # Output
+
+  The result is an attribute set that describes the derivation.
+  Notably it contains the outputs, which in the context of the Nix language are special strings that refer to the output paths, which may not yet exist.
+  The realisation of these outputs only occurs when needed; for example
+
+    * When `nix-build` or a similar command is run, it realises the outputs that were requested on its command line.
+      See https://nix.dev/manual/nix/2.23/command-ref/nix-build
+
+    * When `import`, `readFile`, `readDir` or some other functions are called, they have to realise the outputs they depend on.
+      This is referred to as "import from derivation".
+      See https://nix.dev/manual/nix/2.23/language/import-from-derivation
+
+  Note that `derivation` is very bare-bones, and provides almost no commands during the build.
+  Most likely, you'll want to use functions like `stdenv.mkDerivation` in Nixpkgs to set up a basic environment.
+*/
+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

subprojects/libexpr/primops/fetchClosure.cc

@@ -0,0 +1,287 @@
+#include "primops.hh"
+#include "store-api.hh"
+#include "realisation.hh"
+#include "make-content-addressed.hh"
+#include "url.hh"
+
+namespace nix {
+
+/**
+ * Handler for the content addressed case.
+ *
+ * @param state Evaluator state and store to write to.
+ * @param fromStore Store containing the path to rewrite.
+ * @param fromPath Source path to be rewritten.
+ * @param toPathMaybe Path to write the rewritten path to. If empty, the error shows the actual path.
+ * @param v Return `Value`
+ */
+static void runFetchClosureWithRewrite(EvalState & state, const PosIdx pos, Store & fromStore, const StorePath & fromPath, const std::optional<StorePath> & toPathMaybe, Value &v) {
+
+    // establish toPath or throw
+
+    if (!toPathMaybe || !state.store->isValidPath(*toPathMaybe)) {
+        auto rewrittenPath = makeContentAddressed(fromStore, *state.store, fromPath);
+        if (toPathMaybe && *toPathMaybe != rewrittenPath)
+            throw Error({
+                .msg = HintFmt("rewriting '%s' to content-addressed form yielded '%s', while '%s' was expected",
+                    state.store->printStorePath(fromPath),
+                    state.store->printStorePath(rewrittenPath),
+                    state.store->printStorePath(*toPathMaybe)),
+                .pos = state.positions[pos]
+            });
+        if (!toPathMaybe)
+            throw Error({
+                .msg = HintFmt(
+                    "rewriting '%s' to content-addressed form yielded '%s'\n"
+                    "Use this value for the 'toPath' attribute passed to 'fetchClosure'",
+                    state.store->printStorePath(fromPath),
+                    state.store->printStorePath(rewrittenPath)),
+                .pos = state.positions[pos]
+            });
+    }
+
+    auto toPath = *toPathMaybe;
+
+    // check and return
+
+    auto resultInfo = state.store->queryPathInfo(toPath);
+
+    if (!resultInfo->isContentAddressed(*state.store)) {
+        // We don't perform the rewriting when outPath already exists, as an optimisation.
+        // However, we can quickly detect a mistake if the toPath is input addressed.
+        throw Error({
+            .msg = HintFmt(
+                "The 'toPath' value '%s' is input-addressed, so it can't possibly be the result of rewriting to a content-addressed path.\n\n"
+                "Set 'toPath' to an empty string to make Nix report the correct content-addressed path.",
+                state.store->printStorePath(toPath)),
+            .pos = state.positions[pos]
+        });
+    }
+
+    state.mkStorePathString(toPath, v);
+}
+
+/**
+ * Fetch the closure and make sure it's content addressed.
+ */
+static void runFetchClosureWithContentAddressedPath(EvalState & state, const PosIdx pos, Store & fromStore, const StorePath & fromPath, Value & v) {
+
+    if (!state.store->isValidPath(fromPath))
+        copyClosure(fromStore, *state.store, RealisedPath::Set { fromPath });
+
+    auto info = state.store->queryPathInfo(fromPath);
+
+    if (!info->isContentAddressed(*state.store)) {
+        throw Error({
+            .msg = HintFmt(
+                "The 'fromPath' value '%s' is input-addressed, but 'inputAddressed' is set to 'false' (default).\n\n"
+                "If you do intend to fetch an input-addressed store path, add\n\n"
+                "    inputAddressed = true;\n\n"
+                "to the 'fetchClosure' arguments.\n\n"
+                "Note that to ensure authenticity input-addressed store paths, users must configure a trusted binary cache public key on their systems. This is not needed for content-addressed paths.",
+                state.store->printStorePath(fromPath)),
+            .pos = state.positions[pos]
+        });
+    }
+
+    state.mkStorePathString(fromPath, v);
+}
+
+/**
+ * Fetch the closure and make sure it's input addressed.
+ */
+static void runFetchClosureWithInputAddressedPath(EvalState & state, const PosIdx pos, Store & fromStore, const StorePath & fromPath, Value & v) {
+
+    if (!state.store->isValidPath(fromPath))
+        copyClosure(fromStore, *state.store, RealisedPath::Set { fromPath });
+
+    auto info = state.store->queryPathInfo(fromPath);
+
+    if (info->isContentAddressed(*state.store)) {
+        throw Error({
+            .msg = HintFmt(
+                "The store object referred to by 'fromPath' at '%s' is not input-addressed, but 'inputAddressed' is set to 'true'.\n\n"
+                "Remove the 'inputAddressed' attribute (it defaults to 'false') to expect 'fromPath' to be content-addressed",
+                state.store->printStorePath(fromPath)),
+            .pos = state.positions[pos]
+        });
+    }
+
+    state.mkStorePathString(fromPath, v);
+}
+
+typedef std::optional<StorePath> StorePathOrGap;
+
+static void prim_fetchClosure(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    state.forceAttrs(*args[0], pos, "while evaluating the argument passed to builtins.fetchClosure");
+
+    std::optional<std::string> fromStoreUrl;
+    std::optional<StorePath> fromPath;
+    std::optional<StorePathOrGap> toPath;
+    std::optional<bool> inputAddressedMaybe;
+
+    for (auto & attr : *args[0]->attrs()) {
+        const auto & attrName = state.symbols[attr.name];
+        auto attrHint = [&]() -> std::string {
+            return "while evaluating the '" + attrName + "' attribute passed to builtins.fetchClosure";
+        };
+
+        if (attrName == "fromPath") {
+            NixStringContext context;
+            fromPath = state.coerceToStorePath(attr.pos, *attr.value, context, attrHint());
+        }
+
+        else if (attrName == "toPath") {
+            state.forceValue(*attr.value, attr.pos);
+            bool isEmptyString = attr.value->type() == nString && attr.value->string_view() == "";
+            if (isEmptyString) {
+                toPath = StorePathOrGap {};
+            }
+            else {
+                NixStringContext context;
+                toPath = state.coerceToStorePath(attr.pos, *attr.value, context, attrHint());
+            }
+        }
+
+        else if (attrName == "fromStore")
+            fromStoreUrl = state.forceStringNoCtx(*attr.value, attr.pos,
+                    attrHint());
+
+        else if (attrName == "inputAddressed")
+            inputAddressedMaybe = state.forceBool(*attr.value, attr.pos, attrHint());
+
+        else
+            throw Error({
+                .msg = HintFmt("attribute '%s' isn't supported in call to 'fetchClosure'", attrName),
+                .pos = state.positions[pos]
+            });
+    }
+
+    if (!fromPath)
+        throw Error({
+            .msg = HintFmt("attribute '%s' is missing in call to 'fetchClosure'", "fromPath"),
+            .pos = state.positions[pos]
+        });
+
+    bool inputAddressed = inputAddressedMaybe.value_or(false);
+
+    if (inputAddressed) {
+        if (toPath)
+            throw Error({
+                .msg = HintFmt("attribute '%s' is set to true, but '%s' is also set. Please remove one of them",
+                    "inputAddressed",
+                    "toPath"),
+                .pos = state.positions[pos]
+            });
+    }
+
+    if (!fromStoreUrl)
+        throw Error({
+            .msg = HintFmt("attribute '%s' is missing in call to 'fetchClosure'", "fromStore"),
+            .pos = state.positions[pos]
+        });
+
+    auto parsedURL = parseURL(*fromStoreUrl);
+
+    if (parsedURL.scheme != "http" &&
+        parsedURL.scheme != "https" &&
+        !(getEnv("_NIX_IN_TEST").has_value() && parsedURL.scheme == "file"))
+        throw Error({
+            .msg = HintFmt("'fetchClosure' only supports http:// and https:// stores"),
+            .pos = state.positions[pos]
+        });
+
+    if (!parsedURL.query.empty())
+        throw Error({
+            .msg = HintFmt("'fetchClosure' does not support URL query parameters (in '%s')", *fromStoreUrl),
+            .pos = state.positions[pos]
+        });
+
+    auto fromStore = openStore(parsedURL.to_string());
+
+    if (toPath)
+        runFetchClosureWithRewrite(state, pos, *fromStore, *fromPath, *toPath, v);
+    else if (inputAddressed)
+        runFetchClosureWithInputAddressedPath(state, pos, *fromStore, *fromPath, v);
+    else
+        runFetchClosureWithContentAddressedPath(state, pos, *fromStore, *fromPath, v);
+}
+
+static RegisterPrimOp primop_fetchClosure({
+    .name = "__fetchClosure",
+    .args = {"args"},
+    .doc = R"(
+      Fetch a store path [closure](@docroot@/glossary.md#gloss-closure) from a binary cache, and return the store path as a string with context.
+
+      This function can be invoked in three ways, that we will discuss in order of preference.
+
+      **Fetch a content-addressed store path**
+
+      Example:
+
+      ```nix
+      builtins.fetchClosure {
+        fromStore = "https://cache.nixos.org";
+        fromPath = /nix/store/ldbhlwhh39wha58rm61bkiiwm6j7211j-git-2.33.1;
+      }
+      ```
+
+      This is the simplest invocation, and it does not require the user of the expression to configure [`trusted-public-keys`](@docroot@/command-ref/conf-file.md#conf-trusted-public-keys) to ensure their authenticity.
+
+      If your store path is [input addressed](@docroot@/glossary.md#gloss-input-addressed-store-object) instead of content addressed, consider the other two invocations.
+
+      **Fetch any store path and rewrite it to a fully content-addressed store path**
+
+      Example:
+
+      ```nix
+      builtins.fetchClosure {
+        fromStore = "https://cache.nixos.org";
+        fromPath = /nix/store/r2jd6ygnmirm2g803mksqqjm4y39yi6i-git-2.33.1;
+        toPath = /nix/store/ldbhlwhh39wha58rm61bkiiwm6j7211j-git-2.33.1;
+      }
+      ```
+
+      This example fetches `/nix/store/r2jd...` from the specified binary cache,
+      and rewrites it into the content-addressed store path
+      `/nix/store/ldbh...`.
+
+      Like the previous example, no extra configuration or privileges are required.
+
+      To find out the correct value for `toPath` given a `fromPath`,
+      use [`nix store make-content-addressed`](@docroot@/command-ref/new-cli/nix3-store-make-content-addressed.md):
+
+      ```console
+      # nix store make-content-addressed --from https://cache.nixos.org /nix/store/r2jd6ygnmirm2g803mksqqjm4y39yi6i-git-2.33.1
+      rewrote '/nix/store/r2jd6ygnmirm2g803mksqqjm4y39yi6i-git-2.33.1' to '/nix/store/ldbhlwhh39wha58rm61bkiiwm6j7211j-git-2.33.1'
+      ```
+
+      Alternatively, set `toPath = ""` and find the correct `toPath` in the error message.
+
+      **Fetch an input-addressed store path as is**
+
+      Example:
+
+      ```nix
+      builtins.fetchClosure {
+        fromStore = "https://cache.nixos.org";
+        fromPath = /nix/store/r2jd6ygnmirm2g803mksqqjm4y39yi6i-git-2.33.1;
+        inputAddressed = true;
+      }
+      ```
+
+      It is possible to fetch an [input-addressed store path](@docroot@/glossary.md#gloss-input-addressed-store-object) and return it as is.
+      However, this is the least preferred way of invoking `fetchClosure`, because it requires that the input-addressed paths are trusted by the Nix configuration.
+
+      **`builtins.storePath`**
+
+      `fetchClosure` is similar to [`builtins.storePath`](#builtins-storePath) in that it allows you to use a previously built store path in a Nix expression.
+      However, `fetchClosure` is more reproducible because it specifies a binary cache from which the path can be fetched.
+      Also, using content-addressed store paths does not require users to configure [`trusted-public-keys`](@docroot@/command-ref/conf-file.md#conf-trusted-public-keys) to ensure their authenticity.
+    )",
+    .fun = prim_fetchClosure,
+    .experimentalFeature = Xp::FetchClosure,
+});
+
+}

subprojects/libexpr/primops/fetchMercurial.cc

@@ -0,0 +1,91 @@
+#include "primops.hh"
+#include "eval-inline.hh"
+#include "eval-settings.hh"
+#include "store-api.hh"
+#include "fetchers.hh"
+#include "url.hh"
+#include "url-parts.hh"
+
+namespace nix {
+
+static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    std::string url;
+    std::optional<Hash> rev;
+    std::optional<std::string> ref;
+    std::string_view name = "source";
+    NixStringContext context;
+
+    state.forceValue(*args[0], pos);
+
+    if (args[0]->type() == nAttrs) {
+
+        for (auto & attr : *args[0]->attrs()) {
+            std::string_view n(state.symbols[attr.name]);
+            if (n == "url")
+                url = state.coerceToString(attr.pos, *attr.value, context,
+                        "while evaluating the `url` attribute passed to builtins.fetchMercurial",
+                        false, false).toOwned();
+            else if (n == "rev") {
+                // Ugly: unlike fetchGit, here the "rev" attribute can
+                // be both a revision or a branch/tag name.
+                auto value = state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the `rev` attribute passed to builtins.fetchMercurial");
+                if (std::regex_match(value.begin(), value.end(), revRegex))
+                    rev = Hash::parseAny(value, HashAlgorithm::SHA1);
+                else
+                    ref = value;
+            }
+            else if (n == "name")
+                name = state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the `name` attribute passed to builtins.fetchMercurial");
+            else
+                state.error<EvalError>("unsupported argument '%s' to 'fetchMercurial'", state.symbols[attr.name]).atPos(attr.pos).debugThrow();
+        }
+
+        if (url.empty())
+            state.error<EvalError>("'url' argument required").atPos(pos).debugThrow();
+
+    } else
+        url = state.coerceToString(pos, *args[0], context,
+                "while evaluating the first argument passed to builtins.fetchMercurial",
+                false, false).toOwned();
+
+    // FIXME: git externals probably can be used to bypass the URI
+    // whitelist. Ah well.
+    state.checkURI(url);
+
+    if (state.settings.pureEval && !rev)
+        throw Error("in pure evaluation mode, 'fetchMercurial' requires a Mercurial revision");
+
+    fetchers::Attrs attrs;
+    attrs.insert_or_assign("type", "hg");
+    attrs.insert_or_assign("url", url.find("://") != std::string::npos ? url : "file://" + url);
+    attrs.insert_or_assign("name", std::string(name));
+    if (ref) attrs.insert_or_assign("ref", *ref);
+    if (rev) attrs.insert_or_assign("rev", rev->gitRev());
+    auto input = fetchers::Input::fromAttrs(state.fetchSettings, std::move(attrs));
+
+    auto [storePath, input2] = input.fetchToStore(state.store);
+
+    auto attrs2 = state.buildBindings(8);
+    state.mkStorePathString(storePath, attrs2.alloc(state.sOutPath));
+    if (input2.getRef())
+        attrs2.alloc("branch").mkString(*input2.getRef());
+    // Backward compatibility: set 'rev' to
+    // 0000000000000000000000000000000000000000 for a dirty tree.
+    auto rev2 = input2.getRev().value_or(Hash(HashAlgorithm::SHA1));
+    attrs2.alloc("rev").mkString(rev2.gitRev());
+    attrs2.alloc("shortRev").mkString(rev2.gitRev().substr(0, 12));
+    if (auto revCount = input2.getRevCount())
+        attrs2.alloc("revCount").mkInt(*revCount);
+    v.mkAttrs(attrs2);
+
+    state.allowPath(storePath);
+}
+
+static RegisterPrimOp r_fetchMercurial({
+    .name = "fetchMercurial",
+    .arity = 1,
+    .fun = prim_fetchMercurial
+});
+
+}

subprojects/libexpr/primops/fetchTree.cc

@@ -0,0 +1,826 @@
+#include "attrs.hh"
+#include "primops.hh"
+#include "eval-inline.hh"
+#include "eval-settings.hh"
+#include "store-api.hh"
+#include "fetchers.hh"
+#include "filetransfer.hh"
+#include "registry.hh"
+#include "tarball.hh"
+#include "url.hh"
+#include "value-to-json.hh"
+#include "fetch-to-store.hh"
+
+#include <nlohmann/json.hpp>
+
+#include <ctime>
+#include <iomanip>
+#include <regex>
+
+namespace nix {
+
+void emitTreeAttrs(
+    EvalState & state,
+    const StorePath & storePath,
+    const fetchers::Input & input,
+    Value & v,
+    bool emptyRevFallback,
+    bool forceDirty)
+{
+    auto attrs = state.buildBindings(100);
+
+    state.mkStorePathString(storePath, attrs.alloc(state.sOutPath));
+
+    // FIXME: support arbitrary input attributes.
+
+    auto narHash = input.getNarHash();
+    assert(narHash);
+    attrs.alloc("narHash").mkString(narHash->to_string(HashFormat::SRI, true));
+
+    if (input.getType() == "git")
+        attrs.alloc("submodules").mkBool(
+            fetchers::maybeGetBoolAttr(input.attrs, "submodules").value_or(false));
+
+    if (!forceDirty) {
+
+        if (auto rev = input.getRev()) {
+            attrs.alloc("rev").mkString(rev->gitRev());
+            attrs.alloc("shortRev").mkString(rev->gitShortRev());
+        } else if (emptyRevFallback) {
+            // Backwards compat for `builtins.fetchGit`: dirty repos return an empty sha1 as rev
+            auto emptyHash = Hash(HashAlgorithm::SHA1);
+            attrs.alloc("rev").mkString(emptyHash.gitRev());
+            attrs.alloc("shortRev").mkString(emptyHash.gitShortRev());
+        }
+
+        if (auto revCount = input.getRevCount())
+            attrs.alloc("revCount").mkInt(*revCount);
+        else if (emptyRevFallback)
+            attrs.alloc("revCount").mkInt(0);
+
+    }
+
+    if (auto dirtyRev = fetchers::maybeGetStrAttr(input.attrs, "dirtyRev")) {
+        attrs.alloc("dirtyRev").mkString(*dirtyRev);
+        attrs.alloc("dirtyShortRev").mkString(*fetchers::maybeGetStrAttr(input.attrs, "dirtyShortRev"));
+    }
+
+    if (auto lastModified = input.getLastModified()) {
+        attrs.alloc("lastModified").mkInt(*lastModified);
+        attrs.alloc("lastModifiedDate").mkString(
+            fmt("%s", std::put_time(std::gmtime(&*lastModified), "%Y%m%d%H%M%S")));
+    }
+
+    v.mkAttrs(attrs);
+}
+
+struct FetchTreeParams {
+    bool emptyRevFallback = false;
+    bool allowNameArgument = false;
+    bool isFetchGit = false;
+};
+
+static void fetchTree(
+    EvalState & state,
+    const PosIdx pos,
+    Value * * args,
+    Value & v,
+    const FetchTreeParams & params = FetchTreeParams{}
+) {
+    fetchers::Input input { state.fetchSettings };
+    NixStringContext context;
+    std::optional<std::string> type;
+    if (params.isFetchGit) type = "git";
+
+    state.forceValue(*args[0], pos);
+
+    if (args[0]->type() == nAttrs) {
+        state.forceAttrs(*args[0], pos, "while evaluating the argument passed to builtins.fetchTree");
+
+        fetchers::Attrs attrs;
+
+        if (auto aType = args[0]->attrs()->get(state.sType)) {
+            if (type)
+                state.error<EvalError>(
+                    "unexpected attribute 'type'"
+                ).atPos(pos).debugThrow();
+            type = state.forceStringNoCtx(*aType->value, aType->pos, "while evaluating the `type` attribute passed to builtins.fetchTree");
+        } else if (!type)
+            state.error<EvalError>(
+                "attribute 'type' is missing in call to 'fetchTree'"
+            ).atPos(pos).debugThrow();
+
+        attrs.emplace("type", type.value());
+
+        for (auto & attr : *args[0]->attrs()) {
+            if (attr.name == state.sType) continue;
+            state.forceValue(*attr.value, attr.pos);
+            if (attr.value->type() == nPath || attr.value->type() == nString) {
+                auto s = state.coerceToString(attr.pos, *attr.value, context, "", false, false).toOwned();
+                attrs.emplace(state.symbols[attr.name],
+                    params.isFetchGit && state.symbols[attr.name] == "url"
+                    ? fixGitURL(s)
+                    : s);
+            }
+            else if (attr.value->type() == nBool)
+                attrs.emplace(state.symbols[attr.name], Explicit<bool>{attr.value->boolean()});
+            else if (attr.value->type() == nInt) {
+                auto intValue = attr.value->integer().value;
+
+                if (intValue < 0) {
+                    state.error<EvalError>("negative value given for fetchTree attr %1%: %2%", state.symbols[attr.name], intValue).atPos(pos).debugThrow();
+                }
+
+                attrs.emplace(state.symbols[attr.name], uint64_t(intValue));
+            } else if (state.symbols[attr.name] == "publicKeys") {
+                experimentalFeatureSettings.require(Xp::VerifiedFetches);
+                attrs.emplace(state.symbols[attr.name], printValueAsJSON(state, true, *attr.value, pos, context).dump());
+            }
+            else
+                state.error<TypeError>("fetchTree argument '%s' is %s while a string, Boolean or integer is expected",
+                    state.symbols[attr.name], showType(*attr.value)).debugThrow();
+        }
+
+        if (params.isFetchGit && !attrs.contains("exportIgnore") && (!attrs.contains("submodules") || !*fetchers::maybeGetBoolAttr(attrs, "submodules"))) {
+            attrs.emplace("exportIgnore", Explicit<bool>{true});
+        }
+
+        // fetchTree should fetch git repos with shallow = true by default
+        if (type == "git" && !params.isFetchGit && !attrs.contains("shallow")) {
+            attrs.emplace("shallow", Explicit<bool>{true});
+        }
+
+        if (!params.allowNameArgument)
+            if (auto nameIter = attrs.find("name"); nameIter != attrs.end())
+                state.error<EvalError>(
+                    "attribute 'name' isn’t supported in call to 'fetchTree'"
+                ).atPos(pos).debugThrow();
+
+        input = fetchers::Input::fromAttrs(state.fetchSettings, std::move(attrs));
+    } else {
+        auto url = state.coerceToString(pos, *args[0], context,
+                "while evaluating the first argument passed to the fetcher",
+                false, false).toOwned();
+
+        if (params.isFetchGit) {
+            fetchers::Attrs attrs;
+            attrs.emplace("type", "git");
+            attrs.emplace("url", fixGitURL(url));
+            if (!attrs.contains("exportIgnore") && (!attrs.contains("submodules") || !*fetchers::maybeGetBoolAttr(attrs, "submodules"))) {
+                attrs.emplace("exportIgnore", Explicit<bool>{true});
+            }
+            input = fetchers::Input::fromAttrs(state.fetchSettings, std::move(attrs));
+        } else {
+            if (!experimentalFeatureSettings.isEnabled(Xp::Flakes))
+                state.error<EvalError>(
+                    "passing a string argument to 'fetchTree' requires the 'flakes' experimental feature"
+                ).atPos(pos).debugThrow();
+            input = fetchers::Input::fromURL(state.fetchSettings, url);
+        }
+    }
+
+    if (!state.settings.pureEval && !input.isDirect() && experimentalFeatureSettings.isEnabled(Xp::Flakes))
+        input = lookupInRegistries(state.store, input).first;
+
+    if (state.settings.pureEval && !input.isLocked()) {
+        auto fetcher = "fetchTree";
+        if (params.isFetchGit)
+            fetcher = "fetchGit";
+
+        state.error<EvalError>(
+            "in pure evaluation mode, '%s' will not fetch unlocked input '%s'",
+            fetcher, input.to_string()
+        ).atPos(pos).debugThrow();
+    }
+
+    state.checkURI(input.toURLString());
+
+    auto [storePath, input2] = input.fetchToStore(state.store);
+
+    state.allowPath(storePath);
+
+    emitTreeAttrs(state, storePath, input2, v, params.emptyRevFallback, false);
+}
+
+static void prim_fetchTree(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    fetchTree(state, pos, args, v, { });
+}
+
+static RegisterPrimOp primop_fetchTree({
+    .name = "fetchTree",
+    .args = {"input"},
+    .doc = R"(
+      Fetch a file system tree or a plain file using one of the supported backends and return an attribute set with:
+
+      - the resulting fixed-output [store path](@docroot@/store/store-path.md)
+      - the corresponding [NAR](@docroot@/store/file-system-object/content-address.md#serial-nix-archive) hash
+      - backend-specific metadata (currently not documented). <!-- TODO: document output attributes -->
+
+      *input* must be an attribute set with the following attributes:
+
+      - `type` (String, required)
+
+        One of the [supported source types](#source-types).
+        This determines other required and allowed input attributes.
+
+      - `narHash` (String, optional)
+
+        The `narHash` parameter can be used to substitute the source of the tree.
+        It also allows for verification of tree contents that may not be provided by the underlying transfer mechanism.
+        If `narHash` is set, the source is first looked up is the Nix store and [substituters](@docroot@/command-ref/conf-file.md#conf-substituters), and only fetched if not available.
+
+      A subset of the output attributes of `fetchTree` can be re-used for subsequent calls to `fetchTree` to produce the same result again.
+      That is, `fetchTree` is idempotent.
+
+      Downloads are cached in `$XDG_CACHE_HOME/nix`.
+      The remote source will be fetched from the network if both are true:
+      - A NAR hash is supplied and the corresponding store path is not [valid](@docroot@/glossary.md#gloss-validity), that is, not available in the store
+
+        > **Note**
+        >
+        > [Substituters](@docroot@/command-ref/conf-file.md#conf-substituters) are not used in fetching.
+
+      - There is no cache entry or the cache entry is older than [`tarball-ttl`](@docroot@/command-ref/conf-file.md#conf-tarball-ttl)
+
+      ## Source types
+
+      The following source types and associated input attributes are supported.
+
+      <!-- TODO: It would be soooo much more predictable to work with (and
+      document) if `fetchTree` was a curried call with the first parameter for
+      `type` or an attribute like `builtins.fetchTree.git`! -->
+
+      - `"file"`
+
+        Place a plain file into the Nix store.
+        This is similar to [`builtins.fetchurl`](@docroot@/language/builtins.md#builtins-fetchurl)
+
+        - `url` (String, required)
+
+          Supported protocols:
+
+          - `https`
+
+            > **Example**
+            >
+            > ```nix
+            > fetchTree {
+            >   type = "file";
+            >   url = "https://example.com/index.html";
+            > }
+            > ```
+
+          - `http`
+
+            Insecure HTTP transfer for legacy sources.
+
+            > **Warning**
+            >
+            > HTTP performs no encryption or authentication.
+            > Use a `narHash` known in advance to ensure the output has expected contents.
+
+          - `file`
+
+            A file on the local file system.
+
+            > **Example**
+            >
+            > ```nix
+            > fetchTree {
+            >   type = "file";
+            >   url = "file:///home/eelco/nix/README.md";
+            > }
+            > ```
+
+      - `"tarball"`
+
+        Download a tar archive and extract it into the Nix store.
+        This has the same underyling implementation as [`builtins.fetchTarball`](@docroot@/language/builtins.md#builtins-fetchTarball)
+
+        - `url` (String, required)
+
+           > **Example**
+           >
+           > ```nix
+           > fetchTree {
+           >   type = "tarball";
+           >   url = "https://github.com/NixOS/nixpkgs/tarball/nixpkgs-23.11";
+           > }
+           > ```
+
+      - `"git"`
+
+        Fetch a Git tree and copy it to the Nix store.
+        This is similar to [`builtins.fetchGit`](@docroot@/language/builtins.md#builtins-fetchGit).
+
+        - `url` (String, required)
+
+          The URL formats supported are the same as for Git itself.
+
+          > **Example**
+          >
+          > ```nix
+          > fetchTree {
+          >   type = "git";
+          >   url = "git@github.com:NixOS/nixpkgs.git";
+          > }
+          > ```
+
+          > **Note**
+          >
+          > If the URL points to a local directory, and no `ref` or `rev` is given, Nix will only consider files added to the Git index, as listed by `git ls-files` but use the *current file contents* of the Git working directory.
+
+        - `ref` (String, optional)
+
+          By default, this has no effect. This becomes relevant only once `shallow` cloning is disabled.
+
+          A [Git reference](https://git-scm.com/book/en/v2/Git-Internals-Git-References), such as a branch or tag name.
+
+          Default: `"HEAD"`
+
+        - `rev` (String, optional)
+
+          A Git revision; a commit hash.
+
+          Default: the tip of `ref`
+
+        - `shallow` (Bool, optional)
+
+          Make a shallow clone when fetching the Git tree.
+          When this is enabled, the options `ref` and `allRefs` have no effect anymore.
+
+          Default: `true`
+
+        - `submodules` (Bool, optional)
+
+          Also fetch submodules if available.
+
+          Default: `false`
+
+        - `allRefs` (Bool, optional)
+
+          By default, this has no effect. This becomes relevant only once `shallow` cloning is disabled.
+
+          Whether to fetch all references (eg. branches and tags) of the repository.
+          With this argument being true, it's possible to load a `rev` from *any* `ref`.
+          (Without setting this option, only `rev`s from the specified `ref` are supported).
+
+          Default: `false`
+
+        - `lastModified` (Integer, optional)
+
+          Unix timestamp of the fetched commit.
+
+          If set, pass through the value to the output attribute set.
+          Otherwise, generated from the fetched Git tree.
+
+        - `revCount` (Integer, optional)
+
+          Number of revisions in the history of the Git repository before the fetched commit.
+
+          If set, pass through the value to the output attribute set.
+          Otherwise, generated from the fetched Git tree.
+
+      The following input types are still subject to change:
+
+      - `"path"`
+      - `"github"`
+      - `"gitlab"`
+      - `"sourcehut"`
+      - `"mercurial"`
+
+     *input* can also be a [URL-like reference](@docroot@/command-ref/new-cli/nix3-flake.md#flake-references).
+     The additional input types and the URL-like syntax requires the [`flakes` experimental feature](@docroot@/development/experimental-features.md#xp-feature-flakes) to be enabled.
+
+      > **Example**
+      >
+      > Fetch a GitHub repository using the attribute set representation:
+      >
+      > ```nix
+      > builtins.fetchTree {
+      >   type = "github";
+      >   owner = "NixOS";
+      >   repo = "nixpkgs";
+      >   rev = "ae2e6b3958682513d28f7d633734571fb18285dd";
+      > }
+      > ```
+      >
+      > This evaluates to the following attribute set:
+      >
+      > ```nix
+      > {
+      >   lastModified = 1686503798;
+      >   lastModifiedDate = "20230611171638";
+      >   narHash = "sha256-rA9RqKP9OlBrgGCPvfd5HVAXDOy8k2SmPtB/ijShNXc=";
+      >   outPath = "/nix/store/l5m6qlvfs9sdw14ja3qbzpglcjlb6j1x-source";
+      >   rev = "ae2e6b3958682513d28f7d633734571fb18285dd";
+      >   shortRev = "ae2e6b3";
+      > }
+      > ```
+
+      > **Example**
+      >
+      > Fetch the same GitHub repository using the URL-like syntax:
+      >
+      >   ```nix
+      >   builtins.fetchTree "github:NixOS/nixpkgs/ae2e6b3958682513d28f7d633734571fb18285dd"
+      >   ```
+    )",
+    .fun = prim_fetchTree,
+    .experimentalFeature = Xp::FetchTree,
+});
+
+static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v,
+    const std::string & who, bool unpack, std::string name)
+{
+    std::optional<std::string> url;
+    std::optional<Hash> expectedHash;
+
+    state.forceValue(*args[0], pos);
+
+    bool isArgAttrs = args[0]->type() == nAttrs;
+    bool nameAttrPassed = false;
+
+    if (isArgAttrs) {
+
+        for (auto & attr : *args[0]->attrs()) {
+            std::string_view n(state.symbols[attr.name]);
+            if (n == "url")
+                url = state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the url we should fetch");
+            else if (n == "sha256")
+                expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the sha256 of the content we should fetch"), HashAlgorithm::SHA256);
+            else if (n == "name") {
+                nameAttrPassed = true;
+                name = state.forceStringNoCtx(*attr.value, attr.pos, "while evaluating the name of the content we should fetch");
+            }
+            else
+                state.error<EvalError>("unsupported argument '%s' to '%s'", n, who)
+                .atPos(pos).debugThrow();
+        }
+
+        if (!url)
+            state.error<EvalError>(
+                "'url' argument required").atPos(pos).debugThrow();
+    } else
+        url = state.forceStringNoCtx(*args[0], pos, "while evaluating the url we should fetch");
+
+    if (who == "fetchTarball")
+        url = state.settings.resolvePseudoUrl(*url);
+
+    state.checkURI(*url);
+
+    if (name == "")
+        name = baseNameOf(*url);
+
+    try {
+        checkName(name);
+    } catch (BadStorePathName & e) {
+        auto resolution =
+            nameAttrPassed ? HintFmt("Please change the value for the 'name' attribute passed to '%s', so that it can create a valid store path.", who) :
+            isArgAttrs ? HintFmt("Please add a valid 'name' attribute to the argument for '%s', so that it can create a valid store path.", who) :
+            HintFmt("Please pass an attribute set with 'url' and 'name' attributes to '%s',  so that it can create a valid store path.", who);
+
+        state.error<EvalError>(
+            std::string("invalid store path name when fetching URL '%s': %s. %s"), *url, Uncolored(e.message()), Uncolored(resolution.str()))
+        .atPos(pos).debugThrow();
+    }
+
+    if (state.settings.pureEval && !expectedHash)
+        state.error<EvalError>("in pure evaluation mode, '%s' requires a 'sha256' argument", who).atPos(pos).debugThrow();
+
+    // early exit if pinned and already in the store
+    if (expectedHash && expectedHash->algo == HashAlgorithm::SHA256) {
+        auto expectedPath = state.store->makeFixedOutputPath(
+            name,
+            FixedOutputInfo {
+                .method = unpack ? FileIngestionMethod::NixArchive : FileIngestionMethod::Flat,
+                .hash = *expectedHash,
+                .references = {}
+            });
+
+        if (state.store->isValidPath(expectedPath)) {
+            state.allowAndSetStorePathString(expectedPath, v);
+            return;
+        }
+    }
+
+    // TODO: fetching may fail, yet the path may be substitutable.
+    //       https://github.com/NixOS/nix/issues/4313
+    auto storePath =
+        unpack
+        ? fetchToStore(
+            *state.store,
+            fetchers::downloadTarball(state.store, state.fetchSettings, *url),
+            FetchMode::Copy,
+            name)
+        : fetchers::downloadFile(state.store, *url, name).storePath;
+
+    if (expectedHash) {
+        auto hash = unpack
+            ? state.store->queryPathInfo(storePath)->narHash
+            : hashFile(HashAlgorithm::SHA256, state.store->toRealPath(storePath));
+        if (hash != *expectedHash) {
+            state.error<EvalError>(
+                "hash mismatch in file downloaded from '%s':\n  specified: %s\n  got:       %s",
+                *url,
+                expectedHash->to_string(HashFormat::Nix32, true),
+                hash.to_string(HashFormat::Nix32, true)
+            ).withExitStatus(102)
+            .debugThrow();
+        }
+    }
+
+    state.allowAndSetStorePathString(storePath, v);
+}
+
+static void prim_fetchurl(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    fetch(state, pos, args, v, "fetchurl", false, "");
+}
+
+static RegisterPrimOp primop_fetchurl({
+    .name = "__fetchurl",
+    .args = {"arg"},
+    .doc = R"(
+      Download the specified URL and return the path of the downloaded file.
+      `arg` can be either a string denoting the URL, or an attribute set with the following attributes:
+
+      - `url`
+
+        The URL of the file to download.
+
+      - `name` (default: the last path component of the URL)
+
+        A name for the file in the store. This can be useful if the URL has any
+        characters that are invalid for the store.
+
+      Not available in [restricted evaluation mode](@docroot@/command-ref/conf-file.md#conf-restrict-eval).
+    )",
+    .fun = prim_fetchurl,
+});
+
+static void prim_fetchTarball(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    fetch(state, pos, args, v, "fetchTarball", true, "source");
+}
+
+static RegisterPrimOp primop_fetchTarball({
+    .name = "fetchTarball",
+    .args = {"args"},
+    .doc = R"(
+      Download the specified URL, unpack it and return the path of the
+      unpacked tree. The file must be a tape archive (`.tar`) compressed
+      with `gzip`, `bzip2` or `xz`. If the tarball consists of a
+      single directory, then the top-level path component of the files
+      in the tarball is removed. The typical use of the function is to
+      obtain external Nix expression dependencies, such as a
+      particular version of Nixpkgs, e.g.
+
+      ```nix
+      with import (fetchTarball https://github.com/NixOS/nixpkgs/archive/nixos-14.12.tar.gz) {};
+
+      stdenv.mkDerivation { … }
+      ```
+
+      The fetched tarball is cached for a certain amount of time (1
+      hour by default) in `~/.cache/nix/tarballs/`. You can change the
+      cache timeout either on the command line with `--tarball-ttl`
+      *number-of-seconds* or in the Nix configuration file by adding
+      the line `tarball-ttl = ` *number-of-seconds*.
+
+      Note that when obtaining the hash with `nix-prefetch-url` the
+      option `--unpack` is required.
+
+      This function can also verify the contents against a hash. In that
+      case, the function takes a set instead of a URL. The set requires
+      the attribute `url` and the attribute `sha256`, e.g.
+
+      ```nix
+      with import (fetchTarball {
+        url = "https://github.com/NixOS/nixpkgs/archive/nixos-14.12.tar.gz";
+        sha256 = "1jppksrfvbk5ypiqdz4cddxdl8z6zyzdb2srq8fcffr327ld5jj2";
+      }) {};
+
+      stdenv.mkDerivation { … }
+      ```
+
+      Not available in [restricted evaluation mode](@docroot@/command-ref/conf-file.md#conf-restrict-eval).
+    )",
+    .fun = prim_fetchTarball,
+});
+
+static void prim_fetchGit(EvalState & state, const PosIdx pos, Value * * args, Value & v)
+{
+    fetchTree(state, pos, args, v,
+        FetchTreeParams {
+            .emptyRevFallback = true,
+            .allowNameArgument = true,
+            .isFetchGit = true
+        });
+}
+
+static RegisterPrimOp primop_fetchGit({
+    .name = "fetchGit",
+    .args = {"args"},
+    .doc = R"(
+      Fetch a path from git. *args* can be a URL, in which case the HEAD
+      of the repo at that URL is fetched. Otherwise, it can be an
+      attribute with the following attributes (all except `url` optional):
+
+      - `url`
+
+        The URL of the repo.
+
+      - `name` (default: `source`)
+
+        The name of the directory the repo should be exported to in the store.
+
+      - `rev` (default: *the tip of `ref`*)
+
+        The [Git revision] to fetch.
+        This is typically a commit hash.
+
+        [Git revision]: https://git-scm.com/docs/git-rev-parse#_specifying_revisions
+
+      - `ref` (default: `HEAD`)
+
+        The [Git reference] under which to look for the requested revision.
+        This is often a branch or tag name.
+
+        [Git reference]: https://git-scm.com/book/en/v2/Git-Internals-Git-References
+
+        This option has no effect once `shallow` cloning is enabled.
+
+        By default, the `ref` value is prefixed with `refs/heads/`.
+        As of 2.3.0, Nix will not prefix `refs/heads/` if `ref` starts with `refs/`.
+
+      - `submodules` (default: `false`)
+
+        A Boolean parameter that specifies whether submodules should be checked out.
+
+      - `exportIgnore` (default: `true`)
+
+        A Boolean parameter that specifies whether `export-ignore` from `.gitattributes` should be applied.
+        This approximates part of the `git archive` behavior.
+
+        Enabling this option is not recommended because it is unknown whether the Git developers commit to the reproducibility of `export-ignore` in newer Git versions.
+
+      - `shallow` (default: `false`)
+
+        Make a shallow clone when fetching the Git tree.
+        When this is enabled, the options `ref` and `allRefs` have no effect anymore.
+      - `allRefs`
+
+        Whether to fetch all references (eg. branches and tags) of the repository.
+        With this argument being true, it's possible to load a `rev` from *any* `ref`.
+        (by default only `rev`s from the specified `ref` are supported).
+
+        This option has no effect once `shallow` cloning is enabled.
+
+      - `verifyCommit` (default: `true` if `publicKey` or `publicKeys` are provided, otherwise `false`)
+
+        Whether to check `rev` for a signature matching `publicKey` or `publicKeys`.
+        If `verifyCommit` is enabled, then `fetchGit` cannot use a local repository with uncommitted changes.
+        Requires the [`verified-fetches` experimental feature](@docroot@/development/experimental-features.md#xp-feature-verified-fetches).
+
+      - `publicKey`
+
+        The public key against which `rev` is verified if `verifyCommit` is enabled.
+        Requires the [`verified-fetches` experimental feature](@docroot@/development/experimental-features.md#xp-feature-verified-fetches).
+
+      - `keytype` (default: `"ssh-ed25519"`)
+
+        The key type of `publicKey`.
+        Possible values:
+        - `"ssh-dsa"`
+        - `"ssh-ecdsa"`
+        - `"ssh-ecdsa-sk"`
+        - `"ssh-ed25519"`
+        - `"ssh-ed25519-sk"`
+        - `"ssh-rsa"`
+        Requires the [`verified-fetches` experimental feature](@docroot@/development/experimental-features.md#xp-feature-verified-fetches).
+
+      - `publicKeys`
+
+        The public keys against which `rev` is verified if `verifyCommit` is enabled.
+        Must be given as a list of attribute sets with the following form:
+
+        ```nix
+        {
+          key = "<public key>";
+          type = "<key type>"; # optional, default: "ssh-ed25519"
+        }
+        ```
+
+        Requires the [`verified-fetches` experimental feature](@docroot@/development/experimental-features.md#xp-feature-verified-fetches).
+
+
+      Here are some examples of how to use `fetchGit`.
+
+        - To fetch a private repository over SSH:
+
+          ```nix
+          builtins.fetchGit {
+            url = "git@github.com:my-secret/repository.git";
+            ref = "master";
+            rev = "adab8b916a45068c044658c4158d81878f9ed1c3";
+          }
+          ```
+
+        - To fetch an arbitrary reference:
+
+          ```nix
+          builtins.fetchGit {
+            url = "https://github.com/NixOS/nix.git";
+            ref = "refs/heads/0.5-release";
+          }
+          ```
+
+        - If the revision you're looking for is in the default branch of
+          the git repository you don't strictly need to specify the branch
+          name in the `ref` attribute.
+
+          However, if the revision you're looking for is in a future
+          branch for the non-default branch you will need to specify the
+          the `ref` attribute as well.
+
+          ```nix
+          builtins.fetchGit {
+            url = "https://github.com/nixos/nix.git";
+            rev = "841fcbd04755c7a2865c51c1e2d3b045976b7452";
+            ref = "1.11-maintenance";
+          }
+          ```
+
+          > **Note**
+          >
+          > It is nice to always specify the branch which a revision
+          > belongs to. Without the branch being specified, the fetcher
+          > might fail if the default branch changes. Additionally, it can
+          > be confusing to try a commit from a non-default branch and see
+          > the fetch fail. If the branch is specified the fault is much
+          > more obvious.
+
+        - If the revision you're looking for is in the default branch of
+          the git repository you may omit the `ref` attribute.
+
+          ```nix
+          builtins.fetchGit {
+            url = "https://github.com/nixos/nix.git";
+            rev = "841fcbd04755c7a2865c51c1e2d3b045976b7452";
+          }
+          ```
+
+        - To fetch a specific tag:
+
+          ```nix
+          builtins.fetchGit {
+            url = "https://github.com/nixos/nix.git";
+            ref = "refs/tags/1.9";
+          }
+          ```
+
+        - To fetch the latest version of a remote branch:
+
+          ```nix
+          builtins.fetchGit {
+            url = "ssh://git@github.com/nixos/nix.git";
+            ref = "master";
+          }
+          ```
+
+        - To verify the commit signature:
+
+          ```nix
+          builtins.fetchGit {
+            url = "ssh://git@github.com/nixos/nix.git";
+            verifyCommit = true;
+            publicKeys = [
+                {
+                  type = "ssh-ed25519";
+                  key = "AAAAC3NzaC1lZDI1NTE5AAAAIArPKULJOid8eS6XETwUjO48/HKBWl7FTCK0Z//fplDi";
+                }
+            ];
+          }
+          ```
+
+          Nix will refetch the branch according to the [`tarball-ttl`](@docroot@/command-ref/conf-file.md#conf-tarball-ttl) setting.
+
+          This behavior is disabled in [pure evaluation mode](@docroot@/command-ref/conf-file.md#conf-pure-eval).
+
+        - To fetch the content of a checked-out work directory:
+
+          ```nix
+          builtins.fetchGit ./work-dir
+          ```
+
+      If the URL points to a local directory, and no `ref` or `rev` is
+      given, `fetchGit` will use the current content of the checked-out
+      files, even if they are not committed or added to Git's index. It will
+      only consider files added to the Git repository, as listed by `git ls-files`.
+    )",
+    .fun = prim_fetchGit,
+});
+
+}

subprojects/libexpr/primops/fromTOML.cc

@@ -0,0 +1,110 @@
+#include "primops.hh"
+#include "eval-inline.hh"
+
+#include <sstream>
+
+#include <toml.hpp>
+
+namespace nix {
+
+static void prim_fromTOML(EvalState & state, const PosIdx pos, Value * * args, Value & val)
+{
+    auto toml = state.forceStringNoCtx(*args[0], pos, "while evaluating the argument passed to builtins.fromTOML");
+
+    std::istringstream tomlStream(std::string{toml});
+
+    std::function<void(Value &, toml::value)> visit;
+
+    visit = [&](Value & v, toml::value t) {
+
+        switch(t.type())
+        {
+            case toml::value_t::table:
+                {
+                    auto table = toml::get<toml::table>(t);
+
+                    size_t size = 0;
+                    for (auto & i : table) { (void) i; size++; }
+
+                    auto attrs = state.buildBindings(size);
+
+                    for(auto & elem : table)
+                        visit(attrs.alloc(elem.first), elem.second);
+
+                    v.mkAttrs(attrs);
+                }
+                break;;
+            case toml::value_t::array:
+                {
+                    auto array = toml::get<std::vector<toml::value>>(t);
+
+                    auto list = state.buildList(array.size());
+                    for (const auto & [n, v] : enumerate(list))
+                        visit(*(v = state.allocValue()), array[n]);
+                    v.mkList(list);
+                }
+                break;;
+            case toml::value_t::boolean:
+                v.mkBool(toml::get<bool>(t));
+                break;;
+            case toml::value_t::integer:
+                v.mkInt(toml::get<int64_t>(t));
+                break;;
+            case toml::value_t::floating:
+                v.mkFloat(toml::get<NixFloat>(t));
+                break;;
+            case toml::value_t::string:
+                v.mkString(toml::get<std::string>(t));
+                break;;
+            case toml::value_t::local_datetime:
+            case toml::value_t::offset_datetime:
+            case toml::value_t::local_date:
+            case toml::value_t::local_time:
+                {
+                    if (experimentalFeatureSettings.isEnabled(Xp::ParseTomlTimestamps)) {
+                        auto attrs = state.buildBindings(2);
+                        attrs.alloc("_type").mkString("timestamp");
+                        std::ostringstream s;
+                        s << t;
+                        attrs.alloc("value").mkString(s.str());
+                        v.mkAttrs(attrs);
+                    } else {
+                        throw std::runtime_error("Dates and times are not supported");
+                    }
+                }
+                break;;
+            case toml::value_t::empty:
+                v.mkNull();
+                break;;
+
+        }
+    };
+
+    try {
+        visit(val, toml::parse(tomlStream, "fromTOML" /* the "filename" */));
+    } catch (std::exception & e) { // TODO: toml::syntax_error
+        state.error<EvalError>("while parsing TOML: %s", e.what()).atPos(pos).debugThrow();
+    }
+}
+
+static RegisterPrimOp primop_fromTOML({
+    .name = "fromTOML",
+    .args = {"e"},
+    .doc = R"(
+      Convert a TOML string to a Nix value. For example,
+
+      ```nix
+      builtins.fromTOML ''
+        x=1
+        s="a"
+        [table]
+        y=2
+      ''
+      ```
+
+      returns the value `{ s = "a"; table = { y = 2; }; x = 1; }`.
+    )",
+    .fun = prim_fromTOML
+});
+
+}

subprojects/libexpr/primops/meson.build

@@ -0,0 +1,12 @@
+generated_headers += gen_header.process(
+  'derivation.nix',
+  preserve_path_from: meson.project_source_root(),
+)
+
+sources += files(
+  'context.cc',
+  'fetchClosure.cc',
+  'fetchMercurial.cc',
+  'fetchTree.cc',
+  'fromTOML.cc',
+)

subprojects/libexpr/print-ambiguous.cc

@@ -0,0 +1,101 @@
+#include "print-ambiguous.hh"
+#include "print.hh"
+#include "signals.hh"
+#include "eval.hh"
+
+namespace nix {
+
+// See: https://github.com/NixOS/nix/issues/9730
+void printAmbiguous(
+    Value &v,
+    const SymbolTable &symbols,
+    std::ostream &str,
+    std::set<const void *> *seen,
+    int depth)
+{
+    checkInterrupt();
+
+    if (depth <= 0) {
+        str << "«too deep»";
+        return;
+    }
+    switch (v.type()) {
+    case nInt:
+        str << v.integer();
+        break;
+    case nBool:
+        printLiteralBool(str, v.boolean());
+        break;
+    case nString:
+        printLiteralString(str, v.string_view());
+        break;
+    case nPath:
+        str << v.path().to_string(); // !!! escaping?
+        break;
+    case nNull:
+        str << "null";
+        break;
+    case nAttrs: {
+        if (seen && !v.attrs()->empty() && !seen->insert(v.attrs()).second)
+            str << "«repeated»";
+        else {
+            str << "{ ";
+            for (auto & i : v.attrs()->lexicographicOrder(symbols)) {
+                str << symbols[i->name] << " = ";
+                printAmbiguous(*i->value, symbols, str, seen, depth - 1);
+                str << "; ";
+            }
+            str << "}";
+        }
+        break;
+    }
+    case nList:
+        if (seen && v.listSize() && !seen->insert(v.listElems()).second)
+            str << "«repeated»";
+        else {
+            str << "[ ";
+            for (auto v2 : v.listItems()) {
+                if (v2)
+                    printAmbiguous(*v2, symbols, str, seen, depth - 1);
+                else
+                    str << "(nullptr)";
+                str << " ";
+            }
+            str << "]";
+        }
+        break;
+    case nThunk:
+        if (!v.isBlackhole()) {
+            str << "<CODE>";
+        } else {
+            // Although we know for sure that it's going to be an infinite recursion
+            // when this value is accessed _in the current context_, it's likely
+            // that the user will misinterpret a simpler «infinite recursion» output
+            // as a definitive statement about the value, while in fact it may be
+            // a valid value after `builtins.trace` and perhaps some other steps
+            // have completed.
+            str << "«potential infinite recursion»";
+        }
+        break;
+    case nFunction:
+        if (v.isLambda()) {
+            str << "<LAMBDA>";
+        } else if (v.isPrimOp()) {
+            str << "<PRIMOP>";
+        } else if (v.isPrimOpApp()) {
+            str << "<PRIMOP-APP>";
+        }
+        break;
+    case nExternal:
+        str << *v.external();
+        break;
+    case nFloat:
+        str << v.fpoint();
+        break;
+    default:
+        printError("Nix evaluator internal error: printAmbiguous: invalid value type");
+        unreachable();
+    }
+}
+
+}

subprojects/libexpr/print-ambiguous.hh

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "value.hh"
+
+namespace nix {
+
+/**
+ * Print a value in the deprecated format used by `nix-instantiate --eval` and
+ * `nix-env` (for manifests).
+ *
+ * This output can't be changed because it's part of the `nix-instantiate` API,
+ * but it produces ambiguous output; unevaluated thunks and lambdas (and a few
+ * other types) are printed as Nix path syntax like `<CODE>`.
+ *
+ * See: https://github.com/NixOS/nix/issues/9730
+ */
+void printAmbiguous(
+    Value &v,
+    const SymbolTable &symbols,
+    std::ostream &str,
+    std::set<const void *> *seen,
+    int depth);
+
+}

subprojects/libexpr/print-options.hh

@@ -0,0 +1,120 @@
+#pragma once
+/**
+ * @file
+ * @brief Options for printing Nix values.
+ */
+
+#include <limits>
+
+namespace nix {
+
+/**
+ * How errors should be handled when printing values.
+ */
+enum class ErrorPrintBehavior {
+    /**
+     * Print the first line of the error in brackets: `«error: oh no!»`
+     */
+    Print,
+    /**
+     * Throw the error to the code that attempted to print the value, instead
+     * of suppressing it it.
+     */
+    Throw,
+    /**
+     * Only throw the error if encountered at the top level of the expression.
+     *
+     * This will cause expressions like `builtins.throw "uh oh!"` to throw
+     * errors, but will print attribute sets and other nested structures
+     * containing values that error (like `nixpkgs`) normally.
+     */
+    ThrowTopLevel,
+};
+
+/**
+ * Options for printing Nix values.
+ */
+struct PrintOptions
+{
+    /**
+     * If true, output ANSI color sequences.
+     */
+    bool ansiColors = false;
+
+    /**
+     * If true, force values.
+     */
+    bool force = false;
+
+    /**
+     * If true and `force` is set, print derivations as
+     * `«derivation /nix/store/...»` instead of as attribute sets.
+     */
+    bool derivationPaths = false;
+
+    /**
+     * If true, track which values have been printed and skip them on
+     * subsequent encounters. Useful for self-referential values.
+     */
+    bool trackRepeated = true;
+
+    /**
+     * Maximum depth to evaluate to.
+     */
+    size_t maxDepth = std::numeric_limits<size_t>::max();
+
+    /**
+     * Maximum number of attributes in attribute sets to print.
+     *
+     * Note that this is a limit for the entire print invocation, not for each
+     * attribute set encountered.
+     */
+    size_t maxAttrs = std::numeric_limits<size_t>::max();
+
+    /**
+     * Maximum number of list items to print.
+     *
+     * Note that this is a limit for the entire print invocation, not for each
+     * list encountered.
+     */
+    size_t maxListItems = std::numeric_limits<size_t>::max();
+
+    /**
+     * Maximum string length to print.
+     */
+    size_t maxStringLength = std::numeric_limits<size_t>::max();
+
+    /**
+     * Indentation width for pretty-printing.
+     *
+     * If set to 0 (the default), values are not pretty-printed.
+     */
+    size_t prettyIndent = 0;
+
+    /**
+     * How to handle errors encountered while printing values.
+     */
+    ErrorPrintBehavior errors = ErrorPrintBehavior::Print;
+
+    /**
+     * True if pretty-printing is enabled.
+     */
+    inline bool shouldPrettyPrint()
+    {
+        return prettyIndent > 0;
+    }
+};
+
+/**
+ * `PrintOptions` for unknown and therefore potentially large values in error messages,
+ * to avoid printing "too much" output.
+ */
+static PrintOptions errorPrintOptions = PrintOptions {
+    .ansiColors = true,
+    .maxDepth = 10,
+    .maxAttrs = 10,
+    .maxListItems = 10,
+    .maxStringLength = 1024,
+};
+
+}

subprojects/libexpr/print.cc

@@ -0,0 +1,643 @@
+#include <limits>
+#include <unordered_set>
+#include <sstream>
+
+#include "print.hh"
+#include "ansicolor.hh"
+#include "signals.hh"
+#include "store-api.hh"
+#include "terminal.hh"
+#include "english.hh"
+#include "eval.hh"
+
+namespace nix {
+
+void printElided(
+    std::ostream & output,
+    unsigned int value,
+    const std::string_view single,
+    const std::string_view plural,
+    bool ansiColors)
+{
+    if (ansiColors)
+        output << ANSI_FAINT;
+    output << "«";
+    pluralize(output, value, single, plural);
+    output << " elided»";
+    if (ansiColors)
+        output << ANSI_NORMAL;
+}
+
+
+std::ostream &
+printLiteralString(std::ostream & str, const std::string_view string, size_t maxLength, bool ansiColors)
+{
+    size_t charsPrinted = 0;
+    if (ansiColors)
+        str << ANSI_MAGENTA;
+    str << "\"";
+    for (auto i = string.begin(); i != string.end(); ++i) {
+        if (charsPrinted >= maxLength) {
+            str << "\" ";
+            printElided(str, string.length() - charsPrinted, "byte", "bytes", ansiColors);
+            return str;
+        }
+
+        if (*i == '\"' || *i == '\\') str << "\\" << *i;
+        else if (*i == '\n') str << "\\n";
+        else if (*i == '\r') str << "\\r";
+        else if (*i == '\t') str << "\\t";
+        else if (*i == '$' && *(i+1) == '{') str << "\\" << *i;
+        else str << *i;
+        charsPrinted++;
+    }
+    str << "\"";
+    if (ansiColors)
+        str << ANSI_NORMAL;
+    return str;
+}
+
+std::ostream &
+printLiteralString(std::ostream & str, const std::string_view string)
+{
+    return printLiteralString(str, string, std::numeric_limits<size_t>::max(), false);
+}
+
+std::ostream &
+printLiteralBool(std::ostream & str, bool boolean)
+{
+    str << (boolean ? "true" : "false");
+    return str;
+}
+
+// Returns `true' is a string is a reserved keyword which requires quotation
+// when printing attribute set field names.
+//
+// This list should generally be kept in sync with `./lexer.l'.
+// You can test if a keyword needs to be added by running:
+//   $ nix eval --expr '{ <KEYWORD> = 1; }'
+// For example `or' doesn't need to be quoted.
+bool isReservedKeyword(const std::string_view str)
+{
+    static const std::unordered_set<std::string_view> reservedKeywords = {
+        "if", "then", "else", "assert", "with", "let", "in", "rec", "inherit"
+    };
+    return reservedKeywords.contains(str);
+}
+
+std::ostream &
+printIdentifier(std::ostream & str, std::string_view s) {
+    if (s.empty())
+        str << "\"\"";
+    else if (isReservedKeyword(s))
+        str << '"' << s << '"';
+    else {
+        char c = s[0];
+        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')) {
+            printLiteralString(str, s);
+            return str;
+        }
+        for (auto c : s)
+            if (!((c >= 'a' && c <= 'z') ||
+                  (c >= 'A' && c <= 'Z') ||
+                  (c >= '0' && c <= '9') ||
+                  c == '_' || c == '\'' || c == '-')) {
+                printLiteralString(str, s);
+                return str;
+            }
+        str << s;
+    }
+    return str;
+}
+
+static bool isVarName(std::string_view s)
+{
+    if (s.size() == 0) return false;
+    if (isReservedKeyword(s)) return false;
+    char c = s[0];
+    if ((c >= '0' && c <= '9') || c == '-' || c == '\'') return false;
+    for (auto & i : s)
+        if (!((i >= 'a' && i <= 'z') ||
+              (i >= 'A' && i <= 'Z') ||
+              (i >= '0' && i <= '9') ||
+              i == '_' || i == '-' || i == '\''))
+            return false;
+    return true;
+}
+
+std::ostream &
+printAttributeName(std::ostream & str, std::string_view name) {
+    if (isVarName(name))
+        str << name;
+    else
+        printLiteralString(str, name);
+    return str;
+}
+
+bool isImportantAttrName(const std::string& attrName)
+{
+    return attrName == "type" || attrName == "_type";
+}
+
+typedef std::pair<std::string, Value *> AttrPair;
+
+struct ImportantFirstAttrNameCmp
+{
+
+    bool operator()(const AttrPair& lhs, const AttrPair& rhs) const
+    {
+        auto lhsIsImportant = isImportantAttrName(lhs.first);
+        auto rhsIsImportant = isImportantAttrName(rhs.first);
+        return std::forward_as_tuple(!lhsIsImportant, lhs.first)
+            < std::forward_as_tuple(!rhsIsImportant, rhs.first);
+    }
+};
+
+typedef std::set<const void *> ValuesSeen;
+typedef std::vector<std::pair<std::string, Value *>> AttrVec;
+
+class Printer
+{
+private:
+    std::ostream & output;
+    EvalState & state;
+    PrintOptions options;
+    std::optional<ValuesSeen> seen;
+    size_t totalAttrsPrinted = 0;
+    size_t totalListItemsPrinted = 0;
+    std::string indent;
+
+    void increaseIndent()
+    {
+        if (options.shouldPrettyPrint()) {
+            indent.append(options.prettyIndent, ' ');
+        }
+    }
+
+    void decreaseIndent()
+    {
+        if (options.shouldPrettyPrint()) {
+            assert(indent.size() >= options.prettyIndent);
+            indent.resize(indent.size() - options.prettyIndent);
+        }
+    }
+
+    /**
+     * Print a space (for separating items or attributes).
+     *
+     * If pretty-printing is enabled, a newline and the current `indent` is
+     * printed instead.
+     */
+    void printSpace(bool prettyPrint)
+    {
+        if (prettyPrint) {
+            output << "\n" << indent;
+        } else {
+            output << " ";
+        }
+    }
+
+    void printRepeated()
+    {
+        if (options.ansiColors)
+            output << ANSI_MAGENTA;
+        output << "«repeated»";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printNullptr()
+    {
+        if (options.ansiColors)
+            output << ANSI_MAGENTA;
+        output << "«nullptr»";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printElided(unsigned int value, const std::string_view single, const std::string_view plural)
+    {
+        ::nix::printElided(output, value, single, plural, options.ansiColors);
+    }
+
+    void printInt(Value & v)
+    {
+        if (options.ansiColors)
+            output << ANSI_CYAN;
+        output << v.integer();
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printFloat(Value & v)
+    {
+        if (options.ansiColors)
+            output << ANSI_CYAN;
+        output << v.fpoint();
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printBool(Value & v)
+    {
+        if (options.ansiColors)
+            output << ANSI_CYAN;
+        printLiteralBool(output, v.boolean());
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printString(Value & v)
+    {
+        printLiteralString(output, v.string_view(), options.maxStringLength, options.ansiColors);
+    }
+
+    void printPath(Value & v)
+    {
+        if (options.ansiColors)
+            output << ANSI_GREEN;
+        output << v.path().to_string(); // !!! escaping?
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printNull()
+    {
+        if (options.ansiColors)
+            output << ANSI_CYAN;
+        output << "null";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printDerivation(Value & v)
+    {
+        std::optional<StorePath> storePath;
+        if (auto i = v.attrs()->get(state.sDrvPath)) {
+            NixStringContext context;
+            storePath = state.coerceToStorePath(i->pos, *i->value, context, "while evaluating the drvPath of a derivation");
+        }
+
+        /* This unfortunately breaks printing nested values because of
+           how the pretty printer is used (when pretting printing and warning
+           to same terminal / std stream). */
+#if 0
+        if (storePath && !storePath->isDerivation())
+            warn(
+                "drvPath attribute '%s' is not a valid store path to a derivation, this value not work properly",
+                state.store->printStorePath(*storePath));
+#endif
+
+        if (options.ansiColors)
+            output << ANSI_GREEN;
+        output << "«derivation";
+        if (storePath) {
+            output << " " << state.store->printStorePath(*storePath);
+        }
+        output << "»";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    /**
+     * @note This may force items.
+     */
+    bool shouldPrettyPrintAttrs(AttrVec & v)
+    {
+        if (!options.shouldPrettyPrint() || v.empty()) {
+            return false;
+        }
+
+        // Pretty-print attrsets with more than one item.
+        if (v.size() > 1) {
+            return true;
+        }
+
+        auto item = v[0].second;
+        if (!item) {
+            return true;
+        }
+
+        // It is ok to force the item(s) here, because they will be printed anyway.
+        state.forceValue(*item, item->determinePos(noPos));
+
+        // Pretty-print single-item attrsets only if they contain nested
+        // structures.
+        auto itemType = item->type();
+        return itemType == nList || itemType == nAttrs || itemType == nThunk;
+    }
+
+    void printAttrs(Value & v, size_t depth)
+    {
+        if (seen && !seen->insert(v.attrs()).second) {
+            printRepeated();
+            return;
+        }
+
+        if (options.force && options.derivationPaths && state.isDerivation(v)) {
+            printDerivation(v);
+        } else if (depth < options.maxDepth) {
+            increaseIndent();
+            output << "{";
+
+            AttrVec sorted;
+            for (auto & i : *v.attrs())
+                sorted.emplace_back(std::pair(state.symbols[i.name], i.value));
+
+            if (options.maxAttrs == std::numeric_limits<size_t>::max())
+                std::sort(sorted.begin(), sorted.end());
+            else
+                std::sort(sorted.begin(), sorted.end(), ImportantFirstAttrNameCmp());
+
+            auto prettyPrint = shouldPrettyPrintAttrs(sorted);
+
+            size_t currentAttrsPrinted = 0;
+
+            for (auto & i : sorted) {
+                printSpace(prettyPrint);
+
+                if (totalAttrsPrinted >= options.maxAttrs) {
+                    printElided(sorted.size() - currentAttrsPrinted, "attribute", "attributes");
+                    break;
+                }
+
+                printAttributeName(output, i.first);
+                output << " = ";
+                print(*i.second, depth + 1);
+                output << ";";
+                totalAttrsPrinted++;
+                currentAttrsPrinted++;
+            }
+
+            decreaseIndent();
+            printSpace(prettyPrint);
+            output << "}";
+        } else {
+            output << "{ ... }";
+        }
+    }
+
+    /**
+     * @note This may force items.
+     */
+    bool shouldPrettyPrintList(std::span<Value * const> list)
+    {
+        if (!options.shouldPrettyPrint() || list.empty()) {
+            return false;
+        }
+
+        // Pretty-print lists with more than one item.
+        if (list.size() > 1) {
+            return true;
+        }
+
+        auto item = list[0];
+        if (!item) {
+            return true;
+        }
+
+        // It is ok to force the item(s) here, because they will be printed anyway.
+        state.forceValue(*item, item->determinePos(noPos));
+
+        // Pretty-print single-item lists only if they contain nested
+        // structures.
+        auto itemType = item->type();
+        return itemType == nList || itemType == nAttrs || itemType == nThunk;
+    }
+
+    void printList(Value & v, size_t depth)
+    {
+        if (seen && v.listSize() && !seen->insert(&v).second) {
+            printRepeated();
+            return;
+        }
+
+        if (depth < options.maxDepth) {
+            increaseIndent();
+            output << "[";
+            auto listItems = v.listItems();
+            auto prettyPrint = shouldPrettyPrintList(listItems);
+
+            size_t currentListItemsPrinted = 0;
+
+            for (auto elem : listItems) {
+                printSpace(prettyPrint);
+
+                if (totalListItemsPrinted >= options.maxListItems) {
+                    printElided(listItems.size() - currentListItemsPrinted, "item", "items");
+                    break;
+                }
+
+                if (elem) {
+                    print(*elem, depth + 1);
+                } else {
+                    printNullptr();
+                }
+                totalListItemsPrinted++;
+                currentListItemsPrinted++;
+            }
+
+            decreaseIndent();
+            printSpace(prettyPrint);
+            output << "]";
+        } else {
+            output << "[ ... ]";
+        }
+    }
+
+    void printFunction(Value & v)
+    {
+        if (options.ansiColors)
+            output << ANSI_BLUE;
+        output << "«";
+
+        if (v.isLambda()) {
+            output << "lambda";
+            if (v.payload.lambda.fun) {
+                if (v.payload.lambda.fun->name) {
+                    output << " " << state.symbols[v.payload.lambda.fun->name];
+                }
+
+                std::ostringstream s;
+                s << state.positions[v.payload.lambda.fun->pos];
+                output << " @ " << filterANSIEscapes(s.str());
+            }
+        } else if (v.isPrimOp()) {
+            if (v.primOp())
+                output << *v.primOp();
+            else
+                output << "primop";
+        } else if (v.isPrimOpApp()) {
+            output << "partially applied ";
+            auto primOp = v.primOpAppPrimOp();
+            if (primOp)
+                output << *primOp;
+            else
+                output << "primop";
+        } else {
+            unreachable();
+        }
+
+        output << "»";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printThunk(Value & v)
+    {
+        if (v.isBlackhole()) {
+            // Although we know for sure that it's going to be an infinite recursion
+            // when this value is accessed _in the current context_, it's likely
+            // that the user will misinterpret a simpler «infinite recursion» output
+            // as a definitive statement about the value, while in fact it may be
+            // a valid value after `builtins.trace` and perhaps some other steps
+            // have completed.
+            if (options.ansiColors)
+                output << ANSI_RED;
+            output << "«potential infinite recursion»";
+            if (options.ansiColors)
+                output << ANSI_NORMAL;
+        } else if (v.isThunk() || v.isApp()) {
+            if (options.ansiColors)
+                    output << ANSI_MAGENTA;
+            output << "«thunk»";
+            if (options.ansiColors)
+                    output << ANSI_NORMAL;
+        } else {
+            unreachable();
+        }
+    }
+
+    void printExternal(Value & v)
+    {
+        v.external()->print(output);
+    }
+
+    void printUnknown()
+    {
+        if (options.ansiColors)
+            output << ANSI_RED;
+        output << "«unknown»";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void printError_(Error & e)
+    {
+        if (options.ansiColors)
+            output << ANSI_RED;
+        output << "«error: " << filterANSIEscapes(e.info().msg.str(), true) << "»";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
+    }
+
+    void print(Value & v, size_t depth)
+    {
+        output.flush();
+        checkInterrupt();
+
+        try {
+            if (options.force) {
+                state.forceValue(v, v.determinePos(noPos));
+            }
+
+            switch (v.type()) {
+
+            case nInt:
+                printInt(v);
+                break;
+
+            case nFloat:
+                printFloat(v);
+                break;
+
+            case nBool:
+                printBool(v);
+                break;
+
+            case nString:
+                printString(v);
+                break;
+
+            case nPath:
+                printPath(v);
+                break;
+
+            case nNull:
+                printNull();
+                break;
+
+            case nAttrs:
+                printAttrs(v, depth);
+                break;
+
+            case nList:
+                printList(v, depth);
+                break;
+
+            case nFunction:
+                printFunction(v);
+                break;
+
+            case nThunk:
+                printThunk(v);
+                break;
+
+            case nExternal:
+                printExternal(v);
+                break;
+
+            default:
+                printUnknown();
+                break;
+            }
+        } catch (Error & e) {
+            if (options.errors == ErrorPrintBehavior::Throw
+                || (options.errors == ErrorPrintBehavior::ThrowTopLevel
+                    && depth == 0)) {
+                throw;
+            }
+            printError_(e);
+        }
+    }
+
+public:
+    Printer(std::ostream & output, EvalState & state, PrintOptions options)
+        : output(output), state(state), options(options) { }
+
+    void print(Value & v)
+    {
+        totalAttrsPrinted = 0;
+        totalListItemsPrinted = 0;
+        indent.clear();
+
+        if (options.trackRepeated) {
+            seen.emplace();
+        } else {
+            seen.reset();
+        }
+
+        ValuesSeen seen;
+        print(v, 0);
+    }
+};
+
+void printValue(EvalState & state, std::ostream & output, Value & v, PrintOptions options)
+{
+    Printer(output, state, options).print(v);
+}
+
+std::ostream & operator<<(std::ostream & output, const ValuePrinter & printer)
+{
+    printValue(printer.state, output, printer.value, printer.options);
+    return output;
+}
+
+template<>
+HintFmt & HintFmt::operator%(const ValuePrinter & value)
+{
+        fmt % value;
+        return *this;
+}
+
+}

subprojects/libexpr/print.hh

@@ -0,0 +1,91 @@
+#pragma once
+/**
+ * @file
+ * @brief Common printing functions for the Nix language
+ *
+ * While most types come with their own methods for printing, they share some
+ * functions that are placed here.
+ */
+
+#include <iostream>
+
+#include "fmt.hh"
+#include "print-options.hh"
+
+namespace nix {
+
+class EvalState;
+struct Value;
+
+/**
+ * Print a string as a Nix string literal.
+ *
+ * Quotes and fairly minimal escaping are added.
+ *
+ * @param o The output stream to print to
+ * @param s The logical string
+ */
+std::ostream & printLiteralString(std::ostream & o, std::string_view s);
+inline std::ostream & printLiteralString(std::ostream & o, const char * s) {
+    return printLiteralString(o, std::string_view(s));
+}
+inline std::ostream & printLiteralString(std::ostream & o, const std::string & s) {
+    return printLiteralString(o, std::string_view(s));
+}
+
+/** Print `true` or `false`. */
+std::ostream & printLiteralBool(std::ostream & o, bool b);
+
+/**
+ * Print a string as an attribute name in the Nix expression language syntax.
+ *
+ * Prints a quoted string if necessary.
+ */
+std::ostream & printAttributeName(std::ostream & o, std::string_view s);
+
+/**
+ * Returns `true' is a string is a reserved keyword which requires quotation
+ * when printing attribute set field names.
+ */
+bool isReservedKeyword(const std::string_view str);
+
+/**
+ * Print a string as an identifier in the Nix expression language syntax.
+ *
+ * FIXME: "identifier" is ambiguous. Identifiers do not have a single
+ *        textual representation. They can be used in variable references,
+ *        let bindings, left-hand sides or attribute names in a select
+ *        expression, or something else entirely, like JSON. Use one of the
+ *        `print*` functions instead.
+ */
+std::ostream & printIdentifier(std::ostream & o, std::string_view s);
+
+void printValue(EvalState & state, std::ostream & str, Value & v, PrintOptions options = PrintOptions {});
+
+/**
+ * A partially-applied form of `printValue` which can be formatted using `<<`
+ * without allocating an intermediate string.
+ */
+class ValuePrinter {
+    friend std::ostream & operator << (std::ostream & output, const ValuePrinter & printer);
+private:
+    EvalState & state;
+    Value & value;
+    PrintOptions options;
+
+public:
+    ValuePrinter(EvalState & state, Value & value, PrintOptions options = PrintOptions {})
+        : state(state), value(value), options(options) { }
+};
+
+std::ostream & operator<<(std::ostream & output, const ValuePrinter & printer);
+
+
+/**
+ * `ValuePrinter` does its own ANSI formatting, so we don't color it
+ * magenta.
+ */
+template<>
+HintFmt & HintFmt::operator%(const ValuePrinter & value);
+
+}

subprojects/libexpr/repl-exit-status.hh

@@ -0,0 +1,20 @@
+#pragma once
+
+namespace nix {
+
+/**
+ * Exit status returned from the REPL.
+ */
+enum class ReplExitStatus {
+    /**
+     * The user exited with `:quit`. The program (e.g., if the REPL was acting
+     * as the debugger) should exit.
+     */
+    QuitAll,
+    /**
+     * The user exited with `:continue`. The program should continue running.
+     */
+    Continue,
+};
+
+}

subprojects/libexpr/search-path.cc

@@ -0,0 +1,55 @@
+#include "search-path.hh"
+
+namespace nix {
+
+std::optional<std::string_view> LookupPath::Prefix::suffixIfPotentialMatch(
+    std::string_view path) const
+{
+    auto n = s.size();
+
+    /* Non-empty prefix and suffix must be separated by a /, or the
+       prefix is not a valid path prefix. */
+    bool needSeparator = n > 0 && n < path.size();
+
+    if (needSeparator && path[n] != '/') {
+        return std::nullopt;
+    }
+
+    /* Prefix must be prefix of this path. */
+    if (path.compare(0, n, s) != 0) {
+        return std::nullopt;
+    }
+
+    /* Skip next path separator. */
+    return {
+        path.substr(needSeparator ? n + 1 : n)
+    };
+}
+
+
+LookupPath::Elem LookupPath::Elem::parse(std::string_view rawElem)
+{
+    size_t pos = rawElem.find('=');
+
+    return LookupPath::Elem {
+        .prefix = Prefix {
+            .s = pos == std::string::npos
+                ? std::string { "" }
+                : std::string { rawElem.substr(0, pos) },
+        },
+        .path = Path {
+            .s = std::string { rawElem.substr(pos + 1) },
+        },
+    };
+}
+
+
+LookupPath LookupPath::parse(const Strings & rawElems)
+{
+    LookupPath res;
+    for (auto & rawElem : rawElems)
+        res.elements.emplace_back(LookupPath::Elem::parse(rawElem));
+    return res;
+}
+
+}

subprojects/libexpr/search-path.hh

@@ -0,0 +1,108 @@
+#pragma once
+///@file
+
+#include <optional>
+
+#include "types.hh"
+#include "comparator.hh"
+
+namespace nix {
+
+/**
+ * A "search path" is a list of ways look for something, used with
+ * `builtins.findFile` and `< >` lookup expressions.
+ */
+struct LookupPath
+{
+    /**
+     * A single element of a `LookupPath`.
+     *
+     * Each element is tried in succession when looking up a path. The first
+     * element to completely match wins.
+     */
+    struct Elem;
+
+    /**
+     * The first part of a `LookupPath::Elem` pair.
+     *
+     * Called a "prefix" because it takes the form of a prefix of a file
+     * path (first `n` path components). When looking up a path, to use
+     * a `LookupPath::Elem`, its `Prefix` must match the path.
+     */
+    struct Prefix;
+
+    /**
+     * The second part of a `LookupPath::Elem` pair.
+     *
+     * It is either a path or a URL (with certain restrictions / extra
+     * structure).
+     *
+     * If the prefix of the path we are looking up matches, we then
+     * check if the rest of the path points to something that exists
+     * within the directory denoted by this. If so, the
+     * `LookupPath::Elem` as a whole matches, and that *something* being
+     * pointed to by the rest of the path we are looking up is the
+     * result.
+     */
+    struct Path;
+
+    /**
+     * The list of search path elements. Each one is checked for a path
+     * when looking up. (The actual lookup entry point is in `EvalState`
+     * not in this class.)
+     */
+    std::list<LookupPath::Elem> elements;
+
+    /**
+     * Parse a string into a `LookupPath`
+     */
+    static LookupPath parse(const Strings & rawElems);
+};
+
+struct LookupPath::Prefix
+{
+    /**
+     * Underlying string
+     *
+     * @todo Should we normalize this when constructing a `LookupPath::Prefix`?
+     */
+    std::string s;
+
+    GENERATE_CMP(LookupPath::Prefix, me->s);
+
+    /**
+     * If the path possibly matches this search path element, return the
+     * suffix that we should look for inside the resolved value of the
+     * element
+     * Note the double optionality in the name. While we might have a matching prefix, the suffix may not exist.
+     */
+    std::optional<std::string_view> suffixIfPotentialMatch(std::string_view path) const;
+};
+
+struct LookupPath::Path
+{
+    /**
+     * The location of a search path item, as a path or URL.
+     *
+     * @todo Maybe change this to `std::variant<SourcePath, URL>`.
+     */
+    std::string s;
+
+    GENERATE_CMP(LookupPath::Path, me->s);
+};
+
+struct LookupPath::Elem
+{
+
+    Prefix prefix;
+    Path path;
+
+    GENERATE_CMP(LookupPath::Elem, me->prefix, me->path);
+
+    /**
+     * Parse a string into a `LookupPath::Elem`
+     */
+    static LookupPath::Elem parse(std::string_view rawElem);
+};
+
+}

subprojects/libexpr/symbol-table.hh

@@ -0,0 +1,146 @@
+#pragma once
+///@file
+
+#include <list>
+#include <map>
+#include <unordered_map>
+
+#include "types.hh"
+#include "chunked-vector.hh"
+#include "error.hh"
+
+namespace nix {
+
+/**
+ * This class mainly exists to give us an operator<< for ostreams. We could also
+ * return plain strings from SymbolTable, but then we'd have to wrap every
+ * instance of a symbol that is fmt()ed, which is inconvenient and error-prone.
+ */
+class SymbolStr
+{
+    friend class SymbolTable;
+
+private:
+    const std::string * s;
+
+    explicit SymbolStr(const std::string & symbol): s(&symbol) {}
+
+public:
+    bool operator == (std::string_view s2) const
+    {
+        return *s == s2;
+    }
+
+    const char * c_str() const
+    {
+        return s->c_str();
+    }
+
+    operator const std::string_view () const
+    {
+        return *s;
+    }
+
+    friend std::ostream & operator <<(std::ostream & os, const SymbolStr & symbol);
+
+    bool empty() const
+    {
+        return s->empty();
+    }
+};
+
+/**
+ * Symbols have the property that they can be compared efficiently
+ * (using an equality test), because the symbol table stores only one
+ * copy of each string.
+ */
+class Symbol
+{
+    friend class SymbolTable;
+
+private:
+    uint32_t id;
+
+    explicit Symbol(uint32_t id): id(id) {}
+
+public:
+    Symbol() : id(0) {}
+
+    explicit operator bool() const { return id > 0; }
+
+    auto operator<=>(const Symbol other) const { return id <=> other.id; }
+    bool operator==(const Symbol other) const { return id == other.id; }
+
+    friend class std::hash<Symbol>;
+};
+
+/**
+ * Symbol table used by the parser and evaluator to represent and look
+ * up identifiers and attributes efficiently.
+ */
+class SymbolTable
+{
+private:
+    std::unordered_map<std::string_view, std::pair<const std::string *, uint32_t>> symbols;
+    ChunkedVector<std::string, 8192> store{16};
+
+public:
+
+    /**
+     * converts a string into a symbol.
+     */
+    Symbol create(std::string_view s)
+    {
+        // Most symbols are looked up more than once, so we trade off insertion performance
+        // for lookup performance.
+        // TODO: could probably be done more efficiently with transparent Hash and Equals
+        // on the original implementation using unordered_set
+        // FIXME: make this thread-safe.
+        auto it = symbols.find(s);
+        if (it != symbols.end()) return Symbol(it->second.second + 1);
+
+        const auto & [rawSym, idx] = store.add(std::string(s));
+        symbols.emplace(rawSym, std::make_pair(&rawSym, idx));
+        return Symbol(idx + 1);
+    }
+
+    std::vector<SymbolStr> resolve(const std::vector<Symbol> & symbols) const
+    {
+        std::vector<SymbolStr> result;
+        result.reserve(symbols.size());
+        for (auto sym : symbols)
+            result.push_back((*this)[sym]);
+        return result;
+    }
+
+    SymbolStr operator[](Symbol s) const
+    {
+        if (s.id == 0 || s.id > store.size())
+            unreachable();
+        return SymbolStr(store[s.id - 1]);
+    }
+
+    size_t size() const
+    {
+        return store.size();
+    }
+
+    size_t totalSize() const;
+
+    template<typename T>
+    void dump(T callback) const
+    {
+        store.forEach(callback);
+    }
+};
+
+}
+
+template<>
+struct std::hash<nix::Symbol>
+{
+    std::size_t operator()(const nix::Symbol & s) const noexcept
+    {
+        return std::hash<decltype(s.id)>{}(s.id);
+    }
+};

subprojects/libexpr/value-to-json.cc

@@ -0,0 +1,122 @@
+#include "value-to-json.hh"
+#include "eval-inline.hh"
+#include "store-api.hh"
+#include "signals.hh"
+
+#include <cstdlib>
+#include <iomanip>
+#include <nlohmann/json.hpp>
+
+
+namespace nix {
+using json = nlohmann::json;
+json printValueAsJSON(EvalState & state, bool strict,
+    Value & v, const PosIdx pos, NixStringContext & context, bool copyToStore)
+{
+    checkInterrupt();
+
+    if (strict) state.forceValue(v, pos);
+
+    json out;
+
+    switch (v.type()) {
+
+        case nInt:
+            out = v.integer().value;
+            break;
+
+        case nBool:
+            out = v.boolean();
+            break;
+
+        case nString:
+            copyContext(v, context);
+            out = v.c_str();
+            break;
+
+        case nPath:
+            if (copyToStore)
+                out = state.store->printStorePath(
+                    state.copyPathToStore(context, v.path()));
+            else
+                out = v.path().path.abs();
+            break;
+
+        case nNull:
+            // already initialized as null
+            break;
+
+        case nAttrs: {
+            auto maybeString = state.tryAttrsToString(pos, v, context, false, false);
+            if (maybeString) {
+                out = *maybeString;
+                break;
+            }
+            if (auto i = v.attrs()->get(state.sOutPath))
+                return printValueAsJSON(state, strict, *i->value, i->pos, context, copyToStore);
+            else {
+                out = json::object();
+                for (auto & a : v.attrs()->lexicographicOrder(state.symbols)) {
+                    try {
+                        out.emplace(state.symbols[a->name], printValueAsJSON(state, strict, *a->value, a->pos, context, copyToStore));
+                    } catch (Error & e) {
+                        e.addTrace(state.positions[a->pos],
+                            HintFmt("while evaluating attribute '%1%'", state.symbols[a->name]));
+                        throw;
+                    }
+                }
+            }
+            break;
+        }
+
+        case nList: {
+            out = json::array();
+            int i = 0;
+            for (auto elem : v.listItems()) {
+                try {
+                    out.push_back(printValueAsJSON(state, strict, *elem, pos, context, copyToStore));
+                } catch (Error & e) {
+                    e.addTrace(state.positions[pos],
+                        HintFmt("while evaluating list element at index %1%", i));
+                    throw;
+                }
+                i++;
+            }
+            break;
+        }
+
+        case nExternal:
+            return v.external()->printValueAsJSON(state, strict, context, copyToStore);
+            break;
+
+        case nFloat:
+            out = v.fpoint();
+            break;
+
+        case nThunk:
+        case nFunction:
+            state.error<TypeError>(
+                "cannot convert %1% to JSON",
+                showType(v)
+            )
+            .atPos(v.determinePos(pos))
+            .debugThrow();
+    }
+    return out;
+}
+
+void printValueAsJSON(EvalState & state, bool strict,
+    Value & v, const PosIdx pos, std::ostream & str, NixStringContext & context, bool copyToStore)
+{
+    str << printValueAsJSON(state, strict, v, pos, context, copyToStore);
+}
+
+json ExternalValueBase::printValueAsJSON(EvalState & state, bool strict,
+    NixStringContext & context, bool copyToStore) const
+{
+    state.error<TypeError>("cannot convert %1% to JSON", showType())
+    .debugThrow();
+}
+
+
+}

subprojects/libexpr/value-to-json.hh

@@ -0,0 +1,19 @@
+#pragma once
+///@file
+
+#include "nixexpr.hh"
+#include "eval.hh"
+
+#include <string>
+#include <map>
+#include <nlohmann/json_fwd.hpp>
+
+namespace nix {
+
+nlohmann::json printValueAsJSON(EvalState & state, bool strict,
+    Value & v, const PosIdx pos, NixStringContext & context, bool copyToStore = true);
+
+void printValueAsJSON(EvalState & state, bool strict,
+    Value & v, const PosIdx pos, std::ostream & str, NixStringContext & context, bool copyToStore = true);
+
+}

subprojects/libexpr/value-to-xml.cc

@@ -0,0 +1,177 @@
+#include "value-to-xml.hh"
+#include "xml-writer.hh"
+#include "eval-inline.hh"
+#include "signals.hh"
+
+#include <cstdlib>
+
+
+namespace nix {
+
+
+static XMLAttrs singletonAttrs(const std::string & name, std::string_view value)
+{
+    XMLAttrs attrs;
+    attrs[name] = value;
+    return attrs;
+}
+
+
+static void printValueAsXML(EvalState & state, bool strict, bool location,
+    Value & v, XMLWriter & doc, NixStringContext & context, PathSet & drvsSeen,
+    const PosIdx pos);
+
+
+static void posToXML(EvalState & state, XMLAttrs & xmlAttrs, const Pos & pos)
+{
+    if (auto path = std::get_if<SourcePath>(&pos.origin))
+        xmlAttrs["path"] = path->path.abs();
+    xmlAttrs["line"] = fmt("%1%", pos.line);
+    xmlAttrs["column"] = fmt("%1%", pos.column);
+}
+
+
+static void showAttrs(EvalState & state, bool strict, bool location,
+    const Bindings & attrs, XMLWriter & doc, NixStringContext & context, PathSet & drvsSeen)
+{
+    StringSet names;
+
+    for (auto & a : attrs.lexicographicOrder(state.symbols)) {
+        XMLAttrs xmlAttrs;
+        xmlAttrs["name"] = state.symbols[a->name];
+        if (location && a->pos) posToXML(state, xmlAttrs, state.positions[a->pos]);
+
+        XMLOpenElement _(doc, "attr", xmlAttrs);
+        printValueAsXML(state, strict, location,
+            *a->value, doc, context, drvsSeen, a->pos);
+    }
+}
+
+
+static void printValueAsXML(EvalState & state, bool strict, bool location,
+    Value & v, XMLWriter & doc, NixStringContext & context, PathSet & drvsSeen,
+    const PosIdx pos)
+{
+    checkInterrupt();
+
+    if (strict) state.forceValue(v, pos);
+
+    switch (v.type()) {
+
+        case nInt:
+            doc.writeEmptyElement("int", singletonAttrs("value", fmt("%1%", v.integer())));
+            break;
+
+        case nBool:
+            doc.writeEmptyElement("bool", singletonAttrs("value", v.boolean() ? "true" : "false"));
+            break;
+
+        case nString:
+            /* !!! show the context? */
+            copyContext(v, context);
+            doc.writeEmptyElement("string", singletonAttrs("value", v.c_str()));
+            break;
+
+        case nPath:
+            doc.writeEmptyElement("path", singletonAttrs("value", v.path().to_string()));
+            break;
+
+        case nNull:
+            doc.writeEmptyElement("null");
+            break;
+
+        case nAttrs:
+            if (state.isDerivation(v)) {
+                XMLAttrs xmlAttrs;
+
+                Path drvPath;
+                if (auto a = v.attrs()->get(state.sDrvPath)) {
+                    if (strict) state.forceValue(*a->value, a->pos);
+                    if (a->value->type() == nString)
+                        xmlAttrs["drvPath"] = drvPath = a->value->c_str();
+                }
+
+                if (auto a = v.attrs()->get(state.sOutPath)) {
+                    if (strict) state.forceValue(*a->value, a->pos);
+                    if (a->value->type() == nString)
+                        xmlAttrs["outPath"] = a->value->c_str();
+                }
+
+                XMLOpenElement _(doc, "derivation", xmlAttrs);
+
+                if (drvPath != "" && drvsSeen.insert(drvPath).second)
+                    showAttrs(state, strict, location, *v.attrs(), doc, context, drvsSeen);
+                else
+                    doc.writeEmptyElement("repeated");
+            }
+
+            else {
+                XMLOpenElement _(doc, "attrs");
+                showAttrs(state, strict, location, *v.attrs(), doc, context, drvsSeen);
+            }
+
+            break;
+
+        case nList: {
+            XMLOpenElement _(doc, "list");
+            for (auto v2 : v.listItems())
+                printValueAsXML(state, strict, location, *v2, doc, context, drvsSeen, pos);
+            break;
+        }
+
+        case nFunction: {
+            if (!v.isLambda()) {
+                // FIXME: Serialize primops and primopapps
+                doc.writeEmptyElement("unevaluated");
+                break;
+            }
+            XMLAttrs xmlAttrs;
+            if (location) posToXML(state, xmlAttrs, state.positions[v.payload.lambda.fun->pos]);
+            XMLOpenElement _(doc, "function", xmlAttrs);
+
+            if (v.payload.lambda.fun->hasFormals()) {
+                XMLAttrs attrs;
+                if (v.payload.lambda.fun->arg) attrs["name"] = state.symbols[v.payload.lambda.fun->arg];
+                if (v.payload.lambda.fun->formals->ellipsis) attrs["ellipsis"] = "1";
+                XMLOpenElement _(doc, "attrspat", attrs);
+                for (auto & i : v.payload.lambda.fun->formals->lexicographicOrder(state.symbols))
+                    doc.writeEmptyElement("attr", singletonAttrs("name", state.symbols[i.name]));
+            } else
+                doc.writeEmptyElement("varpat", singletonAttrs("name", state.symbols[v.payload.lambda.fun->arg]));
+
+            break;
+        }
+
+        case nExternal:
+            v.external()->printValueAsXML(state, strict, location, doc, context, drvsSeen, pos);
+            break;
+
+        case nFloat:
+            doc.writeEmptyElement("float", singletonAttrs("value", fmt("%1%", v.fpoint())));
+            break;
+
+        case nThunk:
+            doc.writeEmptyElement("unevaluated");
+    }
+}
+
+
+void ExternalValueBase::printValueAsXML(EvalState & state, bool strict,
+    bool location, XMLWriter & doc, NixStringContext & context, PathSet & drvsSeen,
+    const PosIdx pos) const
+{
+    doc.writeEmptyElement("unevaluated");
+}
+
+
+void printValueAsXML(EvalState & state, bool strict, bool location,
+    Value & v, std::ostream & out, NixStringContext & context, const PosIdx pos)
+{
+    XMLWriter doc(true, out);
+    XMLOpenElement root(doc, "expr");
+    PathSet drvsSeen;
+    printValueAsXML(state, strict, location, v, doc, context, drvsSeen, pos);
+}
+
+
+}

subprojects/libexpr/value-to-xml.hh

@@ -0,0 +1,15 @@
+#pragma once
+///@file
+
+#include "nixexpr.hh"
+#include "eval.hh"
+
+#include <string>
+#include <map>
+
+namespace nix {
+
+void printValueAsXML(EvalState & state, bool strict, bool location,
+    Value & v, std::ostream & out, NixStringContext & context, const PosIdx pos);
+
+}

subprojects/libexpr/value.hh

@@ -0,0 +1,511 @@
+#pragma once
+///@file
+
+#include <cassert>
+#include <span>
+
+#include "eval-gc.hh"
+#include "symbol-table.hh"
+#include "value/context.hh"
+#include "source-path.hh"
+#include "print-options.hh"
+#include "checked-arithmetic.hh"
+
+#include <nlohmann/json_fwd.hpp>
+
+namespace nix {
+
+struct Value;
+class BindingsBuilder;
+
+
+typedef enum {
+    tUninitialized = 0,
+    tInt = 1,
+    tBool,
+    tString,
+    tPath,
+    tNull,
+    tAttrs,
+    tList1,
+    tList2,
+    tListN,
+    tThunk,
+    tApp,
+    tLambda,
+    tPrimOp,
+    tPrimOpApp,
+    tExternal,
+    tFloat
+} InternalType;
+
+/**
+ * This type abstracts over all actual value types in the language,
+ * grouping together implementation details like tList*, different function
+ * types, and types in non-normal form (so thunks and co.)
+ */
+typedef enum {
+    nThunk,
+    nInt,
+    nFloat,
+    nBool,
+    nString,
+    nPath,
+    nNull,
+    nAttrs,
+    nList,
+    nFunction,
+    nExternal
+} ValueType;
+
+class Bindings;
+struct Env;
+struct Expr;
+struct ExprLambda;
+struct ExprBlackHole;
+struct PrimOp;
+class Symbol;
+class PosIdx;
+struct Pos;
+class StorePath;
+class EvalState;
+class XMLWriter;
+class Printer;
+
+using NixInt = checked::Checked<int64_t>;
+using NixFloat = double;
+
+/**
+ * External values must descend from ExternalValueBase, so that
+ * type-agnostic nix functions (e.g. showType) can be implemented
+ */
+class ExternalValueBase
+{
+    friend std::ostream & operator << (std::ostream & str, const ExternalValueBase & v);
+    friend class Printer;
+    protected:
+    /**
+     * Print out the value
+     */
+    virtual std::ostream & print(std::ostream & str) const = 0;
+
+    public:
+    /**
+     * Return a simple string describing the type
+     */
+    virtual std::string showType() const = 0;
+
+    /**
+     * Return a string to be used in builtins.typeOf
+     */
+    virtual std::string typeOf() const = 0;
+
+    /**
+     * Coerce the value to a string. Defaults to uncoercable, i.e. throws an
+     * error.
+     */
+    virtual std::string coerceToString(EvalState & state, const PosIdx & pos, NixStringContext & context, bool copyMore, bool copyToStore) const;
+
+    /**
+     * Compare to another value of the same type. Defaults to uncomparable,
+     * i.e. always false.
+     */
+    virtual bool operator ==(const ExternalValueBase & b) const noexcept;
+
+    /**
+     * Print the value as JSON. Defaults to unconvertable, i.e. throws an error
+     */
+    virtual nlohmann::json printValueAsJSON(EvalState & state, bool strict,
+        NixStringContext & context, bool copyToStore = true) const;
+
+    /**
+     * Print the value as XML. Defaults to unevaluated
+     */
+    virtual void printValueAsXML(EvalState & state, bool strict, bool location,
+        XMLWriter & doc, NixStringContext & context, PathSet & drvsSeen,
+        const PosIdx pos) const;
+
+    virtual ~ExternalValueBase()
+    {
+    };
+};
+
+std::ostream & operator << (std::ostream & str, const ExternalValueBase & v);
+
+
+class ListBuilder
+{
+    const size_t size;
+    Value * inlineElems[2] = {nullptr, nullptr};
+public:
+    Value * * elems;
+    ListBuilder(EvalState & state, size_t size);
+
+    ListBuilder(ListBuilder && x)
+        : size(x.size)
+        , inlineElems{x.inlineElems[0], x.inlineElems[1]}
+        , elems(size <= 2 ? inlineElems : x.elems)
+    { }
+
+    Value * & operator [](size_t n)
+    {
+        return elems[n];
+    }
+
+    typedef Value * * iterator;
+
+    iterator begin() { return &elems[0]; }
+    iterator end() { return &elems[size]; }
+
+    friend struct Value;
+};
+
+
+struct Value
+{
+private:
+    InternalType internalType = tUninitialized;
+
+    friend std::string showType(const Value & v);
+
+public:
+
+    void print(EvalState &state, std::ostream &str, PrintOptions options = PrintOptions {});
+
+    // Functions needed to distinguish the type
+    // These should be removed eventually, by putting the functionality that's
+    // needed by callers into methods of this type
+
+    // type() == nThunk
+    inline bool isThunk() const { return internalType == tThunk; };
+    inline bool isApp() const { return internalType == tApp; };
+    inline bool isBlackhole() const;
+
+    // type() == nFunction
+    inline bool isLambda() const { return internalType == tLambda; };
+    inline bool isPrimOp() const { return internalType == tPrimOp; };
+    inline bool isPrimOpApp() const { return internalType == tPrimOpApp; };
+
+    /**
+     * Strings in the evaluator carry a so-called `context` which
+     * is a list of strings representing store paths.  This is to
+     * allow users to write things like
+     *
+     *   "--with-freetype2-library=" + freetype + "/lib"
+     *
+     * where `freetype` is a derivation (or a source to be copied
+     * to the store).  If we just concatenated the strings without
+     * keeping track of the referenced store paths, then if the
+     * string is used as a derivation attribute, the derivation
+     * will not have the correct dependencies in its inputDrvs and
+     * inputSrcs.
+
+     * The semantics of the context is as follows: when a string
+     * with context C is used as a derivation attribute, then the
+     * derivations in C will be added to the inputDrvs of the
+     * derivation, and the other store paths in C will be added to
+     * the inputSrcs of the derivations.
+
+     * For canonicity, the store paths should be in sorted order.
+     */
+    struct StringWithContext {
+        const char * c_str;
+        const char * * context; // must be in sorted order
+    };
+
+    struct Path {
+        SourceAccessor * accessor;
+        const char * path;
+    };
+
+    struct ClosureThunk {
+        Env * env;
+        Expr * expr;
+    };
+
+    struct FunctionApplicationThunk {
+        Value * left, * right;
+    };
+
+    struct Lambda {
+        Env * env;
+        ExprLambda * fun;
+    };
+
+    using Payload = union
+    {
+        NixInt integer;
+        bool boolean;
+
+        StringWithContext string;
+
+        Path path;
+
+        Bindings * attrs;
+        struct {
+            size_t size;
+            Value * const * elems;
+        } bigList;
+        Value * smallList[2];
+        ClosureThunk thunk;
+        FunctionApplicationThunk app;
+        Lambda lambda;
+        PrimOp * primOp;
+        FunctionApplicationThunk primOpApp;
+        ExternalValueBase * external;
+        NixFloat fpoint;
+    };
+
+    Payload payload;
+
+    /**
+     * Returns the normal type of a Value. This only returns nThunk if
+     * the Value hasn't been forceValue'd
+     *
+     * @param invalidIsThunk Instead of aborting an an invalid (probably
+     * 0, so uninitialized) internal type, return `nThunk`.
+     */
+    inline ValueType type(bool invalidIsThunk = false) const
+    {
+        switch (internalType) {
+            case tUninitialized: break;
+            case tInt: return nInt;
+            case tBool: return nBool;
+            case tString: return nString;
+            case tPath: return nPath;
+            case tNull: return nNull;
+            case tAttrs: return nAttrs;
+            case tList1: case tList2: case tListN: return nList;
+            case tLambda: case tPrimOp: case tPrimOpApp: return nFunction;
+            case tExternal: return nExternal;
+            case tFloat: return nFloat;
+            case tThunk: case tApp: return nThunk;
+        }
+        if (invalidIsThunk)
+            return nThunk;
+        else
+            unreachable();
+    }
+
+    inline void finishValue(InternalType newType, Payload newPayload)
+    {
+        payload = newPayload;
+        internalType = newType;
+    }
+
+    /**
+     * A value becomes valid when it is initialized. We don't use this
+     * in the evaluator; only in the bindings, where the slight extra
+     * cost is warranted because of inexperienced callers.
+     */
+    inline bool isValid() const
+    {
+        return internalType != tUninitialized;
+    }
+
+    inline void mkInt(NixInt::Inner n)
+    {
+        mkInt(NixInt{n});
+    }
+
+    inline void mkInt(NixInt n)
+    {
+        finishValue(tInt, { .integer = n });
+    }
+
+    inline void mkBool(bool b)
+    {
+        finishValue(tBool, { .boolean = b });
+    }
+
+    inline void mkString(const char * s, const char * * context = 0)
+    {
+        finishValue(tString, { .string = { .c_str = s, .context = context } });
+    }
+
+    void mkString(std::string_view s);
+
+    void mkString(std::string_view s, const NixStringContext & context);
+
+    void mkStringMove(const char * s, const NixStringContext & context);
+
+    inline void mkString(const SymbolStr & s)
+    {
+        mkString(s.c_str());
+    }
+
+    void mkPath(const SourcePath & path);
+    void mkPath(std::string_view path);
+
+    inline void mkPath(SourceAccessor * accessor, const char * path)
+    {
+        finishValue(tPath, { .path = { .accessor = accessor, .path = path } });
+    }
+
+    inline void mkNull()
+    {
+        finishValue(tNull, {});
+    }
+
+    inline void mkAttrs(Bindings * a)
+    {
+        finishValue(tAttrs, { .attrs = a });
+    }
+
+    Value & mkAttrs(BindingsBuilder & bindings);
+
+    void mkList(const ListBuilder & builder)
+    {
+        if (builder.size == 1)
+            finishValue(tList1, { .smallList = { builder.inlineElems[0] } });
+        else if (builder.size == 2)
+            finishValue(tList2, { .smallList = { builder.inlineElems[0], builder.inlineElems[1] } });
+        else
+            finishValue(tListN, { .bigList = { .size = builder.size, .elems = builder.elems } });
+    }
+
+    inline void mkThunk(Env * e, Expr * ex)
+    {
+        finishValue(tThunk, { .thunk = { .env = e, .expr = ex } });
+    }
+
+    inline void mkApp(Value * l, Value * r)
+    {
+        finishValue(tApp, { .app = { .left = l, .right = r } });
+    }
+
+    inline void mkLambda(Env * e, ExprLambda * f)
+    {
+        finishValue(tLambda, { .lambda = { .env = e, .fun = f } });
+    }
+
+    inline void mkBlackhole();
+
+    void mkPrimOp(PrimOp * p);
+
+    inline void mkPrimOpApp(Value * l, Value * r)
+    {
+        finishValue(tPrimOpApp, { .primOpApp = { .left = l, .right = r } });
+    }
+
+    /**
+     * For a `tPrimOpApp` value, get the original `PrimOp` value.
+     */
+    const PrimOp * primOpAppPrimOp() const;
+
+    inline void mkExternal(ExternalValueBase * e)
+    {
+        finishValue(tExternal, { .external = e });
+    }
+
+    inline void mkFloat(NixFloat n)
+    {
+        finishValue(tFloat, { .fpoint = n });
+    }
+
+    bool isList() const
+    {
+        return internalType == tList1 || internalType == tList2 || internalType == tListN;
+    }
+
+    Value * const * listElems()
+    {
+        return internalType == tList1 || internalType == tList2 ? payload.smallList : payload.bigList.elems;
+    }
+
+    std::span<Value * const> listItems() const
+    {
+        assert(isList());
+        return std::span<Value * const>(listElems(), listSize());
+    }
+
+    Value * const * listElems() const
+    {
+        return internalType == tList1 || internalType == tList2 ? payload.smallList : payload.bigList.elems;
+    }
+
+    size_t listSize() const
+    {
+        return internalType == tList1 ? 1 : internalType == tList2 ? 2 : payload.bigList.size;
+    }
+
+    PosIdx determinePos(const PosIdx pos) const;
+
+    /**
+     * Check whether forcing this value requires a trivial amount of
+     * computation. In particular, function applications are
+     * non-trivial.
+     */
+    bool isTrivial() const;
+
+    SourcePath path() const
+    {
+        assert(internalType == tPath);
+        return SourcePath(
+            ref(payload.path.accessor->shared_from_this()),
+            CanonPath(CanonPath::unchecked_t(), payload.path.path));
+    }
+
+    std::string_view string_view() const
+    {
+        assert(internalType == tString);
+        return std::string_view(payload.string.c_str);
+    }
+
+    const char * c_str() const
+    {
+        assert(internalType == tString);
+        return payload.string.c_str;
+    }
+
+    const char * * context() const
+    {
+        return payload.string.context;
+    }
+
+    ExternalValueBase * external() const
+    { return payload.external; }
+
+    const Bindings * attrs() const
+    { return payload.attrs; }
+
+    const PrimOp * primOp() const
+    { return payload.primOp; }
+
+    bool boolean() const
+    { return payload.boolean; }
+
+    NixInt integer() const
+    { return payload.integer; }
+
+    NixFloat fpoint() const
+    { return payload.fpoint; }
+};
+
+
+extern ExprBlackHole eBlackHole;
+
+bool Value::isBlackhole() const
+{
+    return internalType == tThunk && payload.thunk.expr == (Expr*) &eBlackHole;
+}
+
+void Value::mkBlackhole()
+{
+    mkThunk(nullptr, (Expr *) &eBlackHole);
+}
+
+
+typedef std::vector<Value *, traceable_allocator<Value *>> ValueVector;
+typedef std::unordered_map<Symbol, Value *, std::hash<Symbol>, std::equal_to<Symbol>, traceable_allocator<std::pair<const Symbol, Value *>>> ValueMap;
+typedef std::map<Symbol, ValueVector, std::less<Symbol>, traceable_allocator<std::pair<const Symbol, ValueVector>>> ValueVectorMap;
+
+
+/**
+ * A value allocated in traceable memory.
+ */
+typedef std::shared_ptr<Value *> RootValue;
+
+RootValue allocRootValue(Value * v);
+
+}

subprojects/libexpr/value/context.cc

@@ -0,0 +1,108 @@
+#include "util.hh"
+#include "value/context.hh"
+
+#include <optional>
+
+namespace nix {
+
+NixStringContextElem NixStringContextElem::parse(
+    std::string_view s0,
+    const ExperimentalFeatureSettings & xpSettings)
+{
+    std::string_view s = s0;
+
+    std::function<SingleDerivedPath()> parseRest;
+    parseRest = [&]() -> SingleDerivedPath {
+        // Case on whether there is a '!'
+        size_t index = s.find("!");
+        if (index == std::string_view::npos) {
+            return SingleDerivedPath::Opaque {
+                .path = StorePath { s },
+            };
+        } else {
+            std::string output { s.substr(0, index) };
+            // Advance string to parse after the '!'
+            s = s.substr(index + 1);
+            auto drv = make_ref<SingleDerivedPath>(parseRest());
+            drvRequireExperiment(*drv, xpSettings);
+            return SingleDerivedPath::Built {
+                .drvPath = std::move(drv),
+                .output = std::move(output),
+            };
+        }
+    };
+
+    if (s.size() == 0) {
+        throw BadNixStringContextElem(s0,
+            "String context element should never be an empty string");
+    }
+
+    switch (s.at(0)) {
+    case '!': {
+        // Advance string to parse after the '!'
+        s = s.substr(1);
+
+        // Find *second* '!'
+        if (s.find("!") == std::string_view::npos) {
+            throw BadNixStringContextElem(s0,
+                "String content element beginning with '!' should have a second '!'");
+        }
+
+        return std::visit(
+            [&](auto x) -> NixStringContextElem { return std::move(x); },
+            parseRest());
+    }
+    case '=': {
+        return NixStringContextElem::DrvDeep {
+            .drvPath = StorePath { s.substr(1) },
+        };
+    }
+    default: {
+        // Ensure no '!'
+        if (s.find("!") != std::string_view::npos) {
+            throw BadNixStringContextElem(s0,
+                "String content element not beginning with '!' should not have a second '!'");
+        }
+        return std::visit(
+            [&](auto x) -> NixStringContextElem { return std::move(x); },
+            parseRest());
+    }
+    }
+}
+
+std::string NixStringContextElem::to_string() const
+{
+    std::string res;
+
+    std::function<void(const SingleDerivedPath &)> toStringRest;
+    toStringRest = [&](auto & p) {
+        std::visit(overloaded {
+            [&](const SingleDerivedPath::Opaque & o) {
+                res += o.path.to_string();
+            },
+            [&](const SingleDerivedPath::Built & o) {
+                res += o.output;
+                res += '!';
+                toStringRest(*o.drvPath);
+            },
+        }, p.raw());
+    };
+
+    std::visit(overloaded {
+        [&](const NixStringContextElem::Built & b) {
+            res += '!';
+            toStringRest(b);
+        },
+        [&](const NixStringContextElem::Opaque & o) {
+            toStringRest(o);
+        },
+        [&](const NixStringContextElem::DrvDeep & d) {
+            res += '=';
+            res += d.drvPath.to_string();
+        },
+    }, raw);
+
+    return res;
+}
+
+}

subprojects/libexpr/value/context.hh

@@ -0,0 +1,85 @@
+#pragma once
+///@file
+
+#include "comparator.hh"
+#include "derived-path.hh"
+#include "variant-wrapper.hh"
+
+#include <nlohmann/json_fwd.hpp>
+
+namespace nix {
+
+class BadNixStringContextElem : public Error
+{
+public:
+    std::string_view raw;
+
+    template<typename... Args>
+    BadNixStringContextElem(std::string_view raw_, const Args & ... args)
+        : Error("")
+    {
+        raw = raw_;
+        auto hf = HintFmt(args...);
+        err.msg = HintFmt("Bad String Context element: %1%: %2%", Uncolored(hf.str()), raw);
+    }
+};
+
+struct NixStringContextElem {
+    /**
+     * Plain opaque path to some store object.
+     *
+     * Encoded as just the path: ‘<path>’.
+     */
+    using Opaque = SingleDerivedPath::Opaque;
+
+    /**
+     * Path to a derivation and its entire build closure.
+     *
+     * The path doesn't just refer to derivation itself and its closure, but
+     * also all outputs of all derivations in that closure (including the
+     * root derivation).
+     *
+     * Encoded in the form ‘=<drvPath>’.
+     */
+    struct DrvDeep {
+        StorePath drvPath;
+
+        GENERATE_CMP(DrvDeep, me->drvPath);
+    };
+
+    /**
+     * Derivation output.
+     *
+     * Encoded in the form ‘!<output>!<drvPath>’.
+     */
+    using Built = SingleDerivedPath::Built;
+
+    using Raw = std::variant<
+        Opaque,
+        DrvDeep,
+        Built
+    >;
+
+    Raw raw;
+
+    GENERATE_CMP(NixStringContextElem, me->raw);
+
+    MAKE_WRAPPER_CONSTRUCTOR(NixStringContextElem);
+
+    /**
+     * Decode a context string, one of:
+     * - ‘<path>’
+     * - ‘=<path>’
+     * - ‘!<name>!<path>’
+     *
+     * @param xpSettings Stop-gap to avoid globals during unit tests.
+     */
+    static NixStringContextElem parse(
+        std::string_view s,
+        const ExperimentalFeatureSettings & xpSettings = experimentalFeatureSettings);
+    std::string to_string() const;
+};
+
+typedef std::set<NixStringContextElem> NixStringContext;
+
+}