Merge remote-tracking branch 'upstream/master' into indexed-store-path-outputs

105 files changed, 3885 insertions, 1518 deletions

diff --git a/src/libcmd/command.cc b/src/libcmd/command.cc
index a53b029b7..f28cfe5de 100644
--- a/src/libcmd/command.cc
+++ b/src/libcmd/command.cc
@@ -197,17 +197,17 @@ void StorePathCommand::run(ref<Store> store, std::vector<StorePath> && storePath
     run(store, *storePaths.begin());
 }
 
-Strings editorFor(const Pos & pos)
+Strings editorFor(const Path & file, uint32_t line)
 {
     auto editor = getEnv("EDITOR").value_or("cat");
     auto args = tokenizeString<Strings>(editor);
-    if (pos.line > 0 && (
+    if (line > 0 && (
         editor.find("emacs") != std::string::npos ||
         editor.find("nano") != std::string::npos ||
         editor.find("vim") != std::string::npos ||
         editor.find("kak") != std::string::npos))
-        args.push_back(fmt("+%d", pos.line));
-    args.push_back(pos.file);
+        args.push_back(fmt("+%d", line));
+    args.push_back(file);
     return args;
 }
 
diff --git a/src/libcmd/command.hh b/src/libcmd/command.hh
index 84bbb5292..078e2a2ce 100644
--- a/src/libcmd/command.hh
+++ b/src/libcmd/command.hh
@@ -219,7 +219,7 @@ static RegisterCommand registerCommand2(std::vector<std::string> && name)
 
 /* Helper function to generate args that invoke $EDITOR on
    filename:lineno. */
-Strings editorFor(const Pos & pos);
+Strings editorFor(const Path & file, uint32_t line);
 
 struct MixProfile : virtual StoreCommand
 {
diff --git a/src/libcmd/installables.cc b/src/libcmd/installables.cc
index 483bc1421..e0a95118d 100644
--- a/src/libcmd/installables.cc
+++ b/src/libcmd/installables.cc
@@ -235,7 +235,7 @@ void SourceExprCommand::completeInstallable(std::string_view prefix)
 
         if (v2.type() == nAttrs) {
             for (auto & i : *v2.attrs) {
-                std::string name = i.name;
+                std::string name = state->symbols[i.name];
                 if (name.find(searchWord) == 0) {
                     if (prefix_ == "")
                         completions->add(name);
@@ -291,7 +291,7 @@ void completeFlakeRefWithFragment(
 
                 std::string lastAttr;
                 if (!attrPath.empty() && !hasSuffix(attrPathS, ".")) {
-                    lastAttr = attrPath.back();
+                    lastAttr = evalState->symbols[attrPath.back()];
                     attrPath.pop_back();
                 }
 
@@ -299,11 +299,11 @@ void completeFlakeRefWithFragment(
                 if (!attr) continue;
 
                 for (auto & attr2 : (*attr)->getAttrs()) {
-                    if (hasPrefix(attr2, lastAttr)) {
+                    if (hasPrefix(evalState->symbols[attr2], lastAttr)) {
                         auto attrPath2 = (*attr)->getAttrPath(attr2);
                         /* Strip the attrpath prefix. */
                         attrPath2.erase(attrPath2.begin(), attrPath2.begin() + attrPathPrefix.size());
-                        completions->add(flakeRefS + "#" + concatStringsSep(".", attrPath2));
+                        completions->add(flakeRefS + "#" + concatStringsSep(".", evalState->symbols.resolve(attrPath2)));
                     }
                 }
             }
@@ -460,10 +460,8 @@ DerivedPaths InstallableValue::toDerivedPaths()
 
     // Group by derivation, helps with .all in particular
     for (auto & drv : toDerivations()) {
-        auto outputName = drv.outputName;
-        if (outputName == "")
-            throw Error("derivation '%s' lacks an 'outputName' attribute", state->store->printStorePath(drv.drvPath));
-        drvsToOutputs[drv.drvPath].insert(outputName);
+        for (auto & outputName : drv.outputsToInstall)
+            drvsToOutputs[drv.drvPath].insert(outputName);
         drvsToCopy.insert(drv.drvPath);
     }
 
@@ -486,14 +484,24 @@ struct InstallableAttrPath : InstallableValue
     SourceExprCommand & cmd;
     RootValue v;
     std::string attrPath;
-
-    InstallableAttrPath(ref<EvalState> state, SourceExprCommand & cmd, Value * v, const std::string & attrPath)
-        : InstallableValue(state), cmd(cmd), v(allocRootValue(v)), attrPath(attrPath)
+    OutputsSpec outputsSpec;
+
+    InstallableAttrPath(
+        ref<EvalState> state,
+        SourceExprCommand & cmd,
+        Value * v,
+        const std::string & attrPath,
+        OutputsSpec outputsSpec)
+        : InstallableValue(state)
+        , cmd(cmd)
+        , v(allocRootValue(v))
+        , attrPath(attrPath)
+        , outputsSpec(std::move(outputsSpec))
     { }
 
     std::string what() const override { return attrPath; }
 
-    std::pair<Value *, Pos> toValue(EvalState & state) override
+    std::pair<Value *, PosIdx> toValue(EvalState & state) override
     {
         auto [vRes, pos] = findAlongAttrPath(state, attrPath, *cmd.getAutoArgs(state), **v);
         state.forceValue(*vRes, pos);
@@ -517,7 +525,19 @@ std::vector<InstallableValue::DerivationInfo> InstallableAttrPath::toDerivations
         auto drvPath = drvInfo.queryDrvPath();
         if (!drvPath)
             throw Error("'%s' is not a derivation", what());
-        res.push_back({ *drvPath, drvInfo.queryOutputName() });
+
+        std::set<std::string> outputsToInstall;
+
+        if (auto outputNames = std::get_if<OutputNames>(&outputsSpec))
+            outputsToInstall = *outputNames;
+        else
+            for (auto & output : drvInfo.queryOutputs(false, std::get_if<DefaultOutputs>(&outputsSpec)))
+                outputsToInstall.insert(output.first);
+
+        res.push_back(DerivationInfo {
+            .drvPath = *drvPath,
+            .outputsToInstall = std::move(outputsToInstall)
+        });
     }
 
     return res;
@@ -594,6 +614,7 @@ InstallableFlake::InstallableFlake(
     ref<EvalState> state,
     FlakeRef && flakeRef,
     std::string_view fragment,
+    OutputsSpec outputsSpec,
     Strings attrPaths,
     Strings prefixes,
     const flake::LockFlags & lockFlags)
@@ -601,6 +622,7 @@ InstallableFlake::InstallableFlake(
       flakeRef(flakeRef),
       attrPaths(fragment == "" ? attrPaths : Strings{(std::string) fragment}),
       prefixes(fragment == "" ? Strings{} : prefixes),
+      outputsSpec(std::move(outputsSpec)),
       lockFlags(lockFlags)
 {
     if (cmd && cmd->getAutoArgs(*state)->size())
@@ -618,9 +640,29 @@ std::tuple<std::string, FlakeRef, InstallableValue::DerivationInfo> InstallableF
 
     auto drvPath = attr->forceDerivation();
 
+    std::set<std::string> outputsToInstall;
+
+    if (auto aMeta = attr->maybeGetAttr(state->sMeta))
+        if (auto aOutputsToInstall = aMeta->maybeGetAttr("outputsToInstall"))
+            for (auto & s : aOutputsToInstall->getListOfStrings())
+                outputsToInstall.insert(s);
+
+    if (outputsToInstall.empty() || std::get_if<AllOutputs>(&outputsSpec)) {
+        outputsToInstall.clear();
+        if (auto aOutputs = attr->maybeGetAttr(state->sOutputs))
+            for (auto & s : aOutputs->getListOfStrings())
+                outputsToInstall.insert(s);
+    }
+
+    if (outputsToInstall.empty())
+        outputsToInstall.insert("out");
+
+    if (auto outputNames = std::get_if<OutputNames>(&outputsSpec))
+        outputsToInstall = *outputNames;
+
     auto drvInfo = DerivationInfo {
-        std::move(drvPath),
-        attr->getAttr(state->sOutputName)->getString()
+        .drvPath = std::move(drvPath),
+        .outputsToInstall = std::move(outputsToInstall),
     };
 
     return {attrPath, getLockedFlake()->flake.lockedRef, std::move(drvInfo)};
@@ -633,7 +675,7 @@ std::vector<InstallableValue::DerivationInfo> InstallableFlake::toDerivations()
     return res;
 }
 
-std::pair<Value *, Pos> InstallableFlake::toValue(EvalState & state)
+std::pair<Value *, PosIdx> InstallableFlake::toValue(EvalState & state)
 {
     return {&getCursor(state)->forceValue(), noPos};
 }
@@ -743,8 +785,14 @@ std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
             state->eval(e, *vFile);
         }
 
-        for (auto & s : ss)
-            result.push_back(std::make_shared<InstallableAttrPath>(state, *this, vFile, s == "." ? "" : s));
+        for (auto & s : ss) {
+            auto [prefix, outputsSpec] = parseOutputsSpec(s);
+            result.push_back(
+                std::make_shared<InstallableAttrPath>(
+                    state, *this, vFile,
+                    prefix == "." ? "" : prefix,
+                    outputsSpec));
+        }
 
     } else {
 
@@ -777,12 +825,13 @@ std::vector<std::shared_ptr<Installable>> SourceExprCommand::parseInstallables(
             }
 
             try {
-                auto [flakeRef, fragment] = parseFlakeRefWithFragment(s, absPath("."));
+                auto [flakeRef, fragment, outputsSpec] = parseFlakeRefWithFragmentAndOutputsSpec(s, absPath("."));
                 result.push_back(std::make_shared<InstallableFlake>(
                         this,
                         getEvalState(),
                         std::move(flakeRef),
                         fragment,
+                        outputsSpec,
                         getDefaultFlakeAttrPaths(),
                         getDefaultFlakeAttrPathPrefixes(),
                         lockFlags));
@@ -856,26 +905,28 @@ std::vector<std::pair<std::shared_ptr<Installable>, BuiltPath>> Installable::bui
                         auto outputHashes = staticOutputHashes(*evalStore, drv); // FIXME: expensive
                         auto drvOutputs = drv.outputsAndOptPaths(*store);
                         for (auto & output : bfd.outputs) {
-                            if (!outputHashes.count(output))
+                            auto outputHash = get(outputHashes, output);
+                            if (!outputHash)
                                 throw Error(
                                     "the derivation '%s' doesn't have an output named '%s'",
                                     store->printStorePath(bfd.drvPath), output);
                             if (settings.isExperimentalFeatureEnabled(Xp::CaDerivations)) {
-                                DrvOutput outputId { outputHashes.at(output), output };
+                                DrvOutput outputId { *outputHash, output };
                                 auto realisation = store->queryRealisation(outputId);
                                 if (!realisation)
                                     throw Error(
-                                        "cannot operate on an output of unbuilt "
-                                        "content-addressed derivation '%s'",
+                                        "cannot operate on an output of the "
+                                        "unbuilt derivation '%s'",
                                         outputId.to_string());
                                 outputs.insert_or_assign(output, realisation->outPath);
                             } else {
                                 // If ca-derivations isn't enabled, assume that
                                 // the output path is statically known.
-                                assert(drvOutputs.count(output));
-                                assert(drvOutputs.at(output).second);
+                                auto drvOutput = get(drvOutputs, output);
+                                assert(drvOutput);
+                                assert(drvOutput->second);
                                 outputs.insert_or_assign(
-                                    output, *drvOutputs.at(output).second);
+                                    output, *drvOutput->second);
                             }
                         }
                         res.push_back({installable, BuiltPath::Built { bfd.drvPath, outputs }});
diff --git a/src/libcmd/installables.hh b/src/libcmd/installables.hh
index b847f8939..1a5a96153 100644
--- a/src/libcmd/installables.hh
+++ b/src/libcmd/installables.hh
@@ -68,7 +68,7 @@ struct Installable
 
     UnresolvedApp toApp(EvalState & state);
 
-    virtual std::pair<Value *, Pos> toValue(EvalState & state)
+    virtual std::pair<Value *, PosIdx> toValue(EvalState & state)
     {
         throw Error("argument '%s' cannot be evaluated", what());
     }
@@ -141,7 +141,7 @@ struct InstallableValue : Installable
     struct DerivationInfo
     {
         StorePath drvPath;
-        std::string outputName;
+        std::set<std::string> outputsToInstall;
     };
 
     virtual std::vector<DerivationInfo> toDerivations() = 0;
@@ -156,6 +156,7 @@ struct InstallableFlake : InstallableValue
     FlakeRef flakeRef;
     Strings attrPaths;
     Strings prefixes;
+    OutputsSpec outputsSpec;
     const flake::LockFlags & lockFlags;
     mutable std::shared_ptr<flake::LockedFlake> _lockedFlake;
 
@@ -164,6 +165,7 @@ struct InstallableFlake : InstallableValue
         ref<EvalState> state,
         FlakeRef && flakeRef,
         std::string_view fragment,
+        OutputsSpec outputsSpec,
         Strings attrPaths,
         Strings prefixes,
         const flake::LockFlags & lockFlags);
@@ -178,7 +180,7 @@ struct InstallableFlake : InstallableValue
 
     std::vector<DerivationInfo> toDerivations() override;
 
-    std::pair<Value *, Pos> toValue(EvalState & state) override;
+    std::pair<Value *, PosIdx> toValue(EvalState & state) override;
 
     /* Get a cursor to every attrpath in getActualAttrPaths() that
        exists. */
diff --git a/src/libcmd/markdown.cc b/src/libcmd/markdown.cc
index 29bb4d31e..71f9c8dff 100644
--- a/src/libcmd/markdown.cc
+++ b/src/libcmd/markdown.cc
@@ -9,10 +9,12 @@ namespace nix {
 
 std::string renderMarkdownToTerminal(std::string_view markdown)
 {
+    int windowWidth = getWindowSize().second;
+
     struct lowdown_opts opts {
         .type = LOWDOWN_TERM,
         .maxdepth = 20,
-        .cols = std::max(getWindowSize().second, (unsigned short) 80),
+        .cols = (size_t) std::max(windowWidth - 5, 60),
         .hmargin = 0,
         .vmargin = 0,
         .feat = LOWDOWN_COMMONMARK | LOWDOWN_FENCED | LOWDOWN_DEFLIST | LOWDOWN_TABLES,
diff --git a/src/libexpr/attr-path.cc b/src/libexpr/attr-path.cc
index 32deecfae..94ab60f9a 100644
--- a/src/libexpr/attr-path.cc
+++ b/src/libexpr/attr-path.cc
@@ -41,13 +41,13 @@ std::vector<Symbol> parseAttrPath(EvalState & state, std::string_view s)
 }
 
 
-std::pair<Value *, Pos> findAlongAttrPath(EvalState & state, const std::string & attrPath,
+std::pair<Value *, PosIdx> findAlongAttrPath(EvalState & state, const std::string & attrPath,
     Bindings & autoArgs, Value & vIn)
 {
     Strings tokens = parseAttrPath(attrPath);
 
     Value * v = &vIn;
-    Pos pos = noPos;
+    PosIdx pos = noPos;
 
     for (auto & attr : tokens) {
 
@@ -77,13 +77,13 @@ std::pair<Value *, Pos> findAlongAttrPath(EvalState & state, const std::string &
             if (a == v->attrs->end()) {
                 std::set<std::string> attrNames;
                 for (auto & attr : *v->attrs)
-                    attrNames.insert(attr.name);
+                    attrNames.insert(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;
+            pos = a->pos;
         }
 
         else {
@@ -106,7 +106,7 @@ std::pair<Value *, Pos> findAlongAttrPath(EvalState & state, const std::string &
 }
 
 
-Pos findPackageFilename(EvalState & state, Value & v, std::string what)
+std::pair<std::string, uint32_t> findPackageFilename(EvalState & state, Value & v, std::string what)
 {
     Value * v2;
     try {
@@ -132,9 +132,7 @@ Pos findPackageFilename(EvalState & state, Value & v, std::string what)
         throw ParseError("cannot parse line number '%s'", pos);
     }
 
-    Symbol file = state.symbols.create(filename);
-
-    return { foFile, file, lineno, 0 };
+    return { std::move(filename), lineno };
 }
 
 
diff --git a/src/libexpr/attr-path.hh b/src/libexpr/attr-path.hh
index ff1135a06..117e0051b 100644
--- a/src/libexpr/attr-path.hh
+++ b/src/libexpr/attr-path.hh
@@ -10,14 +10,14 @@ namespace nix {
 MakeError(AttrPathNotFound, Error);
 MakeError(NoPositionInfo, Error);
 
-std::pair<Value *, Pos> findAlongAttrPath(
+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. */
-Pos findPackageFilename(EvalState & state, Value & v, std::string what);
+std::pair<std::string, uint32_t> findPackageFilename(EvalState & state, Value & v, std::string what);
 
 std::vector<Symbol> parseAttrPath(EvalState & state, std::string_view s);
 
diff --git a/src/libexpr/attr-set.cc b/src/libexpr/attr-set.cc
index 52ac47e9b..877116f1f 100644
--- a/src/libexpr/attr-set.cc
+++ b/src/libexpr/attr-set.cc
@@ -26,7 +26,7 @@ Bindings * EvalState::allocBindings(size_t capacity)
 /* Create a new attribute named 'name' on an existing attribute set stored
    in 'vAttrs' and return the newly allocated Value which is associated with
    this attribute. */
-Value * EvalState::allocAttr(Value & vAttrs, const Symbol & name)
+Value * EvalState::allocAttr(Value & vAttrs, Symbol name)
 {
     Value * v = allocValue();
     vAttrs.attrs->push_back(Attr(name, v));
@@ -40,7 +40,7 @@ Value * EvalState::allocAttr(Value & vAttrs, std::string_view name)
 }
 
 
-Value & BindingsBuilder::alloc(const Symbol & name, ptr<Pos> pos)
+Value & BindingsBuilder::alloc(Symbol name, PosIdx pos)
 {
     auto value = state.allocValue();
     bindings->push_back(Attr(name, value, pos));
@@ -48,7 +48,7 @@ Value & BindingsBuilder::alloc(const Symbol & name, ptr<Pos> pos)
 }
 
 
-Value & BindingsBuilder::alloc(std::string_view name, ptr<Pos> pos)
+Value & BindingsBuilder::alloc(std::string_view name, PosIdx pos)
 {
     return alloc(state.symbols.create(name), pos);
 }
diff --git a/src/libexpr/attr-set.hh b/src/libexpr/attr-set.hh
index cad9743ea..dcc73b506 100644
--- a/src/libexpr/attr-set.hh
+++ b/src/libexpr/attr-set.hh
@@ -15,18 +15,27 @@ 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;
-    ptr<Pos> pos;
-    Attr(Symbol name, Value * value, ptr<Pos> pos = ptr(&noPos))
-        : name(name), value(value), pos(pos) { };
-    Attr() : pos(&noPos) { };
+    Attr(Symbol name, Value * value, PosIdx pos = noPos)
+        : name(name), pos(pos), value(value) { };
+    Attr() { };
     bool 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
@@ -35,13 +44,13 @@ class Bindings
 {
 public:
     typedef uint32_t size_t;
-    ptr<Pos> pos;
+    PosIdx pos;
 
 private:
     size_t size_, capacity_;
     Attr attrs[0];
 
-    Bindings(size_t capacity) : pos(&noPos), size_(0), capacity_(capacity) { }
+    Bindings(size_t capacity) : size_(0), capacity_(capacity) { }
     Bindings(const Bindings & bindings) = delete;
 
 public:
@@ -57,7 +66,7 @@ public:
         attrs[size_++] = attr;
     }
 
-    iterator find(const Symbol & name)
+    iterator find(Symbol name)
     {
         Attr key(name, 0);
         iterator i = std::lower_bound(begin(), end(), key);
@@ -65,7 +74,7 @@ public:
         return end();
     }
 
-    Attr * get(const Symbol & name)
+    Attr * get(Symbol name)
     {
         Attr key(name, 0);
         iterator i = std::lower_bound(begin(), end(), key);
@@ -73,18 +82,6 @@ public:
         return nullptr;
     }
 
-    Attr & need(const Symbol & name, const Pos & pos = noPos)
-    {
-        auto a = get(name);
-        if (!a)
-            throw Error({
-                .msg = hintfmt("attribute '%s' missing", name),
-                .errPos = pos
-            });
-
-        return *a;
-    }
-
     iterator begin() { return &attrs[0]; }
     iterator end() { return &attrs[size_]; }
 
@@ -98,14 +95,15 @@ public:
     size_t capacity() { return capacity_; }
 
     /* Returns the attributes in lexicographically sorted order. */
-    std::vector<const Attr *> lexicographicOrder() const
+    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) {
-            return (const std::string &) a->name < (const std::string &) b->name;
+        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;
     }
@@ -130,7 +128,7 @@ public:
         : bindings(bindings), state(state)
     { }
 
-    void insert(Symbol name, Value * value, ptr<Pos> pos = ptr(&noPos))
+    void insert(Symbol name, Value * value, PosIdx pos = noPos)
     {
         insert(Attr(name, value, pos));
     }
@@ -145,9 +143,9 @@ public:
         bindings->push_back(attr);
     }
 
-    Value & alloc(const Symbol & name, ptr<Pos> pos = ptr(&noPos));
+    Value & alloc(Symbol name, PosIdx pos = noPos);
 
-    Value & alloc(std::string_view name, ptr<Pos> pos = ptr(&noPos));
+    Value & alloc(std::string_view name, PosIdx pos = noPos);
 
     Bindings * finish()
     {
diff --git a/src/libexpr/eval-cache.cc b/src/libexpr/eval-cache.cc
index 7d3fd01a4..0eb4bc79e 100644
--- a/src/libexpr/eval-cache.cc
+++ b/src/libexpr/eval-cache.cc
@@ -35,13 +35,19 @@ struct AttrDb
 
     std::unique_ptr<Sync<State>> _state;
 
-    AttrDb(const Store & cfg, const Hash & fingerprint)
+    SymbolTable & symbols;
+
+    AttrDb(
+        const Store & cfg,
+        const Hash & fingerprint,
+        SymbolTable & symbols)
         : cfg(cfg)
         , _state(std::make_unique<Sync<State>>())
+        , symbols(symbols)
     {
         auto state(_state->lock());
 
-        Path cacheDir = getCacheDir() + "/nix/eval-cache-v2";
+        Path cacheDir = getCacheDir() + "/nix/eval-cache-v3";
         createDirs(cacheDir);
 
         Path dbPath = cacheDir + "/" + fingerprint.to_string(Base16, false) + ".sqlite";
@@ -100,7 +106,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (key.second)
+                (symbols[key.second])
                 (AttrType::FullAttrs)
                 (0, false).exec();
 
@@ -110,7 +116,7 @@ struct AttrDb
             for (auto & attr : attrs)
                 state->insertAttribute.use()
                     (rowId)
-                    (attr)
+                    (symbols[attr])
                     (AttrType::Placeholder)
                     (0, false).exec();
 
@@ -135,14 +141,14 @@ struct AttrDb
                 }
                 state->insertAttributeWithContext.use()
                     (key.first)
-                    (key.second)
+                    (symbols[key.second])
                     (AttrType::String)
                     (s)
                     (ctx).exec();
             } else {
                 state->insertAttribute.use()
                     (key.first)
-                    (key.second)
+                    (symbols[key.second])
                     (AttrType::String)
                 (s).exec();
             }
@@ -161,7 +167,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (key.second)
+                (symbols[key.second])
                 (AttrType::Bool)
                 (b ? 1 : 0).exec();
 
@@ -169,6 +175,24 @@ struct AttrDb
         });
     }
 
+    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)
+                (concatStringsSep("\t", l)).exec();
+
+            return state->db.getLastInsertedRowId();
+        });
+    }
+
     AttrId setPlaceholder(AttrKey key)
     {
         return doSQLite([&]()
@@ -177,7 +201,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (key.second)
+                (symbols[key.second])
                 (AttrType::Placeholder)
                 (0, false).exec();
 
@@ -193,7 +217,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (key.second)
+                (symbols[key.second])
                 (AttrType::Missing)
                 (0, false).exec();
 
@@ -209,7 +233,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (key.second)
+                (symbols[key.second])
                 (AttrType::Misc)
                 (0, false).exec();
 
@@ -225,7 +249,7 @@ struct AttrDb
 
             state->insertAttribute.use()
                 (key.first)
-                (key.second)
+                (symbols[key.second])
                 (AttrType::Failed)
                 (0, false).exec();
 
@@ -233,13 +257,11 @@ struct AttrDb
         });
     }
 
-    std::optional<std::pair<AttrId, AttrValue>> getAttr(
-        AttrKey key,
-        SymbolTable & symbols)
+    std::optional<std::pair<AttrId, AttrValue>> getAttr(AttrKey key)
     {
         auto state(_state->lock());
 
-        auto queryAttribute(state->queryAttribute.use()(key.first)(key.second));
+        auto queryAttribute(state->queryAttribute.use()(key.first)(symbols[key.second]));
         if (!queryAttribute.next()) return {};
 
         auto rowId = (AttrType) queryAttribute.getInt(0);
@@ -253,7 +275,7 @@ struct AttrDb
                 std::vector<Symbol> attrs;
                 auto queryAttributes(state->queryAttributes.use()(rowId));
                 while (queryAttributes.next())
-                    attrs.push_back(symbols.create(queryAttributes.getStr(0)));
+                    attrs.emplace_back(symbols.create(queryAttributes.getStr(0)));
                 return {{rowId, attrs}};
             }
             case AttrType::String: {
@@ -265,6 +287,8 @@ struct AttrDb
             }
             case AttrType::Bool:
                 return {{rowId, queryAttribute.getInt(2) != 0}};
+            case AttrType::ListOfStrings:
+                return {{rowId, tokenizeString<std::vector<std::string>>(queryAttribute.getStr(2), "\t")}};
             case AttrType::Missing:
                 return {{rowId, missing_t()}};
             case AttrType::Misc:
@@ -277,10 +301,13 @@ struct AttrDb
     }
 };
 
-static std::shared_ptr<AttrDb> makeAttrDb(const Store & cfg, const Hash & fingerprint)
+static std::shared_ptr<AttrDb> makeAttrDb(
+    const Store & cfg,
+    const Hash & fingerprint,
+    SymbolTable & symbols)
 {
     try {
-        return std::make_shared<AttrDb>(cfg, fingerprint);
+        return std::make_shared<AttrDb>(cfg, fingerprint, symbols);
     } catch (SQLiteError &) {
         ignoreException();
         return nullptr;
@@ -291,7 +318,7 @@ EvalCache::EvalCache(
     std::optional<std::reference_wrapper<const Hash>> useCache,
     EvalState & state,
     RootLoader rootLoader)
-    : db(useCache ? makeAttrDb(*state.store, *useCache) : nullptr)
+    : db(useCache ? makeAttrDb(*state.store, *useCache, state.symbols) : nullptr)
     , state(state)
     , rootLoader(rootLoader)
 {
@@ -327,8 +354,7 @@ AttrKey AttrCursor::getKey()
     if (!parent)
         return {0, root->state.sEpsilon};
     if (!parent->first->cachedValue) {
-        parent->first->cachedValue = root->db->getAttr(
-            parent->first->getKey(), root->state.symbols);
+        parent->first->cachedValue = root->db->getAttr(parent->first->getKey());
         assert(parent->first->cachedValue);
     }
     return {parent->first->cachedValue->first, parent->second};
@@ -369,17 +395,17 @@ std::vector<Symbol> AttrCursor::getAttrPath(Symbol name) const
 
 std::string AttrCursor::getAttrPathStr() const
 {
-    return concatStringsSep(".", getAttrPath());
+    return concatStringsSep(".", root->state.symbols.resolve(getAttrPath()));
 }
 
 std::string AttrCursor::getAttrPathStr(Symbol name) const
 {
-    return concatStringsSep(".", getAttrPath(name));
+    return concatStringsSep(".", root->state.symbols.resolve(getAttrPath(name)));
 }
 
 Value & AttrCursor::forceValue()
 {
-    debug("evaluating uncached attribute %s", getAttrPathStr());
+    debug("evaluating uncached attribute '%s'", getAttrPathStr());
 
     auto & v = getValue();
 
@@ -414,25 +440,25 @@ Suggestions AttrCursor::getSuggestionsForAttr(Symbol name)
     auto attrNames = getAttrs();
     std::set<std::string> strAttrNames;
     for (auto & name : attrNames)
-        strAttrNames.insert(std::string(name));
+        strAttrNames.insert(root->state.symbols[name]);
 
-    return Suggestions::bestMatches(strAttrNames, name);
+    return Suggestions::bestMatches(strAttrNames, root->state.symbols[name]);
 }
 
 std::shared_ptr<AttrCursor> AttrCursor::maybeGetAttr(Symbol name, bool forceErrors)
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
+            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(), 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}, root->state.symbols);
+                auto attr = root->db->getAttr({cachedValue->first, name});
                 if (attr) {
                     if (std::get_if<missing_t>(&attr->second))
                         return nullptr;
@@ -522,7 +548,7 @@ std::string AttrCursor::getString()
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
+            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());
@@ -544,7 +570,7 @@ string_t AttrCursor::getStringWithContext()
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
+            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;
@@ -577,7 +603,7 @@ bool AttrCursor::getBool()
 {
     if (root->db) {
         if (!cachedValue)
-            cachedValue = root->db->getAttr(getKey(), root->state.symbols);
+            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());
@@ -595,11 +621,44 @@ bool AttrCursor::getBool()
     return v.boolean;
 }
 
+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
+                throw TypeError("'%s' is not a list of strings", getAttrPathStr());
+        }
+    }
+
+    debug("evaluating uncached attribute '%s'", getAttrPathStr());
+
+    auto & v = getValue();
+    root->state.forceValue(v, noPos);
+
+    if (v.type() != nList)
+        throw TypeError("'%s' is not a list", getAttrPathStr());
+
+    std::vector<std::string> res;
+
+    for (auto & elem : v.listItems())
+        res.push_back(std::string(root->state.forceStringNoCtx(*elem)));
+
+    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(), root->state.symbols);
+            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());
@@ -617,8 +676,9 @@ std::vector<Symbol> AttrCursor::getAttrs()
     std::vector<Symbol> attrs;
     for (auto & attr : *getValue().attrs)
         attrs.push_back(attr.name);
-    std::sort(attrs.begin(), attrs.end(), [](const Symbol & a, const Symbol & b) {
-        return (const std::string &) a < (const std::string &) b;
+    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)
diff --git a/src/libexpr/eval-cache.hh b/src/libexpr/eval-cache.hh
index b0709ebc2..636e293ad 100644
--- a/src/libexpr/eval-cache.hh
+++ b/src/libexpr/eval-cache.hh
@@ -44,6 +44,7 @@ enum AttrType {
     Misc = 4,
     Failed = 5,
     Bool = 6,
+    ListOfStrings = 7,
 };
 
 struct placeholder_t {};
@@ -61,7 +62,8 @@ typedef std::variant<
     missing_t,
     misc_t,
     failed_t,
-    bool
+    bool,
+    std::vector<std::string>
     > AttrValue;
 
 class AttrCursor : public std::enable_shared_from_this<AttrCursor>
@@ -114,6 +116,8 @@ public:
 
     bool getBool();
 
+    std::vector<std::string> getListOfStrings();
+
     std::vector<Symbol> getAttrs();
 
     bool isDerivation();
diff --git a/src/libexpr/eval-inline.hh b/src/libexpr/eval-inline.hh
index 08a419923..7f01d08e3 100644
--- a/src/libexpr/eval-inline.hh
+++ b/src/libexpr/eval-inline.hh
@@ -2,27 +2,8 @@
 
 #include "eval.hh"
 
-#define LocalNoInline(f) static f __attribute__((noinline)); f
-#define LocalNoInlineNoReturn(f) static f __attribute__((noinline, noreturn)); f
-
 namespace nix {
 
-LocalNoInlineNoReturn(void throwEvalError(const Pos & pos, const char * s))
-{
-    throw EvalError({
-        .msg = hintfmt(s),
-        .errPos = pos
-    });
-}
-
-LocalNoInlineNoReturn(void throwTypeError(const Pos & pos, const char * s, const Value & v))
-{
-    throw TypeError({
-        .msg = hintfmt(s, showType(v)),
-        .errPos = pos
-    });
-}
-
 
 /* Note: Various places expect the allocated memory to be zeroed. */
 [[gnu::always_inline]]
@@ -99,7 +80,7 @@ Env & EvalState::allocEnv(size_t size)
 
 
 [[gnu::always_inline]]
-void EvalState::forceValue(Value & v, const Pos & pos)
+void EvalState::forceValue(Value & v, const PosIdx pos)
 {
     forceValue(v, [&]() { return pos; });
 }
@@ -128,7 +109,7 @@ void EvalState::forceValue(Value & v, Callable getPos)
 
 
 [[gnu::always_inline]]
-inline void EvalState::forceAttrs(Value & v, const Pos & pos)
+inline void EvalState::forceAttrs(Value & v, const PosIdx pos)
 {
     forceAttrs(v, [&]() { return pos; });
 }
@@ -145,7 +126,7 @@ inline void EvalState::forceAttrs(Value & v, Callable getPos)
 
 
 [[gnu::always_inline]]
-inline void EvalState::forceList(Value & v, const Pos & pos)
+inline void EvalState::forceList(Value & v, const PosIdx pos)
 {
     forceValue(v, pos);
     if (!v.isList())
diff --git a/src/libexpr/eval.cc b/src/libexpr/eval.cc
index b87e06ef5..8d67691f0 100644
--- a/src/libexpr/eval.cc
+++ b/src/libexpr/eval.cc
@@ -96,7 +96,8 @@ RootValue allocRootValue(Value * v)
 }
 
 
-void Value::print(std::ostream & str, std::set<const void *> * seen) const
+void Value::print(const SymbolTable & symbols, std::ostream & str,
+    std::set<const void *> * seen) const
 {
     checkInterrupt();
 
@@ -129,9 +130,9 @@ void Value::print(std::ostream & str, std::set<const void *> * seen) const
             str << "«repeated»";
         else {
             str << "{ ";
-            for (auto & i : attrs->lexicographicOrder()) {
-                str << i->name << " = ";
-                i->value->print(str, seen);
+            for (auto & i : attrs->lexicographicOrder(symbols)) {
+                str << symbols[i->name] << " = ";
+                i->value->print(symbols, str, seen);
                 str << "; ";
             }
             str << "}";
@@ -146,7 +147,10 @@ void Value::print(std::ostream & str, std::set<const void *> * seen) const
         else {
             str << "[ ";
             for (auto v2 : listItems()) {
-                v2->print(str, seen);
+                if (v2)
+                    v2->print(symbols, str, seen);
+                else
+                    str << "(nullptr)";
                 str << " ";
             }
             str << "]";
@@ -177,17 +181,23 @@ void Value::print(std::ostream & str, std::set<const void *> * seen) const
 }
 
 
-void Value::print(std::ostream & str, bool showRepeated) const
+void Value::print(const SymbolTable & symbols, std::ostream & str, bool showRepeated) const
 {
     std::set<const void *> seen;
-    print(str, showRepeated ? nullptr : &seen);
+    print(symbols, str, showRepeated ? nullptr : &seen);
 }
 
+// Pretty print types for assertion errors
+std::ostream & operator << (std::ostream & os, const ValueType t) {
+    os << showType(t);
+    return os;
+}
 
-std::ostream & operator << (std::ostream & str, const Value & v)
+std::string printValue(const EvalState & state, const Value & v)
 {
-    v.print(str, false);
-    return str;
+    std::ostringstream out;
+    v.print(state.symbols, out);
+    return out.str();
 }
 
 
@@ -236,10 +246,10 @@ std::string showType(const Value & v)
     }
 }
 
-Pos Value::determinePos(const Pos & pos) const
+PosIdx Value::determinePos(const PosIdx pos) const
 {
     switch (internalType) {
-        case tAttrs: return *attrs->pos;
+        case tAttrs: return attrs->pos;
         case tLambda: return lambda.fun->pos;
         case tApp: return app.left->determinePos(pos);
         default: return pos;
@@ -308,7 +318,7 @@ static BoehmGCStackAllocator boehmGCStackAllocator;
 
 static Symbol getName(const AttrName & name, EvalState & state, Env & env)
 {
-    if (name.symbol.set()) {
+    if (name.symbol) {
         return name.symbol;
     } else {
         Value nameValue;
@@ -639,20 +649,20 @@ Value * EvalState::addPrimOp(const std::string & name,
     size_t arity, PrimOpFun primOp)
 {
     auto name2 = name.substr(0, 2) == "__" ? name.substr(2) : name;
-    Symbol sym = symbols.create(name2);
+    auto sym = symbols.create(name2);
 
     /* Hack to make constants lazy: turn them into a application of
        the primop to a dummy value. */
     if (arity == 0) {
         auto vPrimOp = allocValue();
-        vPrimOp->mkPrimOp(new PrimOp { .fun = primOp, .arity = 1, .name = sym });
+        vPrimOp->mkPrimOp(new PrimOp { .fun = primOp, .arity = 1, .name = name2 });
         Value v;
         v.mkApp(vPrimOp, vPrimOp);
         return addConstant(name, v);
     }
 
     Value * v = allocValue();
-    v->mkPrimOp(new PrimOp { .fun = primOp, .arity = arity, .name = sym });
+    v->mkPrimOp(new PrimOp { .fun = primOp, .arity = arity, .name = name2 });
     staticBaseEnv.vars.emplace_back(symbols.create(name), baseEnvDispl);
     baseEnv.values[baseEnvDispl++] = v;
     baseEnv.values[0]->attrs->push_back(Attr(sym, v));
@@ -667,21 +677,21 @@ Value * EvalState::addPrimOp(PrimOp && primOp)
     if (primOp.arity == 0) {
         primOp.arity = 1;
         auto vPrimOp = allocValue();
-        vPrimOp->mkPrimOp(new PrimOp(std::move(primOp)));
+        vPrimOp->mkPrimOp(new PrimOp(primOp));
         Value v;
         v.mkApp(vPrimOp, vPrimOp);
         return addConstant(primOp.name, v);
     }
 
-    Symbol envName = primOp.name;
+    auto envName = symbols.create(primOp.name);
     if (hasPrefix(primOp.name, "__"))
-        primOp.name = symbols.create(std::string(primOp.name, 2));
+        primOp.name = primOp.name.substr(2);
 
     Value * v = allocValue();
-    v->mkPrimOp(new PrimOp(std::move(primOp)));
+    v->mkPrimOp(new PrimOp(primOp));
     staticBaseEnv.vars.emplace_back(envName, baseEnvDispl);
     baseEnv.values[baseEnvDispl++] = v;
-    baseEnv.values[0]->attrs->push_back(Attr(primOp.name, v));
+    baseEnv.values[0]->attrs->push_back(Attr(symbols.create(primOp.name), v));
     return v;
 }
 
@@ -698,7 +708,7 @@ std::optional<EvalState::Doc> EvalState::getDoc(Value & v)
         auto v2 = &v;
         if (v2->primOp->doc)
             return Doc {
-                .pos = noPos,
+                .pos = {},
                 .name = v2->primOp->name,
                 .arity = v2->primOp->arity,
                 .args = v2->primOp->args,
@@ -714,113 +724,133 @@ std::optional<EvalState::Doc> EvalState::getDoc(Value & v)
    evaluator.  So here are some helper functions for throwing
    exceptions. */
 
-LocalNoInlineNoReturn(void throwEvalError(const char * s, const std::string & s2))
+void EvalState::throwEvalError(const PosIdx pos, const char * s) const
+{
+    throw EvalError({
+        .msg = hintfmt(s),
+        .errPos = positions[pos]
+    });
+}
+
+void EvalState::throwTypeError(const PosIdx pos, const char * s, const Value & v) const
+{
+    throw TypeError({
+        .msg = hintfmt(s, showType(v)),
+        .errPos = positions[pos]
+    });
+}
+
+void EvalState::throwEvalError(const char * s, const std::string & s2) const
 {
     throw EvalError(s, s2);
 }
 
-LocalNoInlineNoReturn(void throwEvalError(const Pos & pos, const Suggestions & suggestions, const char * s, const std::string & s2))
+void EvalState::throwEvalError(const PosIdx pos, const Suggestions & suggestions, const char * s,
+    const std::string & s2) const
 {
     throw EvalError(ErrorInfo {
         .msg = hintfmt(s, s2),
-        .errPos = pos,
+        .errPos = positions[pos],
         .suggestions = suggestions,
     });
 }
 
-LocalNoInlineNoReturn(void throwEvalError(const Pos & pos, const char * s, const std::string & s2))
+void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2) const
 {
     throw EvalError(ErrorInfo {
         .msg = hintfmt(s, s2),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
-LocalNoInlineNoReturn(void throwEvalError(const char * s, const std::string & s2, const std::string & s3))
+void EvalState::throwEvalError(const char * s, const std::string & s2, const std::string & s3) const
 {
     throw EvalError(s, s2, s3);
 }
 
-LocalNoInlineNoReturn(void throwEvalError(const Pos & pos, const char * s, const std::string & s2, const std::string & s3))
+void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2,
+    const std::string & s3) const
 {
     throw EvalError({
         .msg = hintfmt(s, s2, s3),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
-LocalNoInlineNoReturn(void throwEvalError(const Pos & p1, const char * s, const Symbol & sym, const Pos & p2))
+void EvalState::throwEvalError(const PosIdx p1, const char * s, const Symbol sym, const PosIdx p2) const
 {
     // p1 is where the error occurred; p2 is a position mentioned in the message.
     throw EvalError({
-        .msg = hintfmt(s, sym, p2),
-        .errPos = p1
+        .msg = hintfmt(s, symbols[sym], positions[p2]),
+        .errPos = positions[p1]
     });
 }
 
-LocalNoInlineNoReturn(void throwTypeError(const Pos & pos, const char * s))
+void EvalState::throwTypeError(const PosIdx pos, const char * s) const
 {
     throw TypeError({
         .msg = hintfmt(s),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
-LocalNoInlineNoReturn(void throwTypeError(const Pos & pos, const char * s, const ExprLambda & fun, const Symbol & s2))
+void EvalState::throwTypeError(const PosIdx pos, const char * s, const ExprLambda & fun,
+    const Symbol s2) const
 {
     throw TypeError({
-        .msg = hintfmt(s, fun.showNamePos(), s2),
-        .errPos = pos
+        .msg = hintfmt(s, fun.showNamePos(*this), symbols[s2]),
+        .errPos = positions[pos]
     });
 }
 
-LocalNoInlineNoReturn(void throwTypeError(const Pos & pos, const Suggestions & suggestions, const char * s, const ExprLambda & fun, const Symbol & s2))
+void EvalState::throwTypeError(const PosIdx pos, const Suggestions & suggestions, const char * s,
+    const ExprLambda & fun, const Symbol s2) const
 {
     throw TypeError(ErrorInfo {
-        .msg = hintfmt(s, fun.showNamePos(), s2),
-        .errPos = pos,
+        .msg = hintfmt(s, fun.showNamePos(*this), symbols[s2]),
+        .errPos = positions[pos],
         .suggestions = suggestions,
     });
 }
 
 
-LocalNoInlineNoReturn(void throwTypeError(const char * s, const Value & v))
+void EvalState::throwTypeError(const char * s, const Value & v) const
 {
     throw TypeError(s, showType(v));
 }
 
-LocalNoInlineNoReturn(void throwAssertionError(const Pos & pos, const char * s, const std::string & s1))
+void EvalState::throwAssertionError(const PosIdx pos, const char * s, const std::string & s1) const
 {
     throw AssertionError({
         .msg = hintfmt(s, s1),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
-LocalNoInlineNoReturn(void throwUndefinedVarError(const Pos & pos, const char * s, const std::string & s1))
+void EvalState::throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1) const
 {
     throw UndefinedVarError({
         .msg = hintfmt(s, s1),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
-LocalNoInlineNoReturn(void throwMissingArgumentError(const Pos & pos, const char * s, const std::string & s1))
+void EvalState::throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1) const
 {
     throw MissingArgumentError({
         .msg = hintfmt(s, s1),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
-LocalNoInline(void addErrorTrace(Error & e, const char * s, const std::string & s2))
+void EvalState::addErrorTrace(Error & e, const char * s, const std::string & s2) const
 {
     e.addTrace(std::nullopt, s, s2);
 }
 
-LocalNoInline(void addErrorTrace(Error & e, const Pos & pos, const char * s, const std::string & s2))
+void EvalState::addErrorTrace(Error & e, const PosIdx pos, const char * s, const std::string & s2) const
 {
-    e.addTrace(pos, s, s2);
+    e.addTrace(positions[pos], s, s2);
 }
 
 
@@ -877,11 +907,11 @@ inline Value * EvalState::lookupVar(Env * env, const ExprVar & var, bool noEval)
         }
         Bindings::iterator j = env->values[0]->attrs->find(var.name);
         if (j != env->values[0]->attrs->end()) {
-            if (countCalls) attrSelects[*j->pos]++;
+            if (countCalls) attrSelects[j->pos]++;
             return j->value;
         }
         if (!env->prevWith)
-            throwUndefinedVarError(var.pos, "undefined variable '%1%'", var.name);
+            throwUndefinedVarError(var.pos, "undefined variable '%1%'", symbols[var.name]);
         for (size_t l = env->prevWith; l; --l, env = env->up) ;
     }
 }
@@ -911,13 +941,14 @@ void EvalState::mkThunk_(Value & v, Expr * expr)
 }
 
 
-void EvalState::mkPos(Value & v, ptr<Pos> pos)
+void EvalState::mkPos(Value & v, PosIdx p)
 {
-    if (pos->file.set()) {
+    auto pos = positions[p];
+    if (!pos.file.empty()) {
         auto attrs = buildBindings(3);
-        attrs.alloc(sFile).mkString(pos->file);
-        attrs.alloc(sLine).mkInt(pos->line);
-        attrs.alloc(sColumn).mkInt(pos->column);
+        attrs.alloc(sFile).mkString(pos.file);
+        attrs.alloc(sLine).mkInt(pos.line);
+        attrs.alloc(sColumn).mkInt(pos.column);
         v.mkAttrs(attrs);
     } else
         v.mkNull();
@@ -1050,7 +1081,7 @@ inline bool EvalState::evalBool(Env & env, Expr * e)
 }
 
 
-inline bool EvalState::evalBool(Env & env, Expr * e, const Pos & pos)
+inline bool EvalState::evalBool(Env & env, Expr * e, const PosIdx pos)
 {
     Value v;
     e->eval(*this, env, v);
@@ -1124,7 +1155,7 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
             } else
                 vAttr = i.second.e->maybeThunk(state, i.second.inherited ? env : env2);
             env2.values[displ++] = vAttr;
-            v.attrs->push_back(Attr(i.first, vAttr, ptr(&i.second.pos)));
+            v.attrs->push_back(Attr(i.first, vAttr, i.second.pos));
         }
 
         /* If the rec contains an attribute called `__overrides', then
@@ -1156,7 +1187,7 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
 
     else
         for (auto & i : attrs)
-            v.attrs->push_back(Attr(i.first, i.second.e->maybeThunk(state, env), ptr(&i.second.pos)));
+            v.attrs->push_back(Attr(i.first, i.second.e->maybeThunk(state, env), i.second.pos));
 
     /* Dynamic attrs apply *after* rec and __overrides. */
     for (auto & i : dynamicAttrs) {
@@ -1166,18 +1197,18 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
         if (nameVal.type() == nNull)
             continue;
         state.forceStringNoCtx(nameVal);
-        Symbol nameSym = state.symbols.create(nameVal.string.s);
+        auto nameSym = state.symbols.create(nameVal.string.s);
         Bindings::iterator j = v.attrs->find(nameSym);
         if (j != v.attrs->end())
-            throwEvalError(i.pos, "dynamic attribute '%1%' already defined at %2%", nameSym, *j->pos);
+            state.throwEvalError(i.pos, "dynamic attribute '%1%' already defined at %2%", nameSym, j->pos);
 
         i.valueExpr->setName(nameSym);
         /* Keep sorted order so find can catch duplicates */
-        v.attrs->push_back(Attr(nameSym, i.valueExpr->maybeThunk(state, *dynamicEnv), ptr(&i.pos)));
+        v.attrs->push_back(Attr(nameSym, i.valueExpr->maybeThunk(state, *dynamicEnv), i.pos));
         v.attrs->sort(); // FIXME: inefficient
     }
 
-    v.attrs->pos = ptr(&pos);
+    v.attrs->pos = pos;
 }
 
 
@@ -1222,10 +1253,12 @@ static std::string showAttrPath(EvalState & state, Env & env, const AttrPath & a
     for (auto & i : attrPath) {
         if (!first) out << '.'; else first = false;
         try {
-            out << getName(i, state, env);
+            out << state.symbols[getName(i, state, env)];
         } catch (Error & e) {
-            assert(!i.symbol.set());
-            out << "\"${" << *i.expr << "}\"";
+            assert(!i.symbol);
+            out << "\"${";
+            i.expr->show(state.symbols, out);
+            out << "}\"";
         }
     }
     return out.str();
@@ -1235,7 +1268,7 @@ static std::string showAttrPath(EvalState & state, Env & env, const AttrPath & a
 void ExprSelect::eval(EvalState & state, Env & env, Value & v)
 {
     Value vTmp;
-    ptr<Pos> pos2(&noPos);
+    PosIdx pos2;
     Value * vAttrs = &vTmp;
 
     e->eval(state, env, vTmp);
@@ -1245,7 +1278,7 @@ void ExprSelect::eval(EvalState & state, Env & env, Value & v)
         for (auto & i : attrPath) {
             state.nrLookups++;
             Bindings::iterator j;
-            Symbol name = getName(i, state, env);
+            auto name = getName(i, state, env);
             if (def) {
                 state.forceValue(*vAttrs, pos);
                 if (vAttrs->type() != nAttrs ||
@@ -1259,23 +1292,24 @@ void ExprSelect::eval(EvalState & state, Env & env, Value & v)
                 if ((j = vAttrs->attrs->find(name)) == vAttrs->attrs->end()) {
                     std::set<std::string> allAttrNames;
                     for (auto & attr : *vAttrs->attrs)
-                        allAttrNames.insert(attr.name);
-                    throwEvalError(
+                        allAttrNames.insert(state.symbols[attr.name]);
+                    state.throwEvalError(
                         pos,
-                        Suggestions::bestMatches(allAttrNames, name),
-                        "attribute '%1%' missing", name);
+                        Suggestions::bestMatches(allAttrNames, state.symbols[name]),
+                        "attribute '%1%' missing", state.symbols[name]);
                 }
             }
             vAttrs = j->value;
             pos2 = j->pos;
-            if (state.countCalls) state.attrSelects[*pos2]++;
+            if (state.countCalls) state.attrSelects[pos2]++;
         }
 
-        state.forceValue(*vAttrs, (*pos2 != noPos ? *pos2 : this->pos ) );
+        state.forceValue(*vAttrs, (pos2 ? pos2 : this->pos ) );
 
     } catch (Error & e) {
-        if (*pos2 != noPos && pos2->file != state.sDerivationNix)
-            addErrorTrace(e, *pos2, "while evaluating the attribute '%1%'",
+        auto pos2r = state.positions[pos2];
+        if (pos2 && pos2r.file != state.derivationNixPath)
+            state.addErrorTrace(e, pos2, "while evaluating the attribute '%1%'",
                 showAttrPath(state, env, attrPath));
         throw;
     }
@@ -1294,7 +1328,7 @@ void ExprOpHasAttr::eval(EvalState & state, Env & env, Value & v)
     for (auto & i : attrPath) {
         state.forceValue(*vAttrs, noPos);
         Bindings::iterator j;
-        Symbol name = getName(i, state, env);
+        auto name = getName(i, state, env);
         if (vAttrs->type() != nAttrs ||
             (j = vAttrs->attrs->find(name)) == vAttrs->attrs->end())
         {
@@ -1315,9 +1349,11 @@ void ExprLambda::eval(EvalState & state, Env & env, Value & v)
 }
 
 
-void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const Pos & pos)
+void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const PosIdx pos)
 {
-    auto trace = evalSettings.traceFunctionCalls ? std::make_unique<FunctionCallTrace>(pos) : nullptr;
+    auto trace = evalSettings.traceFunctionCalls
+        ? std::make_unique<FunctionCallTrace>(positions[pos])
+        : nullptr;
 
     forceValue(fun, pos);
 
@@ -1342,7 +1378,7 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
             ExprLambda & lambda(*vCur.lambda.fun);
 
             auto size =
-                (lambda.arg.empty() ? 0 : 1) +
+                (!lambda.arg ? 0 : 1) +
                 (lambda.hasFormals() ? lambda.formals->formals.size() : 0);
             Env & env2(allocEnv(size));
             env2.up = vCur.lambda.env;
@@ -1355,7 +1391,7 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
             else {
                 forceAttrs(*args[0], pos);
 
-                if (!lambda.arg.empty())
+                if (lambda.arg)
                     env2.values[displ++] = args[0];
 
                 /* For each formal argument, get the actual argument.  If
@@ -1383,10 +1419,10 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
                         if (!lambda.formals->has(i.name)) {
                             std::set<std::string> formalNames;
                             for (auto & formal : lambda.formals->formals)
-                                formalNames.insert(formal.name);
+                                formalNames.insert(symbols[formal.name]);
                             throwTypeError(
                                 pos,
-                                Suggestions::bestMatches(formalNames, i.name),
+                                Suggestions::bestMatches(formalNames, symbols[i.name]),
                                 "%1% called with unexpected argument '%2%'",
                                 lambda,
                                 i.name);
@@ -1404,8 +1440,8 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
             } catch (Error & e) {
                 if (loggerSettings.showTrace.get()) {
                     addErrorTrace(e, lambda.pos, "while evaluating %s",
-                        (lambda.name.set()
-                            ? "'" + (const std::string &) lambda.name + "'"
+                        (lambda.name
+                            ? concatStrings("'", symbols[lambda.name], "'")
                             : "anonymous lambda"));
                     addErrorTrace(e, pos, "from call site%s", "");
                 }
@@ -1554,7 +1590,7 @@ void EvalState::autoCallFunction(Bindings & args, Value & fun, Value & res)
 Nix attempted to evaluate a function as a top level expression; in
 this case it must have its arguments supplied either by default
 values, or passed explicitly with '--arg' or '--argstr'. See
-https://nixos.org/manual/nix/stable/#ss-functions.)", i.name);
+https://nixos.org/manual/nix/stable/expressions/language-constructs.html#functions.)", symbols[i.name]);
 
             }
         }
@@ -1586,8 +1622,8 @@ void ExprAssert::eval(EvalState & state, Env & env, Value & v)
 {
     if (!state.evalBool(env, cond, pos)) {
         std::ostringstream out;
-        cond->show(out);
-        throwAssertionError(pos, "assertion '%1%' failed", out.str());
+        cond->show(state.symbols, out);
+        state.throwAssertionError(pos, "assertion '%1%' failed", out.str());
     }
     body->eval(state, env, v);
 }
@@ -1680,7 +1716,7 @@ void ExprOpConcatLists::eval(EvalState & state, Env & env, Value & v)
 }
 
 
-void EvalState::concatLists(Value & v, size_t nrLists, Value * * lists, const Pos & pos)
+void EvalState::concatLists(Value & v, size_t nrLists, Value * * lists, const PosIdx pos)
 {
     nrListConcats++;
 
@@ -1764,14 +1800,14 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
                 nf = n;
                 nf += vTmp.fpoint;
             } else
-                throwEvalError(i_pos, "cannot add %1% to an integer", showType(vTmp));
+                state.throwEvalError(i_pos, "cannot add %1% to an integer", showType(vTmp));
         } else if (firstType == nFloat) {
             if (vTmp.type() == nInt) {
                 nf += vTmp.integer;
             } else if (vTmp.type() == nFloat) {
                 nf += vTmp.fpoint;
             } else
-                throwEvalError(i_pos, "cannot add %1% to a float", showType(vTmp));
+                state.throwEvalError(i_pos, "cannot add %1% to a float", showType(vTmp));
         } else {
             if (s.empty()) s.reserve(es->size());
             /* skip canonization of first path, which would only be not
@@ -1791,7 +1827,7 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
         v.mkFloat(nf);
     else if (firstType == nPath) {
         if (!context.empty())
-            throwEvalError(pos, "a string that refers to a store path cannot be appended to a path");
+            state.throwEvalError(pos, "a string that refers to a store path cannot be appended to a path");
         v.mkPath(canonPath(str()));
     } else
         v.mkStringMove(c_str(), context);
@@ -1800,7 +1836,7 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
 
 void ExprPos::eval(EvalState & state, Env & env, Value & v)
 {
-    state.mkPos(v, ptr(&pos));
+    state.mkPos(v, pos);
 }
 
 
@@ -1820,7 +1856,7 @@ void EvalState::forceValueDeep(Value & v)
                 try {
                     recurse(*i.value);
                 } catch (Error & e) {
-                    addErrorTrace(e, *i.pos, "while evaluating the attribute '%1%'", i.name);
+                    addErrorTrace(e, i.pos, "while evaluating the attribute '%1%'", symbols[i.name]);
                     throw;
                 }
         }
@@ -1835,7 +1871,7 @@ void EvalState::forceValueDeep(Value & v)
 }
 
 
-NixInt EvalState::forceInt(Value & v, const Pos & pos)
+NixInt EvalState::forceInt(Value & v, const PosIdx pos)
 {
     forceValue(v, pos);
     if (v.type() != nInt)
@@ -1844,7 +1880,7 @@ NixInt EvalState::forceInt(Value & v, const Pos & pos)
 }
 
 
-NixFloat EvalState::forceFloat(Value & v, const Pos & pos)
+NixFloat EvalState::forceFloat(Value & v, const PosIdx pos)
 {
     forceValue(v, pos);
     if (v.type() == nInt)
@@ -1855,7 +1891,7 @@ NixFloat EvalState::forceFloat(Value & v, const Pos & pos)
 }
 
 
-bool EvalState::forceBool(Value & v, const Pos & pos)
+bool EvalState::forceBool(Value & v, const PosIdx pos)
 {
     forceValue(v, pos);
     if (v.type() != nBool)
@@ -1870,7 +1906,7 @@ bool EvalState::isFunctor(Value & fun)
 }
 
 
-void EvalState::forceFunction(Value & v, const Pos & pos)
+void EvalState::forceFunction(Value & v, const PosIdx pos)
 {
     forceValue(v, pos);
     if (v.type() != nFunction && !isFunctor(v))
@@ -1878,7 +1914,7 @@ void EvalState::forceFunction(Value & v, const Pos & pos)
 }
 
 
-std::string_view EvalState::forceString(Value & v, const Pos & pos)
+std::string_view EvalState::forceString(Value & v, const PosIdx pos)
 {
     forceValue(v, pos);
     if (v.type() != nString) {
@@ -1931,7 +1967,7 @@ NixStringContext Value::getContext(const Store & store)
 }
 
 
-std::string_view EvalState::forceString(Value & v, PathSet & context, const Pos & pos)
+std::string_view EvalState::forceString(Value & v, PathSet & context, const PosIdx pos)
 {
     auto s = forceString(v, pos);
     copyContext(v, context);
@@ -1939,7 +1975,7 @@ std::string_view EvalState::forceString(Value & v, PathSet & context, const Pos
 }
 
 
-std::string_view EvalState::forceStringNoCtx(Value & v, const Pos & pos)
+std::string_view EvalState::forceStringNoCtx(Value & v, const PosIdx pos)
 {
     auto s = forceString(v, pos);
     if (v.string.context) {
@@ -1959,13 +1995,13 @@ bool EvalState::isDerivation(Value & v)
     if (v.type() != nAttrs) return false;
     Bindings::iterator i = v.attrs->find(sType);
     if (i == v.attrs->end()) return false;
-    forceValue(*i->value, *i->pos);
+    forceValue(*i->value, i->pos);
     if (i->value->type() != nString) return false;
     return strcmp(i->value->string.s, "derivation") == 0;
 }
 
 
-std::optional<std::string> EvalState::tryAttrsToString(const Pos & pos, Value & v,
+std::optional<std::string> EvalState::tryAttrsToString(const PosIdx pos, Value & v,
     PathSet & context, bool coerceMore, bool copyToStore)
 {
     auto i = v.attrs->find(sToString);
@@ -1978,7 +2014,7 @@ std::optional<std::string> EvalState::tryAttrsToString(const Pos & pos, Value &
     return {};
 }
 
-BackedStringView EvalState::coerceToString(const Pos & pos, Value & v, PathSet & context,
+BackedStringView EvalState::coerceToString(const PosIdx pos, Value & v, PathSet & context,
     bool coerceMore, bool copyToStore, bool canonicalizePath)
 {
     forceValue(v, pos);
@@ -2007,7 +2043,7 @@ BackedStringView EvalState::coerceToString(const Pos & pos, Value & v, PathSet &
     }
 
     if (v.type() == nExternal)
-        return v.external->coerceToString(pos, context, coerceMore, copyToStore);
+        return v.external->coerceToString(positions[pos], context, coerceMore, copyToStore);
 
     if (coerceMore) {
 
@@ -2060,7 +2096,7 @@ std::string EvalState::copyPathToStore(PathSet & context, const Path & path)
 }
 
 
-Path EvalState::coerceToPath(const Pos & pos, Value & v, PathSet & context)
+Path EvalState::coerceToPath(const PosIdx pos, Value & v, PathSet & context)
 {
     auto path = coerceToString(pos, v, context, false, false).toOwned();
     if (path == "" || path[0] != '/')
@@ -2069,14 +2105,14 @@ Path EvalState::coerceToPath(const Pos & pos, Value & v, PathSet & context)
 }
 
 
-StorePath EvalState::coerceToStorePath(const Pos & pos, Value & v, PathSet & context)
+StorePath EvalState::coerceToStorePath(const PosIdx pos, Value & v, PathSet & context)
 {
     auto path = coerceToString(pos, v, context, false, false).toOwned();
     if (auto storePath = store->maybeParseStorePath(path))
         return *storePath;
     throw EvalError({
         .msg = hintfmt("path '%1%' is not in the Nix store", path),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
@@ -2243,14 +2279,14 @@ void EvalState::printStats()
                 auto list = topObj.list("functions");
                 for (auto & i : functionCalls) {
                     auto obj = list.object();
-                    if (i.first->name.set())
+                    if (i.first->name)
                         obj.attr("name", (const std::string &) i.first->name);
                     else
                         obj.attr("name", nullptr);
-                    if (i.first->pos) {
-                        obj.attr("file", (const std::string &) i.first->pos.file);
-                        obj.attr("line", i.first->pos.line);
-                        obj.attr("column", i.first->pos.column);
+                    if (auto pos = positions[i.first->pos]) {
+                        obj.attr("file", (const std::string &) pos.file);
+                        obj.attr("line", pos.line);
+                        obj.attr("column", pos.column);
                     }
                     obj.attr("count", i.second);
                 }
@@ -2259,10 +2295,10 @@ void EvalState::printStats()
                 auto list = topObj.list("attributes");
                 for (auto & i : attrSelects) {
                     auto obj = list.object();
-                    if (i.first) {
-                        obj.attr("file", (const std::string &) i.first.file);
-                        obj.attr("line", i.first.line);
-                        obj.attr("column", i.first.column);
+                    if (auto pos = positions[i.first]) {
+                        obj.attr("file", (const std::string &) pos.file);
+                        obj.attr("line", pos.line);
+                        obj.attr("column", pos.column);
                     }
                     obj.attr("count", i.second);
                 }
diff --git a/src/libexpr/eval.hh b/src/libexpr/eval.hh
index 7ed376e8d..774bc17bb 100644
--- a/src/libexpr/eval.hh
+++ b/src/libexpr/eval.hh
@@ -23,14 +23,14 @@ class StorePath;
 enum RepairFlag : bool;
 
 
-typedef void (* PrimOpFun) (EvalState & state, const Pos & pos, Value * * args, Value & v);
+typedef void (* PrimOpFun) (EvalState & state, const PosIdx pos, Value * * args, Value & v);
 
 
 struct PrimOp
 {
     PrimOpFun fun;
     size_t arity;
-    Symbol name;
+    std::string name;
     std::vector<std::string> args;
     const char * doc = nullptr;
 };
@@ -53,7 +53,9 @@ void copyContext(const Value & v, PathSet & context);
 typedef std::map<Path, StorePath> SrcToStore;
 
 
-std::ostream & operator << (std::ostream & str, const Value & v);
+std::ostream & printValue(const EvalState & state, std::ostream & str, const Value & v);
+std::string printValue(const EvalState & state, const Value & v);
+std::ostream & operator << (std::ostream & os, const ValueType t);
 
 
 typedef std::pair<std::string, std::string> SearchPathElem;
@@ -73,6 +75,9 @@ class EvalState
 {
 public:
     SymbolTable symbols;
+    PosTable positions;
+
+    static inline std::string derivationNixPath = "//builtin/derivation.nix";
 
     const Symbol sWith, sOutPath, sDrvPath, sType, sMeta, sName, sValue,
         sSystem, sOverrides, sOutputs, sOutputName, sIgnoreNulls,
@@ -205,7 +210,7 @@ public:
 
     /* Look up a file in the search path. */
     Path findFile(const std::string_view path);
-    Path findFile(SearchPath & searchPath, const std::string_view path, const Pos & pos = noPos);
+    Path findFile(SearchPath & searchPath, const std::string_view path, const PosIdx pos = noPos);
 
     /* If the specified search path element is a URI, download it. */
     std::pair<bool, std::string> resolveSearchPathElem(const SearchPathElem & elem);
@@ -217,14 +222,14 @@ public:
     /* 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 Pos & pos);
+    inline bool evalBool(Env & env, Expr * e, const PosIdx pos);
     inline void evalAttrs(Env & env, Expr * e, Value & v);
 
     /* 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 Pos & pos);
+    inline void forceValue(Value & v, const PosIdx pos);
 
     template <typename Callable>
     inline void forceValue(Value & v, Callable getPos);
@@ -234,33 +239,72 @@ public:
     void forceValueDeep(Value & v);
 
     /* Force `v', and then verify that it has the expected type. */
-    NixInt forceInt(Value & v, const Pos & pos);
-    NixFloat forceFloat(Value & v, const Pos & pos);
-    bool forceBool(Value & v, const Pos & pos);
+    NixInt forceInt(Value & v, const PosIdx pos);
+    NixFloat forceFloat(Value & v, const PosIdx pos);
+    bool forceBool(Value & v, const PosIdx pos);
 
-    void forceAttrs(Value & v, const Pos & pos);
+    void forceAttrs(Value & v, const PosIdx pos);
 
     template <typename Callable>
     inline void forceAttrs(Value & v, Callable getPos);
 
-    inline void forceList(Value & v, const Pos & pos);
-    void forceFunction(Value & v, const Pos & pos); // either lambda or primop
-    std::string_view forceString(Value & v, const Pos & pos = noPos);
-    std::string_view forceString(Value & v, PathSet & context, const Pos & pos = noPos);
-    std::string_view forceStringNoCtx(Value & v, const Pos & pos = noPos);
+    inline void forceList(Value & v, const PosIdx pos);
+    void forceFunction(Value & v, const PosIdx pos); // either lambda or primop
+    std::string_view forceString(Value & v, const PosIdx pos = noPos);
+    std::string_view forceString(Value & v, PathSet & context, const PosIdx pos = noPos);
+    std::string_view forceStringNoCtx(Value & v, const PosIdx pos = noPos);
+
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx pos, const char * s) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwTypeError(const PosIdx pos, const char * s, const Value & v) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const char * s, const std::string & s2) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx pos, const Suggestions & suggestions, const char * s,
+        const std::string & s2) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const char * s, const std::string & s2, const std::string & s3) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2, const std::string & s3) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx p1, const char * s, const Symbol sym, const PosIdx p2) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwTypeError(const PosIdx pos, const char * s) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwTypeError(const PosIdx pos, const char * s, const ExprLambda & fun, const Symbol s2) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwTypeError(const PosIdx pos, const Suggestions & suggestions, const char * s,
+        const ExprLambda & fun, const Symbol s2) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwTypeError(const char * s, const Value & v) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwAssertionError(const PosIdx pos, const char * s, const std::string & s1) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1) const;
+
+    [[gnu::noinline]]
+    void addErrorTrace(Error & e, const char * s, const std::string & s2) const;
+    [[gnu::noinline]]
+    void addErrorTrace(Error & e, const PosIdx pos, const char * s, const std::string & s2) 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 Pos & pos, Value & v,
+    std::optional<std::string> tryAttrsToString(const PosIdx pos, Value & v,
         PathSet & 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 Pos & pos, Value & v, PathSet & context,
+    BackedStringView coerceToString(const PosIdx pos, Value & v, PathSet & context,
         bool coerceMore = false, bool copyToStore = true,
         bool canonicalizePath = true);
 
@@ -269,10 +313,10 @@ public:
     /* 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. */
-    Path coerceToPath(const Pos & pos, Value & v, PathSet & context);
+    Path coerceToPath(const PosIdx pos, Value & v, PathSet & context);
 
     /* Like coerceToPath, but the result must be a store path. */
-    StorePath coerceToStorePath(const Pos & pos, Value & v, PathSet & context);
+    StorePath coerceToStorePath(const PosIdx pos, Value & v, PathSet & context);
 
 public:
 
@@ -305,7 +349,7 @@ public:
     struct Doc
     {
         Pos pos;
-        std::optional<Symbol> name;
+        std::optional<std::string> name;
         size_t arity;
         std::vector<std::string> args;
         const char * doc;
@@ -333,9 +377,9 @@ public:
     bool isFunctor(Value & fun);
 
     // FIXME: use std::span
-    void callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const Pos & pos);
+    void callFunction(Value & fun, size_t nrArgs, Value * * args, Value & vRes, const PosIdx pos);
 
-    void callFunction(Value & fun, Value & arg, Value & vRes, const Pos & pos)
+    void callFunction(Value & fun, Value & arg, Value & vRes, const PosIdx pos)
     {
         Value * args[] = {&arg};
         callFunction(fun, 1, args, vRes, pos);
@@ -349,7 +393,7 @@ public:
     inline Value * allocValue();
     inline Env & allocEnv(size_t size);
 
-    Value * allocAttr(Value & vAttrs, const Symbol & name);
+    Value * allocAttr(Value & vAttrs, Symbol name);
     Value * allocAttr(Value & vAttrs, std::string_view name);
 
     Bindings * allocBindings(size_t capacity);
@@ -361,9 +405,9 @@ public:
 
     void mkList(Value & v, size_t length);
     void mkThunk_(Value & v, Expr * expr);
-    void mkPos(Value & v, ptr<Pos> pos);
+    void mkPos(Value & v, PosIdx pos);
 
-    void concatLists(Value & v, size_t nrLists, Value * * lists, const Pos & pos);
+    void concatLists(Value & v, size_t nrLists, Value * * lists, const PosIdx pos);
 
     /* Print statistics. */
     void printStats();
@@ -391,7 +435,7 @@ private:
 
     bool countCalls;
 
-    typedef std::map<Symbol, size_t> PrimOpCalls;
+    typedef std::map<std::string, size_t> PrimOpCalls;
     PrimOpCalls primOpCalls;
 
     typedef std::map<ExprLambda *, size_t> FunctionCalls;
@@ -399,7 +443,7 @@ private:
 
     void incrFunctionCall(ExprLambda * fun);
 
-    typedef std::map<Pos, size_t> AttrSelects;
+    typedef std::map<PosIdx, size_t> AttrSelects;
     AttrSelects attrSelects;
 
     friend struct ExprOpUpdate;
@@ -410,9 +454,9 @@ private:
     friend struct ExprFloat;
     friend struct ExprPath;
     friend struct ExprSelect;
-    friend void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v);
-    friend void prim_match(EvalState & state, const Pos & pos, Value * * args, Value & v);
-    friend void prim_split(EvalState & state, const Pos & pos, Value * * args, Value & v);
+    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;
 };
diff --git a/src/libexpr/flake/config.cc b/src/libexpr/flake/config.cc
index a811e59a1..92ec27046 100644
--- a/src/libexpr/flake/config.cc
+++ b/src/libexpr/flake/config.cc
@@ -50,13 +50,11 @@ void ConfigFile::apply()
         else
             assert(false);
 
-        if (!whitelist.count(baseName)) {
-            auto trustedList = readTrustedList();
-
+        if (!whitelist.count(baseName) && !nix::fetchSettings.acceptFlakeConfig) {
             bool trusted = false;
-            if (nix::fetchSettings.acceptFlakeConfig){
-                trusted = true;
-            } else if (auto saved = get(get(trustedList, name).value_or(std::map<std::string, bool>()), valueS)) {
+            auto trustedList = readTrustedList();
+            auto tlname = get(trustedList, name);
+            if (auto saved = tlname ? get(*tlname, valueS) : nullptr) {
                 trusted = *saved;
                 warn("Using saved setting for '%s = %s' from ~/.local/share/nix/trusted-settings.json.", name,valueS);
             } else {
@@ -69,7 +67,6 @@ void ConfigFile::apply()
                     writeTrustedList(trustedList);
                 }
             }
-
             if (!trusted) {
                 warn("ignoring untrusted flake configuration setting '%s'", name);
                 continue;
diff --git a/src/libexpr/flake/flake.cc b/src/libexpr/flake/flake.cc
index 22257c6b3..cbf4f0a6f 100644
--- a/src/libexpr/flake/flake.cc
+++ b/src/libexpr/flake/flake.cc
@@ -72,7 +72,7 @@ static std::tuple<fetchers::Tree, FlakeRef, FlakeRef> fetchOrSubstituteTree(
     return {std::move(tree), resolvedRef, lockedRef};
 }
 
-static void forceTrivialValue(EvalState & state, Value & value, const Pos & pos)
+static void forceTrivialValue(EvalState & state, Value & value, const PosIdx pos)
 {
     if (value.isThunk() && value.isTrivial())
         state.forceValue(value, pos);
@@ -80,20 +80,20 @@ static void forceTrivialValue(EvalState & state, Value & value, const Pos & pos)
 
 
 static void expectType(EvalState & state, ValueType type,
-    Value & value, const Pos & pos)
+    Value & value, const PosIdx pos)
 {
     forceTrivialValue(state, value, pos);
     if (value.type() != type)
         throw Error("expected %s but got %s at %s",
-            showType(type), showType(value.type()), pos);
+            showType(type), showType(value.type()), state.positions[pos]);
 }
 
 static std::map<FlakeId, FlakeInput> parseFlakeInputs(
-    EvalState & state, Value * value, const Pos & pos,
+    EvalState & state, Value * value, const PosIdx pos,
     const std::optional<Path> & baseDir, InputPath lockRootPath);
 
 static FlakeInput parseFlakeInput(EvalState & state,
-    const std::string & inputName, Value * value, const Pos & pos,
+    const std::string & inputName, Value * value, const PosIdx pos,
     const std::optional<Path> & baseDir, InputPath lockRootPath)
 {
     expectType(state, nAttrs, *value, pos);
@@ -111,37 +111,39 @@ static FlakeInput parseFlakeInput(EvalState & state,
     for (nix::Attr attr : *(value->attrs)) {
         try {
             if (attr.name == sUrl) {
-                expectType(state, nString, *attr.value, *attr.pos);
+                expectType(state, nString, *attr.value, attr.pos);
                 url = attr.value->string.s;
                 attrs.emplace("url", *url);
             } else if (attr.name == sFlake) {
-                expectType(state, nBool, *attr.value, *attr.pos);
+                expectType(state, nBool, *attr.value, attr.pos);
                 input.isFlake = attr.value->boolean;
             } else if (attr.name == sInputs) {
-                input.overrides = parseFlakeInputs(state, attr.value, *attr.pos, baseDir, lockRootPath);
+                input.overrides = parseFlakeInputs(state, attr.value, attr.pos, baseDir, lockRootPath);
             } else if (attr.name == sFollows) {
-                expectType(state, nString, *attr.value, *attr.pos);
+                expectType(state, nString, *attr.value, attr.pos);
                 auto follows(parseInputPath(attr.value->string.s));
                 follows.insert(follows.begin(), lockRootPath.begin(), lockRootPath.end());
                 input.follows = follows;
             } else {
                 switch (attr.value->type()) {
                     case nString:
-                        attrs.emplace(attr.name, attr.value->string.s);
+                        attrs.emplace(state.symbols[attr.name], attr.value->string.s);
                         break;
                     case nBool:
-                        attrs.emplace(attr.name, Explicit<bool> { attr.value->boolean });
+                        attrs.emplace(state.symbols[attr.name], Explicit<bool> { attr.value->boolean });
                         break;
                     case nInt:
-                        attrs.emplace(attr.name, (long unsigned int)attr.value->integer);
+                        attrs.emplace(state.symbols[attr.name], (long unsigned int)attr.value->integer);
                         break;
                     default:
                         throw TypeError("flake input attribute '%s' is %s while a string, Boolean, or integer is expected",
-                            attr.name, showType(*attr.value));
+                            state.symbols[attr.name], showType(*attr.value));
                 }
             }
         } catch (Error & e) {
-            e.addTrace(*attr.pos, hintfmt("in flake attribute '%s'", attr.name));
+            e.addTrace(
+                state.positions[attr.pos],
+                hintfmt("in flake attribute '%s'", state.symbols[attr.name]));
             throw;
         }
     }
@@ -150,13 +152,13 @@ static FlakeInput parseFlakeInput(EvalState & state,
         try {
             input.ref = FlakeRef::fromAttrs(attrs);
         } catch (Error & e) {
-            e.addTrace(pos, hintfmt("in flake input"));
+            e.addTrace(state.positions[pos], hintfmt("in flake input"));
             throw;
         }
     else {
         attrs.erase("url");
         if (!attrs.empty())
-            throw Error("unexpected flake input attribute '%s', at %s", attrs.begin()->first, pos);
+            throw Error("unexpected flake input attribute '%s', at %s", attrs.begin()->first, state.positions[pos]);
         if (url)
             input.ref = parseFlakeRef(*url, baseDir, true, input.isFlake);
     }
@@ -168,7 +170,7 @@ static FlakeInput parseFlakeInput(EvalState & state,
 }
 
 static std::map<FlakeId, FlakeInput> parseFlakeInputs(
-    EvalState & state, Value * value, const Pos & pos,
+    EvalState & state, Value * value, const PosIdx pos,
     const std::optional<Path> & baseDir, InputPath lockRootPath)
 {
     std::map<FlakeId, FlakeInput> inputs;
@@ -176,11 +178,11 @@ static std::map<FlakeId, FlakeInput> parseFlakeInputs(
     expectType(state, nAttrs, *value, pos);
 
     for (nix::Attr & inputAttr : *(*value).attrs) {
-        inputs.emplace(inputAttr.name,
+        inputs.emplace(state.symbols[inputAttr.name],
             parseFlakeInput(state,
-                inputAttr.name,
+                state.symbols[inputAttr.name],
                 inputAttr.value,
-                *inputAttr.pos,
+                inputAttr.pos,
                 baseDir,
                 lockRootPath));
     }
@@ -218,28 +220,28 @@ static Flake getFlake(
     Value vInfo;
     state.evalFile(flakeFile, vInfo, true); // FIXME: symlink attack
 
-    expectType(state, nAttrs, vInfo, Pos(foFile, state.symbols.create(flakeFile), 0, 0));
+    expectType(state, nAttrs, vInfo, state.positions.add({flakeFile, foFile}, 0, 0));
 
     if (auto description = vInfo.attrs->get(state.sDescription)) {
-        expectType(state, nString, *description->value, *description->pos);
+        expectType(state, nString, *description->value, description->pos);
         flake.description = description->value->string.s;
     }
 
     auto sInputs = state.symbols.create("inputs");
 
     if (auto inputs = vInfo.attrs->get(sInputs))
-        flake.inputs = parseFlakeInputs(state, inputs->value, *inputs->pos, flakeDir, lockRootPath);
+        flake.inputs = parseFlakeInputs(state, inputs->value, inputs->pos, flakeDir, lockRootPath);
 
     auto sOutputs = state.symbols.create("outputs");
 
     if (auto outputs = vInfo.attrs->get(sOutputs)) {
-        expectType(state, nFunction, *outputs->value, *outputs->pos);
+        expectType(state, nFunction, *outputs->value, outputs->pos);
 
         if (outputs->value->isLambda() && outputs->value->lambda.fun->hasFormals()) {
             for (auto & formal : outputs->value->lambda.fun->formals->formals) {
                 if (formal.name != state.sSelf)
-                    flake.inputs.emplace(formal.name, FlakeInput {
-                        .ref = parseFlakeRef(formal.name)
+                    flake.inputs.emplace(state.symbols[formal.name], FlakeInput {
+                        .ref = parseFlakeRef(state.symbols[formal.name])
                     });
             }
         }
@@ -250,35 +252,41 @@ static Flake getFlake(
     auto sNixConfig = state.symbols.create("nixConfig");
 
     if (auto nixConfig = vInfo.attrs->get(sNixConfig)) {
-        expectType(state, nAttrs, *nixConfig->value, *nixConfig->pos);
+        expectType(state, nAttrs, *nixConfig->value, nixConfig->pos);
 
         for (auto & setting : *nixConfig->value->attrs) {
-            forceTrivialValue(state, *setting.value, *setting.pos);
+            forceTrivialValue(state, *setting.value, setting.pos);
             if (setting.value->type() == nString)
-                flake.config.settings.insert({setting.name, std::string(state.forceStringNoCtx(*setting.value, *setting.pos))});
+                flake.config.settings.emplace(
+                    state.symbols[setting.name],
+                    std::string(state.forceStringNoCtx(*setting.value, setting.pos)));
             else if (setting.value->type() == nPath) {
                 PathSet emptyContext = {};
                 flake.config.settings.emplace(
-                    setting.name,
-                    state.coerceToString(*setting.pos, *setting.value, emptyContext, false, true, true) .toOwned());
+                    state.symbols[setting.name],
+                    state.coerceToString(setting.pos, *setting.value, emptyContext, false, true, true) .toOwned());
             }
             else if (setting.value->type() == nInt)
-                flake.config.settings.insert({setting.name, state.forceInt(*setting.value, *setting.pos)});
+                flake.config.settings.emplace(
+                    state.symbols[setting.name],
+                    state.forceInt(*setting.value, setting.pos));
             else if (setting.value->type() == nBool)
-                flake.config.settings.insert({setting.name, Explicit<bool> { state.forceBool(*setting.value, *setting.pos) }});
+                flake.config.settings.emplace(
+                    state.symbols[setting.name],
+                    Explicit<bool> { state.forceBool(*setting.value, setting.pos) });
             else if (setting.value->type() == nList) {
                 std::vector<std::string> ss;
                 for (auto elem : setting.value->listItems()) {
                     if (elem->type() != nString)
                         throw TypeError("list element in flake configuration setting '%s' is %s while a string is expected",
-                            setting.name, showType(*setting.value));
-                    ss.emplace_back(state.forceStringNoCtx(*elem, *setting.pos));
+                            state.symbols[setting.name], showType(*setting.value));
+                    ss.emplace_back(state.forceStringNoCtx(*elem, setting.pos));
                 }
-                flake.config.settings.insert({setting.name, ss});
+                flake.config.settings.emplace(state.symbols[setting.name], ss);
             }
             else
                 throw TypeError("flake configuration setting '%s' is %s",
-                    setting.name, showType(*setting.value));
+                    state.symbols[setting.name], showType(*setting.value));
         }
     }
 
@@ -288,7 +296,7 @@ static Flake getFlake(
             attr.name != sOutputs &&
             attr.name != sNixConfig)
             throw Error("flake '%s' has an unsupported attribute '%s', at %s",
-                lockedRef, attr.name, *attr.pos);
+                lockedRef, state.symbols[attr.name], state.positions[attr.pos]);
     }
 
     return flake;
@@ -704,12 +712,12 @@ void callFlake(EvalState & state,
     state.callFunction(*vTmp2, *vRootSubdir, vRes, noPos);
 }
 
-static void prim_getFlake(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_getFlake(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     std::string flakeRefS(state.forceStringNoCtx(*args[0], pos));
     auto flakeRef = parseFlakeRef(flakeRefS, {}, true);
     if (evalSettings.pureEval && !flakeRef.input.isLocked())
-        throw Error("cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)", flakeRefS, pos);
+        throw Error("cannot call 'getFlake' on unlocked flake reference '%s', at %s (use --impure to override)", flakeRefS, state.positions[pos]);
 
     callFlake(state,
         lockFlake(state, flakeRef,
diff --git a/src/libexpr/flake/flakeref.cc b/src/libexpr/flake/flakeref.cc
index c1eae413f..eede493f8 100644
--- a/src/libexpr/flake/flakeref.cc
+++ b/src/libexpr/flake/flakeref.cc
@@ -176,7 +176,7 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
                             parsedURL.query.insert_or_assign("shallow", "1");
 
                         return std::make_pair(
-                            FlakeRef(Input::fromURL(parsedURL), get(parsedURL.query, "dir").value_or("")),
+                            FlakeRef(Input::fromURL(parsedURL), getOr(parsedURL.query, "dir", "")),
                             fragment);
                     }
 
@@ -189,7 +189,7 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
             if (!hasPrefix(path, "/"))
                 throw BadURL("flake reference '%s' is not an absolute path", url);
             auto query = decodeQuery(match[2]);
-            path = canonPath(path + "/" + get(query, "dir").value_or(""));
+            path = canonPath(path + "/" + getOr(query, "dir", ""));
         }
 
         fetchers::Attrs attrs;
@@ -208,7 +208,7 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
         input.parent = baseDir;
 
         return std::make_pair(
-            FlakeRef(std::move(input), get(parsedURL.query, "dir").value_or("")),
+            FlakeRef(std::move(input), getOr(parsedURL.query, "dir", "")),
             fragment);
     }
 }
@@ -238,4 +238,15 @@ std::pair<fetchers::Tree, FlakeRef> FlakeRef::fetchTree(ref<Store> store) const
     return {std::move(tree), FlakeRef(std::move(lockedInput), subdir)};
 }
 
+std::tuple<FlakeRef, std::string, OutputsSpec> parseFlakeRefWithFragmentAndOutputsSpec(
+    const std::string & url,
+    const std::optional<Path> & baseDir,
+    bool allowMissing,
+    bool isFlake)
+{
+    auto [prefix, outputsSpec] = parseOutputsSpec(url);
+    auto [flakeRef, fragment] = parseFlakeRefWithFragment(prefix, baseDir, allowMissing, isFlake);
+    return {std::move(flakeRef), fragment, outputsSpec};
+}
+
 }
diff --git a/src/libexpr/flake/flakeref.hh b/src/libexpr/flake/flakeref.hh
index 1fddfd9a0..a9182f4bf 100644
--- a/src/libexpr/flake/flakeref.hh
+++ b/src/libexpr/flake/flakeref.hh
@@ -3,6 +3,7 @@
 #include "types.hh"
 #include "hash.hh"
 #include "fetchers.hh"
+#include "path-with-outputs.hh"
 
 #include <variant>
 
@@ -79,4 +80,11 @@ std::pair<FlakeRef, std::string> parseFlakeRefWithFragment(
 std::optional<std::pair<FlakeRef, std::string>> maybeParseFlakeRefWithFragment(
     const std::string & url, const std::optional<Path> & baseDir = {});
 
+std::tuple<FlakeRef, std::string, OutputsSpec> parseFlakeRefWithFragmentAndOutputsSpec(
+    const std::string & url,
+    const std::optional<Path> & baseDir = {},
+    bool allowMissing = false,
+    bool isFlake = true);
+
+
 }
diff --git a/src/libexpr/function-trace.hh b/src/libexpr/function-trace.hh
index 472f2045e..e9a2526bd 100644
--- a/src/libexpr/function-trace.hh
+++ b/src/libexpr/function-trace.hh
@@ -8,7 +8,7 @@ namespace nix {
 
 struct FunctionCallTrace
 {
-    const Pos & pos;
+    const Pos pos;
     FunctionCallTrace(const Pos & pos);
     ~FunctionCallTrace();
 };
diff --git a/src/libexpr/get-drvs.cc b/src/libexpr/get-drvs.cc
index bb7e77b61..d616b3921 100644
--- a/src/libexpr/get-drvs.cc
+++ b/src/libexpr/get-drvs.cc
@@ -34,7 +34,7 @@ DrvInfo::DrvInfo(EvalState & state, ref<Store> store, const std::string & drvPat
 
     outputName =
         selectedOutputs.empty()
-        ? get(drv.env, "outputName").value_or("out")
+        ? getOr(drv.env, "outputName", "out")
         : *selectedOutputs.begin();
 
     auto i = drv.outputs.find(outputName);
@@ -61,7 +61,7 @@ std::string DrvInfo::querySystem() const
 {
     if (system == "" && attrs) {
         auto i = attrs->find(state->sSystem);
-        system = i == attrs->end() ? "unknown" : state->forceStringNoCtx(*i->value, *i->pos);
+        system = i == attrs->end() ? "unknown" : state->forceStringNoCtx(*i->value, i->pos);
     }
     return system;
 }
@@ -75,7 +75,7 @@ std::optional<StorePath> DrvInfo::queryDrvPath() const
         if (i == attrs->end())
             drvPath = {std::nullopt};
         else
-            drvPath = {state->coerceToStorePath(*i->pos, *i->value, context)};
+            drvPath = {state->coerceToStorePath(i->pos, *i->value, context)};
     }
     return drvPath.value_or(std::nullopt);
 }
@@ -95,7 +95,7 @@ StorePath DrvInfo::queryOutPath() const
         Bindings::iterator i = attrs->find(state->sOutPath);
         PathSet context;
         if (i != attrs->end())
-            outPath = state->coerceToStorePath(*i->pos, *i->value, context);
+            outPath = state->coerceToStorePath(i->pos, *i->value, context);
     }
     if (!outPath)
         throw UnimplementedError("CA derivations are not yet supported");
@@ -109,23 +109,23 @@ DrvInfo::Outputs DrvInfo::queryOutputs(bool withPaths, bool onlyOutputsToInstall
         /* Get the ‘outputs’ list. */
         Bindings::iterator i;
         if (attrs && (i = attrs->find(state->sOutputs)) != attrs->end()) {
-            state->forceList(*i->value, *i->pos);
+            state->forceList(*i->value, i->pos);
 
             /* For each output... */
             for (auto elem : i->value->listItems()) {
-                std::string output(state->forceStringNoCtx(*elem, *i->pos));
+                std::string output(state->forceStringNoCtx(*elem, i->pos));
 
                 if (withPaths) {
                     /* Evaluate the corresponding set. */
                     Bindings::iterator out = attrs->find(state->symbols.create(output));
                     if (out == attrs->end()) continue; // FIXME: throw error?
-                    state->forceAttrs(*out->value, *i->pos);
+                    state->forceAttrs(*out->value, i->pos);
 
                     /* And evaluate its ‘outPath’ attribute. */
                     Bindings::iterator outPath = out->value->attrs->find(state->sOutPath);
                     if (outPath == out->value->attrs->end()) continue; // FIXME: throw error?
                     PathSet context;
-                    outputs.emplace(output, state->coerceToStorePath(*outPath->pos, *outPath->value, context));
+                    outputs.emplace(output, state->coerceToStorePath(outPath->pos, *outPath->value, context));
                 } else
                     outputs.emplace(output, std::nullopt);
             }
@@ -168,7 +168,7 @@ Bindings * DrvInfo::getMeta()
     if (!attrs) return 0;
     Bindings::iterator a = attrs->find(state->sMeta);
     if (a == attrs->end()) return 0;
-    state->forceAttrs(*a->value, *a->pos);
+    state->forceAttrs(*a->value, a->pos);
     meta = a->value->attrs;
     return meta;
 }
@@ -179,7 +179,7 @@ StringSet DrvInfo::queryMetaNames()
     StringSet res;
     if (!getMeta()) return res;
     for (auto & i : *meta)
-        res.insert(i.name);
+        res.emplace(state->symbols[i.name]);
     return res;
 }
 
@@ -269,7 +269,7 @@ void DrvInfo::setMeta(const std::string & name, Value * v)
 {
     getMeta();
     auto attrs = state->buildBindings(1 + (meta ? meta->size() : 0));
-    Symbol sym = state->symbols.create(name);
+    auto sym = state->symbols.create(name);
     if (meta)
         for (auto i : *meta)
             if (i.name != sym)
@@ -356,11 +356,11 @@ static void getDerivations(EvalState & state, Value & vIn,
            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()) {
-            debug("evaluating attribute '%1%'", i->name);
-            if (!std::regex_match(std::string(i->name), attrRegex))
+        for (auto & i : v.attrs->lexicographicOrder(state.symbols)) {
+            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, i->name);
+            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)) {
@@ -369,7 +369,7 @@ static void getDerivations(EvalState & state, Value & vIn,
                    `recurseForDerivations = true' attribute. */
                 if (i->value->type() == nAttrs) {
                     Bindings::iterator j = i->value->attrs->find(state.sRecurseForDerivations);
-                    if (j != i->value->attrs->end() && state.forceBool(*j->value, *j->pos))
+                    if (j != i->value->attrs->end() && state.forceBool(*j->value, j->pos))
                         getDerivations(state, *i->value, pathPrefix2, autoArgs, drvs, done, ignoreAssertionFailures);
                 }
             }
diff --git a/src/libexpr/lexer.l b/src/libexpr/lexer.l
index d574121b0..4c28b976e 100644
--- a/src/libexpr/lexer.l
+++ b/src/libexpr/lexer.l
@@ -28,9 +28,9 @@ using namespace nix;
 
 namespace nix {
 
-static inline Pos makeCurPos(const YYLTYPE & loc, ParseData * data)
+static inline PosIdx makeCurPos(const YYLTYPE & loc, ParseData * data)
 {
-    return Pos(data->origin, data->file, loc.first_line, loc.first_column);
+    return data->state.positions.add(data->origin, loc.first_line, loc.first_column);
 }
 
 #define CUR_POS makeCurPos(*yylloc, data)
@@ -155,7 +155,7 @@ or          { return OR_KW; }
               } catch (const boost::bad_lexical_cast &) {
                   throw ParseError({
                       .msg = hintfmt("invalid integer '%1%'", yytext),
-                      .errPos = CUR_POS,
+                      .errPos = data->state.positions[CUR_POS],
                   });
               }
               return INT;
@@ -165,7 +165,7 @@ or          { return OR_KW; }
               if (errno != 0)
                   throw ParseError({
                       .msg = hintfmt("invalid float '%1%'", yytext),
-                      .errPos = CUR_POS,
+                      .errPos = data->state.positions[CUR_POS],
                   });
               return FLOAT;
             }
@@ -294,7 +294,7 @@ or          { return OR_KW; }
 <INPATH_SLASH><<EOF>> {
   throw ParseError({
       .msg = hintfmt("path has a trailing slash"),
-      .errPos = CUR_POS,
+      .errPos = data->state.positions[CUR_POS],
   });
 }
 
diff --git a/src/libexpr/nixexpr.cc b/src/libexpr/nixexpr.cc
index a2def65a6..c529fdc89 100644
--- a/src/libexpr/nixexpr.cc
+++ b/src/libexpr/nixexpr.cc
@@ -1,5 +1,7 @@
 #include "nixexpr.hh"
 #include "derivations.hh"
+#include "eval.hh"
+#include "symbol-table.hh"
 #include "util.hh"
 
 #include <cstdlib>
@@ -10,12 +12,6 @@ namespace nix {
 
 /* Displaying abstract syntax trees. */
 
-std::ostream & operator << (std::ostream & str, const Expr & e)
-{
-    e.show(str);
-    return str;
-}
-
 static void showString(std::ostream & str, std::string_view s)
 {
     str << '"';
@@ -28,8 +24,10 @@ static void showString(std::ostream & str, std::string_view s)
     str << '"';
 }
 
-static void showId(std::ostream & str, std::string_view s)
+std::ostream & operator <<(std::ostream & str, const SymbolStr & symbol)
 {
+    std::string_view s = symbol;
+
     if (s.empty())
         str << "\"\"";
     else if (s == "if") // FIXME: handle other keywords
@@ -38,7 +36,7 @@ static void showId(std::ostream & str, std::string_view s)
         char c = s[0];
         if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_')) {
             showString(str, s);
-            return;
+            return str;
         }
         for (auto c : s)
             if (!((c >= 'a' && c <= 'z') ||
@@ -46,89 +44,104 @@ static void showId(std::ostream & str, std::string_view s)
                   (c >= '0' && c <= '9') ||
                   c == '_' || c == '\'' || c == '-')) {
                 showString(str, s);
-                return;
+                return str;
             }
         str << s;
     }
-}
-
-std::ostream & operator << (std::ostream & str, const Symbol & sym)
-{
-    showId(str, *sym.s);
     return str;
 }
 
-void Expr::show(std::ostream & str) const
+void Expr::show(const SymbolTable & symbols, std::ostream & str) const
 {
     abort();
 }
 
-void ExprInt::show(std::ostream & str) const
+void ExprInt::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << n;
 }
 
-void ExprFloat::show(std::ostream & str) const
+void ExprFloat::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << nf;
 }
 
-void ExprString::show(std::ostream & str) const
+void ExprString::show(const SymbolTable & symbols, std::ostream & str) const
 {
     showString(str, s);
 }
 
-void ExprPath::show(std::ostream & str) const
+void ExprPath::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << s;
 }
 
-void ExprVar::show(std::ostream & str) const
+void ExprVar::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << name;
+    str << symbols[name];
 }
 
-void ExprSelect::show(std::ostream & str) const
+void ExprSelect::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << "(" << *e << ")." << showAttrPath(attrPath);
-    if (def) str << " or (" << *def << ")";
+    str << "(";
+    e->show(symbols, str);
+    str << ")." << showAttrPath(symbols, attrPath);
+    if (def) {
+        str << " or (";
+        def->show(symbols, str);
+        str << ")";
+    }
 }
 
-void ExprOpHasAttr::show(std::ostream & str) const
+void ExprOpHasAttr::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << "((" << *e << ") ? " << showAttrPath(attrPath) << ")";
+    str << "((";
+    e->show(symbols, str);
+    str << ") ? " << showAttrPath(symbols, attrPath) << ")";
 }
 
-void ExprAttrs::show(std::ostream & str) const
+void ExprAttrs::show(const SymbolTable & symbols, std::ostream & str) const
 {
     if (recursive) str << "rec ";
     str << "{ ";
     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) {
-            return (const std::string &) a->first < (const std::string &) b->first;
-        });
+    std::sort(sorted.begin(), sorted.end(), [&](Attr a, Attr b) {
+        std::string_view sa = symbols[a->first], sb = symbols[b->first];
+        return sa < sb;
+    });
     for (auto & i : sorted) {
         if (i->second.inherited)
-            str << "inherit " << i->first << " " << "; ";
-        else
-            str << i->first << " = " << *i->second.e << "; ";
+            str << "inherit " << symbols[i->first] << " " << "; ";
+        else {
+            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 << "; ";
     }
-    for (auto & i : dynamicAttrs)
-        str << "\"${" << *i.nameExpr << "}\" = " << *i.valueExpr << "; ";
     str << "}";
 }
 
-void ExprList::show(std::ostream & str) const
+void ExprList::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << "[ ";
-    for (auto & i : elems)
-        str << "(" << *i << ") ";
+    for (auto & i : elems) {
+        str << "(";
+        i->show(symbols, str);
+        str << ") ";
+    }
     str << "]";
 }
 
-void ExprLambda::show(std::ostream & str) const
+void ExprLambda::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << "(";
     if (hasFormals()) {
@@ -136,74 +149,100 @@ void ExprLambda::show(std::ostream & str) const
         bool first = true;
         for (auto & i : formals->formals) {
             if (first) first = false; else str << ", ";
-            str << i.name;
-            if (i.def) str << " ? " << *i.def;
+            str << symbols[i.name];
+            if (i.def) {
+                str << " ? ";
+                i.def->show(symbols, str);
+            }
         }
         if (formals->ellipsis) {
             if (!first) str << ", ";
             str << "...";
         }
         str << " }";
-        if (!arg.empty()) str << " @ ";
+        if (arg) str << " @ ";
     }
-    if (!arg.empty()) str << arg;
-    str << ": " << *body << ")";
+    if (arg) str << symbols[arg];
+    str << ": ";
+    body->show(symbols, str);
+    str << ")";
 }
 
-void ExprCall::show(std::ostream & str) const
+void ExprCall::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << '(' << *fun;
+    str << '(';
+    fun->show(symbols, str);
     for (auto e : args) {
         str <<  ' ';
-        str << *e;
+        e->show(symbols, str);
     }
     str << ')';
 }
 
-void ExprLet::show(std::ostream & str) const
+void ExprLet::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << "(let ";
     for (auto & i : attrs->attrs)
         if (i.second.inherited) {
-            str << "inherit " << i.first << "; ";
+            str << "inherit " << symbols[i.first] << "; ";
+        }
+        else {
+            str << symbols[i.first] << " = ";
+            i.second.e->show(symbols, str);
+            str << "; ";
         }
-        else
-            str << i.first << " = " << *i.second.e << "; ";
-    str << "in " << *body << ")";
+    str << "in ";
+    body->show(symbols, str);
+    str << ")";
 }
 
-void ExprWith::show(std::ostream & str) const
+void ExprWith::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << "(with " << *attrs << "; " << *body << ")";
+    str << "(with ";
+    attrs->show(symbols, str);
+    str << "; ";
+    body->show(symbols, str);
+    str << ")";
 }
 
-void ExprIf::show(std::ostream & str) const
+void ExprIf::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << "(if " << *cond << " then " << *then << " else " << *else_ << ")";
+    str << "(if ";
+    cond->show(symbols, str);
+    str << " then ";
+    then->show(symbols, str);
+    str << " else ";
+    else_->show(symbols, str);
+    str << ")";
 }
 
-void ExprAssert::show(std::ostream & str) const
+void ExprAssert::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << "assert " << *cond << "; " << *body;
+    str << "assert ";
+    cond->show(symbols, str);
+    str << "; ";
+    body->show(symbols, str);
 }
 
-void ExprOpNot::show(std::ostream & str) const
+void ExprOpNot::show(const SymbolTable & symbols, std::ostream & str) const
 {
-    str << "(! " << *e << ")";
+    str << "(! ";
+    e->show(symbols, str);
+    str << ")";
 }
 
-void ExprConcatStrings::show(std::ostream & str) const
+void ExprConcatStrings::show(const SymbolTable & symbols, std::ostream & str) const
 {
     bool first = true;
     str << "(";
     for (auto & i : *es) {
         if (first) first = false; else str << " + ";
-        str << *i.second;
+        i.second->show(symbols, str);
     }
     str << ")";
 }
 
-void ExprPos::show(std::ostream & str) const
+void ExprPos::show(const SymbolTable & symbols, std::ostream & str) const
 {
     str << "__curPos";
 }
@@ -234,48 +273,49 @@ std::ostream & operator << (std::ostream & str, const Pos & pos)
 }
 
 
-std::string showAttrPath(const AttrPath & attrPath)
+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.set())
-            out << i.symbol;
-        else
-            out << "\"${" << *i.expr << "}\"";
+        if (i.symbol)
+            out << symbols[i.symbol];
+        else {
+            out << "\"${";
+            i.expr->show(symbols, out);
+            out << "}\"";
+        }
     }
     return out.str();
 }
 
 
-Pos noPos;
-
 
 /* Computing levels/displacements for variables. */
 
-void Expr::bindVars(const StaticEnv & env)
+void Expr::bindVars(const EvalState & es, const StaticEnv & env)
 {
     abort();
 }
 
-void ExprInt::bindVars(const StaticEnv & env)
+void ExprInt::bindVars(const EvalState & es, const StaticEnv & env)
 {
 }
 
-void ExprFloat::bindVars(const StaticEnv & env)
+void ExprFloat::bindVars(const EvalState & es, const StaticEnv & env)
 {
 }
 
-void ExprString::bindVars(const StaticEnv & env)
+void ExprString::bindVars(const EvalState & es, const StaticEnv & env)
 {
 }
 
-void ExprPath::bindVars(const StaticEnv & env)
+void ExprPath::bindVars(const EvalState & es, const StaticEnv & env)
 {
 }
 
-void ExprVar::bindVars(const StaticEnv & env)
+void ExprVar::bindVars(const EvalState & es, const StaticEnv & env)
 {
     /* Check whether the variable appears in the environment.  If so,
        set its level and displacement. */
@@ -301,31 +341,31 @@ void ExprVar::bindVars(const StaticEnv & env)
        "undefined variable" error now. */
     if (withLevel == -1)
         throw UndefinedVarError({
-            .msg = hintfmt("undefined variable '%1%'", name),
-            .errPos = pos
+            .msg = hintfmt("undefined variable '%1%'", es.symbols[name]),
+            .errPos = es.positions[pos]
         });
     fromWith = true;
     this->level = withLevel;
 }
 
-void ExprSelect::bindVars(const StaticEnv & env)
+void ExprSelect::bindVars(const EvalState & es, const StaticEnv & env)
 {
-    e->bindVars(env);
-    if (def) def->bindVars(env);
+    e->bindVars(es, env);
+    if (def) def->bindVars(es, env);
     for (auto & i : attrPath)
-        if (!i.symbol.set())
-            i.expr->bindVars(env);
+        if (!i.symbol)
+            i.expr->bindVars(es, env);
 }
 
-void ExprOpHasAttr::bindVars(const StaticEnv & env)
+void ExprOpHasAttr::bindVars(const EvalState & es, const StaticEnv & env)
 {
-    e->bindVars(env);
+    e->bindVars(es, env);
     for (auto & i : attrPath)
-        if (!i.symbol.set())
-            i.expr->bindVars(env);
+        if (!i.symbol)
+            i.expr->bindVars(es, env);
 }
 
-void ExprAttrs::bindVars(const StaticEnv & env)
+void ExprAttrs::bindVars(const EvalState & es, const StaticEnv & env)
 {
     const StaticEnv * dynamicEnv = &env;
     StaticEnv newEnv(false, &env, recursive ? attrs.size() : 0);
@@ -340,35 +380,35 @@ void ExprAttrs::bindVars(const StaticEnv & env)
         // No need to sort newEnv since attrs is in sorted order.
 
         for (auto & i : attrs)
-            i.second.e->bindVars(i.second.inherited ? env : newEnv);
+            i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
     }
 
     else
         for (auto & i : attrs)
-            i.second.e->bindVars(env);
+            i.second.e->bindVars(es, env);
 
     for (auto & i : dynamicAttrs) {
-        i.nameExpr->bindVars(*dynamicEnv);
-        i.valueExpr->bindVars(*dynamicEnv);
+        i.nameExpr->bindVars(es, *dynamicEnv);
+        i.valueExpr->bindVars(es, *dynamicEnv);
     }
 }
 
-void ExprList::bindVars(const StaticEnv & env)
+void ExprList::bindVars(const EvalState & es, const StaticEnv & env)
 {
     for (auto & i : elems)
-        i->bindVars(env);
+        i->bindVars(es, env);
 }
 
-void ExprLambda::bindVars(const StaticEnv & env)
+void ExprLambda::bindVars(const EvalState & es, const StaticEnv & env)
 {
     StaticEnv newEnv(
         false, &env,
         (hasFormals() ? formals->formals.size() : 0) +
-        (arg.empty() ? 0 : 1));
+        (!arg ? 0 : 1));
 
     Displacement displ = 0;
 
-    if (!arg.empty()) newEnv.vars.emplace_back(arg, displ++);
+    if (arg) newEnv.vars.emplace_back(arg, displ++);
 
     if (hasFormals()) {
         for (auto & i : formals->formals)
@@ -377,20 +417,20 @@ void ExprLambda::bindVars(const StaticEnv & env)
         newEnv.sort();
 
         for (auto & i : formals->formals)
-            if (i.def) i.def->bindVars(newEnv);
+            if (i.def) i.def->bindVars(es, newEnv);
     }
 
-    body->bindVars(newEnv);
+    body->bindVars(es, newEnv);
 }
 
-void ExprCall::bindVars(const StaticEnv & env)
+void ExprCall::bindVars(const EvalState & es, const StaticEnv & env)
 {
-    fun->bindVars(env);
+    fun->bindVars(es, env);
     for (auto e : args)
-        e->bindVars(env);
+        e->bindVars(es, env);
 }
 
-void ExprLet::bindVars(const StaticEnv & env)
+void ExprLet::bindVars(const EvalState & es, const StaticEnv & env)
 {
     StaticEnv newEnv(false, &env, attrs->attrs.size());
 
@@ -401,12 +441,12 @@ void ExprLet::bindVars(const StaticEnv & env)
     // No need to sort newEnv since attrs->attrs is in sorted order.
 
     for (auto & i : attrs->attrs)
-        i.second.e->bindVars(i.second.inherited ? env : newEnv);
+        i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
 
-    body->bindVars(newEnv);
+    body->bindVars(es, newEnv);
 }
 
-void ExprWith::bindVars(const StaticEnv & env)
+void ExprWith::bindVars(const EvalState & es, const StaticEnv & env)
 {
     /* Does this `with' have an enclosing `with'?  If so, record its
        level so that `lookupVar' can look up variables in the previous
@@ -420,57 +460,60 @@ void ExprWith::bindVars(const StaticEnv & env)
             break;
         }
 
-    attrs->bindVars(env);
+    attrs->bindVars(es, env);
     StaticEnv newEnv(true, &env);
-    body->bindVars(newEnv);
+    body->bindVars(es, newEnv);
 }
 
-void ExprIf::bindVars(const StaticEnv & env)
+void ExprIf::bindVars(const EvalState & es, const StaticEnv & env)
 {
-    cond->bindVars(env);
-    then->bindVars(env);
-    else_->bindVars(env);
+    cond->bindVars(es, env);
+    then->bindVars(es, env);
+    else_->bindVars(es, env);
 }
 
-void ExprAssert::bindVars(const StaticEnv & env)
+void ExprAssert::bindVars(const EvalState & es, const StaticEnv & env)
 {
-    cond->bindVars(env);
-    body->bindVars(env);
+    cond->bindVars(es, env);
+    body->bindVars(es, env);
 }
 
-void ExprOpNot::bindVars(const StaticEnv & env)
+void ExprOpNot::bindVars(const EvalState & es, const StaticEnv & env)
 {
-    e->bindVars(env);
+    e->bindVars(es, env);
 }
 
-void ExprConcatStrings::bindVars(const StaticEnv & env)
+void ExprConcatStrings::bindVars(const EvalState & es, const StaticEnv & env)
 {
-    for (auto & i : *es)
-        i.second->bindVars(env);
+    for (auto & i : *this->es)
+        i.second->bindVars(es, env);
 }
 
-void ExprPos::bindVars(const StaticEnv & env)
+void ExprPos::bindVars(const EvalState & es, const StaticEnv & env)
 {
 }
 
 
 /* Storing function names. */
 
-void Expr::setName(Symbol & name)
+void Expr::setName(Symbol name)
 {
 }
 
 
-void ExprLambda::setName(Symbol & name)
+void ExprLambda::setName(Symbol name)
 {
     this->name = name;
     body->setName(name);
 }
 
 
-std::string ExprLambda::showNamePos() const
+std::string ExprLambda::showNamePos(const EvalState & state) const
 {
-    return fmt("%1% at %2%", name.set() ? "'" + (std::string) name + "'" : "anonymous function", pos);
+    std::string id(name
+        ? concatStrings("'", state.symbols[name], "'")
+        : "anonymous function");
+    return fmt("%1% at %2%", id, state.positions[pos]);
 }
 
 
@@ -480,8 +523,7 @@ std::string ExprLambda::showNamePos() const
 size_t SymbolTable::totalSize() const
 {
     size_t n = 0;
-    for (auto & i : store)
-        n += i.size();
+    dump([&] (const std::string & s) { n += s.size(); });
     return n;
 }
 
diff --git a/src/libexpr/nixexpr.hh b/src/libexpr/nixexpr.hh
index 4dbe31510..5df69e000 100644
--- a/src/libexpr/nixexpr.hh
+++ b/src/libexpr/nixexpr.hh
@@ -1,8 +1,12 @@
 #pragma once
 
+#include <map>
+#include <vector>
+
 #include "value.hh"
 #include "symbol-table.hh"
 #include "error.hh"
+#include "chunked-vector.hh"
 
 
 namespace nix {
@@ -23,32 +27,92 @@ MakeError(RestrictedPathError, Error);
 
 struct Pos
 {
-    Symbol file;
+    std::string file;
+    FileOrigin origin;
     uint32_t line;
-    FileOrigin origin:2;
-    uint32_t column:30;
-    Pos() : line(0), origin(foString), column(0) { };
-    Pos(FileOrigin origin, const Symbol & file, uint32_t line, uint32_t column)
-        : file(file), line(line), origin(origin), column(column) { };
-    operator bool() const
+    uint32_t column;
+
+    explicit operator bool() const { return line > 0; }
+};
+
+class PosIdx {
+    friend class PosTable;
+
+private:
+    uint32_t id;
+
+    explicit PosIdx(uint32_t id): id(id) {}
+
+public:
+    PosIdx() : id(0) {}
+
+    explicit operator bool() const { return id > 0; }
+
+    bool operator<(const PosIdx other) const { return id < other.id; }
+};
+
+class PosTable
+{
+public:
+    class Origin {
+        friend PosTable;
+    private:
+        // must always be invalid by default, add() replaces this with the actual value.
+        // subsequent add() calls use this index as a token to quickly check whether the
+        // current origins.back() can be reused or not.
+        mutable uint32_t idx = std::numeric_limits<uint32_t>::max();
+
+        explicit Origin(uint32_t idx): idx(idx), file{}, origin{} {}
+
+    public:
+        const std::string file;
+        const FileOrigin origin;
+
+        Origin(std::string file, FileOrigin origin): file(std::move(file)), origin(origin) {}
+    };
+
+    struct Offset {
+        uint32_t line, column;
+    };
+
+private:
+    std::vector<Origin> origins;
+    ChunkedVector<Offset, 8192> offsets;
+
+public:
+    PosTable(): offsets(1024)
+    {
+        origins.reserve(1024);
+    }
+
+    PosIdx add(const Origin & origin, uint32_t line, uint32_t column)
     {
-        return line != 0;
+        const auto idx = offsets.add({line, column}).second;
+        if (origins.empty() || origins.back().idx != origin.idx) {
+            origin.idx = idx;
+            origins.push_back(origin);
+        }
+        return PosIdx(idx + 1);
     }
 
-    bool operator < (const Pos & p2) const
+    Pos operator[](PosIdx p) const
     {
-        if (!line) return p2.line;
-        if (!p2.line) return false;
-        int d = ((const std::string &) file).compare((const std::string &) p2.file);
-        if (d < 0) return true;
-        if (d > 0) return false;
-        if (line < p2.line) return true;
-        if (line > p2.line) return false;
-        return column < p2.column;
+        if (p.id == 0 || p.id > offsets.size())
+            return {};
+        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 = std::upper_bound(
+            origins.begin(), origins.end(), Origin(idx),
+            [] (const auto & a, const auto & b) { return a.idx < b.idx; });
+        const auto origin = *std::prev(pastOrigin);
+        const auto offset = offsets[idx];
+        return {origin.file, origin.origin, offset.line, offset.column};
     }
 };
 
-extern Pos noPos;
+inline PosIdx noPos = {};
 
 std::ostream & operator << (std::ostream & str, const Pos & pos);
 
@@ -64,13 +128,13 @@ struct AttrName
 {
     Symbol symbol;
     Expr * expr;
-    AttrName(const Symbol & s) : symbol(s) {};
+    AttrName(Symbol s) : symbol(s) {};
     AttrName(Expr * e) : expr(e) {};
 };
 
 typedef std::vector<AttrName> AttrPath;
 
-std::string showAttrPath(const AttrPath & attrPath);
+std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath);
 
 
 /* Abstract syntax of Nix expressions. */
@@ -78,19 +142,17 @@ std::string showAttrPath(const AttrPath & attrPath);
 struct Expr
 {
     virtual ~Expr() { };
-    virtual void show(std::ostream & str) const;
-    virtual void bindVars(const StaticEnv & env);
+    virtual void show(const SymbolTable & symbols, std::ostream & str) const;
+    virtual void bindVars(const EvalState & es, 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 setName(Symbol name);
 };
 
-std::ostream & operator << (std::ostream & str, const Expr & e);
-
 #define COMMON_METHODS \
-    void show(std::ostream & str) const; \
+    void show(const SymbolTable & symbols, std::ostream & str) const;    \
     void eval(EvalState & state, Env & env, Value & v); \
-    void bindVars(const StaticEnv & env);
+    void bindVars(const EvalState & es, const StaticEnv & env);
 
 struct ExprInt : Expr
 {
@@ -133,7 +195,7 @@ typedef uint32_t Displacement;
 
 struct ExprVar : Expr
 {
-    Pos pos;
+    PosIdx pos;
     Symbol name;
 
     /* Whether the variable comes from an environment (e.g. a rec, let
@@ -149,19 +211,19 @@ struct ExprVar : Expr
     Level level;
     Displacement displ;
 
-    ExprVar(const Symbol & name) : name(name) { };
-    ExprVar(const Pos & pos, const Symbol & name) : pos(pos), name(name) { };
+    ExprVar(Symbol name) : name(name) { };
+    ExprVar(const PosIdx & pos, Symbol name) : pos(pos), name(name) { };
     COMMON_METHODS
     Value * maybeThunk(EvalState & state, Env & env);
 };
 
 struct ExprSelect : Expr
 {
-    Pos pos;
+    PosIdx pos;
     Expr * e, * def;
     AttrPath attrPath;
-    ExprSelect(const Pos & pos, Expr * e, const AttrPath & attrPath, Expr * def) : pos(pos), e(e), def(def), attrPath(attrPath) { };
-    ExprSelect(const Pos & pos, Expr * e, const Symbol & name) : pos(pos), e(e), def(0) { attrPath.push_back(AttrName(name)); };
+    ExprSelect(const PosIdx & pos, Expr * e, const AttrPath & attrPath, Expr * def) : pos(pos), e(e), def(def), attrPath(attrPath) { };
+    ExprSelect(const PosIdx & pos, Expr * e, Symbol name) : pos(pos), e(e), def(0) { attrPath.push_back(AttrName(name)); };
     COMMON_METHODS
 };
 
@@ -176,13 +238,13 @@ struct ExprOpHasAttr : Expr
 struct ExprAttrs : Expr
 {
     bool recursive;
-    Pos pos;
+    PosIdx pos;
     struct AttrDef {
         bool inherited;
         Expr * e;
-        Pos pos;
+        PosIdx pos;
         Displacement displ; // displacement
-        AttrDef(Expr * e, const Pos & pos, bool inherited=false)
+        AttrDef(Expr * e, const PosIdx & pos, bool inherited=false)
             : inherited(inherited), e(e), pos(pos) { };
         AttrDef() { };
     };
@@ -190,14 +252,14 @@ struct ExprAttrs : Expr
     AttrDefs attrs;
     struct DynamicAttrDef {
         Expr * nameExpr, * valueExpr;
-        Pos pos;
-        DynamicAttrDef(Expr * nameExpr, Expr * valueExpr, const Pos & pos)
+        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 Pos &pos) : recursive(false), pos(pos) { };
-    ExprAttrs() : recursive(false), pos(noPos) { };
+    ExprAttrs(const PosIdx &pos) : recursive(false), pos(pos) { };
+    ExprAttrs() : recursive(false) { };
     COMMON_METHODS
 };
 
@@ -210,10 +272,9 @@ struct ExprList : Expr
 
 struct Formal
 {
-    Pos pos;
+    PosIdx pos;
     Symbol name;
     Expr * def;
-    Formal(const Pos & pos, const Symbol & name, Expr * def) : pos(pos), name(name), def(def) { };
 };
 
 struct Formals
@@ -222,18 +283,20 @@ struct Formals
     Formals_ formals;
     bool ellipsis;
 
-    bool has(Symbol arg) const {
+    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
+    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) {
-                return std::string_view(a.name) < std::string_view(b.name);
+            [&] (const Formal & a, const Formal & b) {
+                std::string_view sa = symbols[a.name], sb = symbols[b.name];
+                return sa < sb;
             });
         return result;
     }
@@ -241,17 +304,21 @@ struct Formals
 
 struct ExprLambda : Expr
 {
-    Pos pos;
+    PosIdx pos;
     Symbol name;
     Symbol arg;
     Formals * formals;
     Expr * body;
-    ExprLambda(const Pos & pos, const Symbol & arg, Formals * formals, Expr * body)
+    ExprLambda(PosIdx pos, Symbol arg, Formals * formals, Expr * body)
         : pos(pos), arg(arg), formals(formals), body(body)
     {
     };
-    void setName(Symbol & name);
-    std::string showNamePos() const;
+    ExprLambda(PosIdx pos, Formals * formals, Expr * body)
+        : pos(pos), formals(formals), body(body)
+    {
+    }
+    void setName(Symbol name);
+    std::string showNamePos(const EvalState & state) const;
     inline bool hasFormals() const { return formals != nullptr; }
     COMMON_METHODS
 };
@@ -260,8 +327,8 @@ struct ExprCall : Expr
 {
     Expr * fun;
     std::vector<Expr *> args;
-    Pos pos;
-    ExprCall(const Pos & pos, Expr * fun, std::vector<Expr *> && args)
+    PosIdx pos;
+    ExprCall(const PosIdx & pos, Expr * fun, std::vector<Expr *> && args)
         : fun(fun), args(args), pos(pos)
     { }
     COMMON_METHODS
@@ -277,26 +344,26 @@ struct ExprLet : Expr
 
 struct ExprWith : Expr
 {
-    Pos pos;
+    PosIdx pos;
     Expr * attrs, * body;
     size_t prevWith;
-    ExprWith(const Pos & pos, Expr * attrs, Expr * body) : pos(pos), attrs(attrs), body(body) { };
+    ExprWith(const PosIdx & pos, Expr * attrs, Expr * body) : pos(pos), attrs(attrs), body(body) { };
     COMMON_METHODS
 };
 
 struct ExprIf : Expr
 {
-    Pos pos;
+    PosIdx pos;
     Expr * cond, * then, * else_;
-    ExprIf(const Pos & pos, Expr * cond, Expr * then, Expr * else_) : pos(pos), cond(cond), then(then), else_(else_) { };
+    ExprIf(const PosIdx & pos, Expr * cond, Expr * then, Expr * else_) : pos(pos), cond(cond), then(then), else_(else_) { };
     COMMON_METHODS
 };
 
 struct ExprAssert : Expr
 {
-    Pos pos;
+    PosIdx pos;
     Expr * cond, * body;
-    ExprAssert(const Pos & pos, Expr * cond, Expr * body) : pos(pos), cond(cond), body(body) { };
+    ExprAssert(const PosIdx & pos, Expr * cond, Expr * body) : pos(pos), cond(cond), body(body) { };
     COMMON_METHODS
 };
 
@@ -310,17 +377,17 @@ struct ExprOpNot : Expr
 #define MakeBinOp(name, s) \
     struct name : Expr \
     { \
-        Pos pos; \
+        PosIdx pos; \
         Expr * e1, * e2; \
         name(Expr * e1, Expr * e2) : e1(e1), e2(e2) { }; \
-        name(const Pos & pos, Expr * e1, Expr * e2) : pos(pos), e1(e1), e2(e2) { }; \
-        void show(std::ostream & str) const \
+        name(const PosIdx & pos, Expr * e1, Expr * e2) : pos(pos), e1(e1), e2(e2) { }; \
+        void show(const SymbolTable & symbols, std::ostream & str) const \
         { \
-            str << "(" << *e1 << " " s " " << *e2 << ")";   \
+            str << "("; e1->show(symbols, str); str << " " s " "; e2->show(symbols, str); str << ")"; \
         } \
-        void bindVars(const StaticEnv & env) \
+        void bindVars(const EvalState & es, const StaticEnv & env)    \
         { \
-            e1->bindVars(env); e2->bindVars(env); \
+            e1->bindVars(es, env); e2->bindVars(es, env);    \
         } \
         void eval(EvalState & state, Env & env, Value & v); \
     };
@@ -335,18 +402,18 @@ MakeBinOp(ExprOpConcatLists, "++")
 
 struct ExprConcatStrings : Expr
 {
-    Pos pos;
+    PosIdx pos;
     bool forceString;
-    std::vector<std::pair<Pos, Expr *> > * es;
-    ExprConcatStrings(const Pos & pos, bool forceString, std::vector<std::pair<Pos, Expr *> > * es)
+    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) { };
     COMMON_METHODS
 };
 
 struct ExprPos : Expr
 {
-    Pos pos;
-    ExprPos(const Pos & pos) : pos(pos) { };
+    PosIdx pos;
+    ExprPos(const PosIdx & pos) : pos(pos) { };
     COMMON_METHODS
 };
 
@@ -384,7 +451,7 @@ struct StaticEnv
         vars.erase(it, end);
     }
 
-    Vars::const_iterator find(const Symbol & name) const
+    Vars::const_iterator find(Symbol name) const
     {
         Vars::value_type key(name, 0);
         auto i = std::lower_bound(vars.begin(), vars.end(), key);
diff --git a/src/libexpr/parser.y b/src/libexpr/parser.y
index 919b9cfae..be0598b75 100644
--- a/src/libexpr/parser.y
+++ b/src/libexpr/parser.y
@@ -32,12 +32,12 @@ namespace nix {
         SymbolTable & symbols;
         Expr * result;
         Path basePath;
-        Symbol file;
-        FileOrigin origin;
+        PosTable::Origin origin;
         std::optional<ErrorInfo> error;
-        ParseData(EvalState & state)
+        ParseData(EvalState & state, PosTable::Origin origin)
             : state(state)
             , symbols(state.symbols)
+            , origin(std::move(origin))
             { };
     };
 
@@ -77,26 +77,26 @@ using namespace nix;
 namespace nix {
 
 
-static void dupAttr(const AttrPath & attrPath, const Pos & pos, const Pos & prevPos)
+static void dupAttr(const EvalState & state, const AttrPath & attrPath, const PosIdx pos, const PosIdx prevPos)
 {
     throw ParseError({
          .msg = hintfmt("attribute '%1%' already defined at %2%",
-             showAttrPath(attrPath), prevPos),
-         .errPos = pos
+             showAttrPath(state.symbols, attrPath), state.positions[prevPos]),
+         .errPos = state.positions[pos]
     });
 }
 
-static void dupAttr(Symbol attr, const Pos & pos, const Pos & prevPos)
+static void dupAttr(const EvalState & state, Symbol attr, const PosIdx pos, const PosIdx prevPos)
 {
     throw ParseError({
-        .msg = hintfmt("attribute '%1%' already defined at %2%", attr, prevPos),
-        .errPos = pos
+        .msg = hintfmt("attribute '%1%' already defined at %2%", state.symbols[attr], state.positions[prevPos]),
+        .errPos = state.positions[pos]
     });
 }
 
 
 static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
-    Expr * e, const Pos & pos)
+    Expr * e, const PosIdx pos, const nix::EvalState & state)
 {
     AttrPath::iterator i;
     // All attrpaths have at least one attr
@@ -104,15 +104,15 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
     // Checking attrPath validity.
     // ===========================
     for (i = attrPath.begin(); i + 1 < attrPath.end(); i++) {
-        if (i->symbol.set()) {
+        if (i->symbol) {
             ExprAttrs::AttrDefs::iterator j = attrs->attrs.find(i->symbol);
             if (j != attrs->attrs.end()) {
                 if (!j->second.inherited) {
                     ExprAttrs * attrs2 = dynamic_cast<ExprAttrs *>(j->second.e);
-                    if (!attrs2) dupAttr(attrPath, pos, j->second.pos);
+                    if (!attrs2) dupAttr(state, attrPath, pos, j->second.pos);
                     attrs = attrs2;
                 } else
-                    dupAttr(attrPath, pos, j->second.pos);
+                    dupAttr(state, attrPath, pos, j->second.pos);
             } else {
                 ExprAttrs * nested = new ExprAttrs;
                 attrs->attrs[i->symbol] = ExprAttrs::AttrDef(nested, pos);
@@ -126,7 +126,7 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
     }
     // Expr insertion.
     // ==========================
-    if (i->symbol.set()) {
+    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
@@ -139,11 +139,11 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
                 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);
+                        dupAttr(state, ad.first, j2->second.pos, ad.second.pos);
                     jAttrs->attrs.emplace(ad.first, ad.second);
                 }
             } else {
-                dupAttr(attrPath, pos, j->second.pos);
+                dupAttr(state, attrPath, pos, j->second.pos);
             }
         } else {
             // This attr path is not defined. Let's create it.
@@ -157,14 +157,14 @@ static void addAttr(ExprAttrs * attrs, AttrPath & attrPath,
 
 
 static Formals * toFormals(ParseData & data, ParserFormals * formals,
-    Pos pos = noPos, Symbol arg = {})
+    PosIdx pos = noPos, 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, Pos>> duplicate;
+    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;
@@ -173,18 +173,18 @@ static Formals * toFormals(ParseData & data, ParserFormals * formals,
     }
     if (duplicate)
         throw ParseError({
-            .msg = hintfmt("duplicate formal function argument '%1%'", duplicate->first),
-            .errPos = duplicate->second
+            .msg = hintfmt("duplicate formal function argument '%1%'", data.symbols[duplicate->first]),
+            .errPos = data.state.positions[duplicate->second]
         });
 
     Formals result;
     result.ellipsis = formals->ellipsis;
     result.formals = std::move(formals->formals);
 
-    if (arg.set() && result.has(arg))
+    if (arg && result.has(arg))
         throw ParseError({
-            .msg = hintfmt("duplicate formal function argument '%1%'", arg),
-            .errPos = pos
+            .msg = hintfmt("duplicate formal function argument '%1%'", data.symbols[arg]),
+            .errPos = data.state.positions[pos]
         });
 
     delete formals;
@@ -192,8 +192,8 @@ static Formals * toFormals(ParseData & data, ParserFormals * formals,
 }
 
 
-static Expr * stripIndentation(const Pos & pos, SymbolTable & symbols,
-    std::vector<std::pair<Pos, std::variant<Expr *, StringToken> > > & es)
+static Expr * stripIndentation(const PosIdx pos, SymbolTable & symbols,
+    std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken> > > & es)
 {
     if (es.empty()) return new ExprString("");
 
@@ -233,7 +233,7 @@ static Expr * stripIndentation(const Pos & pos, SymbolTable & symbols,
     }
 
     /* Strip spaces from each line. */
-    std::vector<std::pair<Pos, Expr *> > * es2 = new std::vector<std::pair<Pos, Expr *> >;
+    auto * es2 = new std::vector<std::pair<PosIdx, Expr *> >;
     atStartOfLine = true;
     size_t curDropped = 0;
     size_t n = es.size();
@@ -284,9 +284,9 @@ static Expr * stripIndentation(const Pos & pos, SymbolTable & symbols,
 }
 
 
-static inline Pos makeCurPos(const YYLTYPE & loc, ParseData * data)
+static inline PosIdx makeCurPos(const YYLTYPE & loc, ParseData * data)
 {
-    return Pos(data->origin, data->file, loc.first_line, loc.first_column);
+    return data->state.positions.add(data->origin, loc.first_line, loc.first_column);
 }
 
 #define CUR_POS makeCurPos(*yylocp, data)
@@ -299,7 +299,7 @@ void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, const char * err
 {
     data->error = {
         .msg = hintfmt(error),
-        .errPos = makeCurPos(*loc, data)
+        .errPos = data->state.positions[makeCurPos(*loc, data)]
     };
 }
 
@@ -320,8 +320,8 @@ void yyerror(YYLTYPE * loc, yyscan_t scanner, ParseData * data, const char * err
   StringToken uri;
   StringToken str;
   std::vector<nix::AttrName> * attrNames;
-  std::vector<std::pair<nix::Pos, nix::Expr *> > * string_parts;
-  std::vector<std::pair<nix::Pos, std::variant<nix::Expr *, StringToken> > > * ind_string_parts;
+  std::vector<std::pair<nix::PosIdx, nix::Expr *> > * string_parts;
+  std::vector<std::pair<nix::PosIdx, std::variant<nix::Expr *, StringToken> > > * ind_string_parts;
 }
 
 %type <e> start expr expr_function expr_if expr_op
@@ -369,15 +369,15 @@ expr_function
   : ID ':' expr_function
     { $$ = new ExprLambda(CUR_POS, data->symbols.create($1), 0, $3); }
   | '{' formals '}' ':' expr_function
-    { $$ = new ExprLambda(CUR_POS, data->symbols.create(""), toFormals(*data, $2), $5); }
+    { $$ = new ExprLambda(CUR_POS, toFormals(*data, $2), $5); }
   | '{' formals '}' '@' ID ':' expr_function
     {
-      Symbol arg = data->symbols.create($5);
+      auto arg = data->symbols.create($5);
       $$ = new ExprLambda(CUR_POS, arg, toFormals(*data, $2, CUR_POS, arg), $7);
     }
   | ID '@' '{' formals '}' ':' expr_function
     {
-      Symbol arg = data->symbols.create($1);
+      auto arg = data->symbols.create($1);
       $$ = new ExprLambda(CUR_POS, arg, toFormals(*data, $4, CUR_POS, arg), $7);
     }
   | ASSERT expr ';' expr_function
@@ -388,7 +388,7 @@ expr_function
     { if (!$2->dynamicAttrs.empty())
         throw ParseError({
             .msg = hintfmt("dynamic attributes not allowed in let"),
-            .errPos = CUR_POS
+            .errPos = data->state.positions[CUR_POS]
         });
       $$ = new ExprLet($2, $4);
     }
@@ -415,7 +415,7 @@ expr_op
   | expr_op UPDATE expr_op { $$ = new ExprOpUpdate(CUR_POS, $1, $3); }
   | expr_op '?' attrpath { $$ = new ExprOpHasAttr($1, *$3); }
   | expr_op '+' expr_op
-    { $$ = new ExprConcatStrings(CUR_POS, false, new std::vector<std::pair<Pos, Expr *> >({{makeCurPos(@1, data), $1}, {makeCurPos(@3, data), $3}})); }
+    { $$ = new ExprConcatStrings(CUR_POS, false, new std::vector<std::pair<PosIdx, Expr *> >({{makeCurPos(@1, data), $1}, {makeCurPos(@3, data), $3}})); }
   | expr_op '-' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__sub")), {$1, $3}); }
   | expr_op '*' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__mul")), {$1, $3}); }
   | expr_op '/' expr_op { $$ = new ExprCall(CUR_POS, new ExprVar(data->symbols.create("__div")), {$1, $3}); }
@@ -477,7 +477,7 @@ expr_simple
       if (noURLLiterals)
           throw ParseError({
               .msg = hintfmt("URL literals are disabled"),
-              .errPos = CUR_POS
+              .errPos = data->state.positions[CUR_POS]
           });
       $$ = new ExprString(std::string($1));
   }
@@ -503,9 +503,9 @@ string_parts_interpolated
   : string_parts_interpolated STR
   { $$ = $1; $1->emplace_back(makeCurPos(@2, data), new ExprString(std::string($2))); }
   | string_parts_interpolated DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $3); }
-  | DOLLAR_CURLY expr '}' { $$ = new std::vector<std::pair<Pos, Expr *> >; $$->emplace_back(makeCurPos(@1, data), $2); }
+  | DOLLAR_CURLY expr '}' { $$ = new std::vector<std::pair<PosIdx, Expr *> >; $$->emplace_back(makeCurPos(@1, data), $2); }
   | STR DOLLAR_CURLY expr '}' {
-      $$ = new std::vector<std::pair<Pos, Expr *> >;
+      $$ = new std::vector<std::pair<PosIdx, Expr *> >;
       $$->emplace_back(makeCurPos(@1, data), new ExprString(std::string($1)));
       $$->emplace_back(makeCurPos(@2, data), $3);
     }
@@ -528,17 +528,17 @@ path_start
 ind_string_parts
   : ind_string_parts IND_STR { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $2); }
   | ind_string_parts DOLLAR_CURLY expr '}' { $$ = $1; $1->emplace_back(makeCurPos(@2, data), $3); }
-  | { $$ = new std::vector<std::pair<Pos, std::variant<Expr *, StringToken> > >; }
+  | { $$ = new std::vector<std::pair<PosIdx, std::variant<Expr *, StringToken> > >; }
   ;
 
 binds
-  : binds attrpath '=' expr ';' { $$ = $1; addAttr($$, *$2, $4, makeCurPos(@2, data)); }
+  : binds attrpath '=' expr ';' { $$ = $1; addAttr($$, *$2, $4, makeCurPos(@2, data), data->state); }
   | binds INHERIT attrs ';'
     { $$ = $1;
       for (auto & i : *$3) {
           if ($$->attrs.find(i.symbol) != $$->attrs.end())
-              dupAttr(i.symbol, makeCurPos(@3, data), $$->attrs[i.symbol].pos);
-          Pos pos = makeCurPos(@3, data);
+              dupAttr(data->state, i.symbol, makeCurPos(@3, data), $$->attrs[i.symbol].pos);
+          auto pos = makeCurPos(@3, data);
           $$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprVar(CUR_POS, i.symbol), pos, true));
       }
     }
@@ -547,7 +547,7 @@ binds
       /* !!! Should ensure sharing of the expression in $4. */
       for (auto & i : *$6) {
           if ($$->attrs.find(i.symbol) != $$->attrs.end())
-              dupAttr(i.symbol, makeCurPos(@6, data), $$->attrs[i.symbol].pos);
+              dupAttr(data->state, i.symbol, makeCurPos(@6, data), $$->attrs[i.symbol].pos);
           $$->attrs.emplace(i.symbol, ExprAttrs::AttrDef(new ExprSelect(CUR_POS, $4, i.symbol), makeCurPos(@6, data)));
       }
     }
@@ -565,7 +565,7 @@ attrs
       } else
           throw ParseError({
               .msg = hintfmt("dynamic attributes not allowed in inherit"),
-              .errPos = makeCurPos(@2, data)
+              .errPos = data->state.positions[makeCurPos(@2, data)]
           });
     }
   | { $$ = new AttrPath; }
@@ -621,8 +621,8 @@ formals
   ;
 
 formal
-  : ID { $$ = new Formal(CUR_POS, data->symbols.create($1), 0); }
-  | ID '?' expr { $$ = new Formal(CUR_POS, data->symbols.create($1), $3); }
+  : ID { $$ = new Formal{CUR_POS, data->symbols.create($1), 0}; }
+  | ID '?' expr { $$ = new Formal{CUR_POS, data->symbols.create($1), $3}; }
   ;
 
 %%
@@ -646,19 +646,19 @@ Expr * EvalState::parse(char * text, size_t length, FileOrigin origin,
     const PathView path, const PathView basePath, StaticEnv & staticEnv)
 {
     yyscan_t scanner;
-    ParseData data(*this);
-    data.origin = origin;
+    std::string file;
     switch (origin) {
         case foFile:
-            data.file = data.symbols.create(path);
+            file = path;
             break;
         case foStdin:
         case foString:
-            data.file = data.symbols.create(text);
+            file = text;
             break;
         default:
             assert(false);
     }
+    ParseData data(*this, {file, origin});
     data.basePath = basePath;
 
     yylex_init(&scanner);
@@ -668,7 +668,7 @@ Expr * EvalState::parse(char * text, size_t length, FileOrigin origin,
 
     if (res) throw ParseError(data.error.value());
 
-    data.result->bindVars(staticEnv);
+    data.result->bindVars(*this, staticEnv);
 
     return data.result;
 }
@@ -760,7 +760,7 @@ Path EvalState::findFile(const std::string_view path)
 }
 
 
-Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, const Pos & pos)
+Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, const PosIdx pos)
 {
     for (auto & i : searchPath) {
         std::string suffix;
@@ -787,7 +787,7 @@ Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, c
             ? "cannot look up '<%s>' in pure evaluation mode (use '--impure' to override)"
             : "file '%s' was not found in the Nix search path (add it using $NIX_PATH or -I)",
             path),
-        .errPos = pos
+        .errPos = positions[pos]
     });
 }
 
diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc
index 73817dbdd..28fea276e 100644
--- a/src/libexpr/primops.cc
+++ b/src/libexpr/primops.cc
@@ -68,14 +68,15 @@ StringMap EvalState::realiseContext(const PathSet & context)
 
     /* Get all the output paths corresponding to the placeholders we had */
     for (auto & [drvPath, outputs] : drvs) {
-        auto outputPaths = store->queryDerivationOutputMap(drvPath);
+        const auto outputPaths = store->queryDerivationOutputMap(drvPath);
         for (auto & outputName : outputs) {
-            if (outputPaths.count(outputName) == 0)
+            auto outputPath = get(outputPaths, outputName);
+            if (!outputPath)
                 throw Error("derivation '%s' does not have an output named '%s'",
                         store->printStorePath(drvPath), outputName);
             res.insert_or_assign(
                 downstreamPlaceholder(*store, drvPath, outputName),
-                store->printStorePath(outputPaths.at(outputName))
+                store->printStorePath(*outputPath)
             );
         }
     }
@@ -96,7 +97,7 @@ struct RealisePathFlags {
     bool checkForPureEval = true;
 };
 
-static Path realisePath(EvalState & state, const Pos & pos, Value & v, const RealisePathFlags flags = {})
+static Path realisePath(EvalState & state, const PosIdx pos, Value & v, const RealisePathFlags flags = {})
 {
     PathSet context;
 
@@ -105,7 +106,7 @@ static Path realisePath(EvalState & state, const Pos & pos, Value & v, const Rea
         try {
             return state.coerceToPath(pos, v, context);
         } catch (Error & e) {
-            e.addTrace(pos, "while realising the context of a path");
+            e.addTrace(state.positions[pos], "while realising the context of a path");
             throw;
         }
     }();
@@ -119,7 +120,7 @@ static Path realisePath(EvalState & state, const Pos & pos, Value & v, const Rea
             ? state.checkSourcePath(realPath)
             : realPath;
     } catch (Error & e) {
-        e.addTrace(pos, "while realising the context of path '%s'", path);
+        e.addTrace(state.positions[pos], "while realising the context of path '%s'", path);
         throw;
     }
 }
@@ -157,7 +158,7 @@ static void mkOutputString(
 
 /* Load and evaluate an expression from path specified by the
    argument. */
-static void import(EvalState & state, const Pos & pos, Value & vPath, Value * vScope, Value & v)
+static void import(EvalState & state, const PosIdx pos, Value & vPath, Value * vScope, Value & v)
 {
     auto path = realisePath(state, pos, vPath);
 
@@ -237,7 +238,7 @@ static void import(EvalState & state, const Pos & pos, Value & vPath, Value * vS
 static RegisterPrimOp primop_scopedImport(RegisterPrimOp::Info {
     .name = "scopedImport",
     .arity = 2,
-    .fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
+    .fun = [](EvalState & state, const PosIdx pos, Value * * args, Value & v)
     {
         import(state, pos, *args[1], args[0], v);
     }
@@ -299,7 +300,7 @@ static RegisterPrimOp primop_import({
       (The function argument doesn’t have to be called `x` in `foo.nix`;
       any name would work.)
     )",
-    .fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
+    .fun = [](EvalState & state, const PosIdx pos, Value * * args, Value & v)
     {
         import(state, pos, *args[0], nullptr, v);
     }
@@ -310,7 +311,7 @@ static RegisterPrimOp primop_import({
 extern "C" typedef void (*ValueInitializer)(EvalState & state, Value & v);
 
 /* Load a ValueInitializer from a DSO and return whatever it initializes */
-void prim_importNative(EvalState & state, const Pos & pos, Value * * args, Value & v)
+void prim_importNative(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto path = realisePath(state, pos, *args[0]);
 
@@ -338,7 +339,7 @@ void prim_importNative(EvalState & state, const Pos & pos, Value * * args, Value
 
 
 /* Execute a program and parse its output */
-void prim_exec(EvalState & state, const Pos & pos, Value * * args, Value & v)
+void prim_exec(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[0], pos);
     auto elems = args[0]->listElems();
@@ -346,7 +347,7 @@ void prim_exec(EvalState & state, const Pos & pos, Value * * args, Value & v)
     if (count == 0) {
         throw EvalError({
             .msg = hintfmt("at least one argument to 'exec' required"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
     }
     PathSet context;
@@ -361,29 +362,30 @@ void prim_exec(EvalState & state, const Pos & pos, Value * * args, Value & v)
         throw EvalError({
             .msg = hintfmt("cannot execute '%1%', since path '%2%' is not valid",
                 program, e.path),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
     }
 
     auto output = runProgram(program, true, commandArgs);
     Expr * parsed;
     try {
-        parsed = state.parseExprFromString(std::move(output), pos.file);
+        auto base = state.positions[pos];
+        parsed = state.parseExprFromString(std::move(output), base.file);
     } catch (Error & e) {
-        e.addTrace(pos, "While parsing the output from '%1%'", program);
+        e.addTrace(state.positions[pos], "While parsing the output from '%1%'", program);
         throw;
     }
     try {
         state.eval(parsed, v);
     } catch (Error & e) {
-        e.addTrace(pos, "While evaluating the output from '%1%'", program);
+        e.addTrace(state.positions[pos], "While evaluating the output from '%1%'", program);
         throw;
     }
 }
 
 
 /* Return a string representing the type of the expression. */
-static void prim_typeOf(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_typeOf(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     std::string t;
@@ -402,7 +404,7 @@ static void prim_typeOf(EvalState & state, const Pos & pos, Value * * args, Valu
         case nFloat: t = "float"; break;
         case nThunk: abort();
     }
-    v.mkString(state.symbols.create(t));
+    v.mkString(t);
 }
 
 static RegisterPrimOp primop_typeOf({
@@ -417,7 +419,7 @@ static RegisterPrimOp primop_typeOf({
 });
 
 /* Determine whether the argument is the null value. */
-static void prim_isNull(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isNull(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nNull);
@@ -437,7 +439,7 @@ static RegisterPrimOp primop_isNull({
 });
 
 /* Determine whether the argument is a function. */
-static void prim_isFunction(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isFunction(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nFunction);
@@ -453,7 +455,7 @@ static RegisterPrimOp primop_isFunction({
 });
 
 /* Determine whether the argument is an integer. */
-static void prim_isInt(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isInt(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nInt);
@@ -469,7 +471,7 @@ static RegisterPrimOp primop_isInt({
 });
 
 /* Determine whether the argument is a float. */
-static void prim_isFloat(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isFloat(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nFloat);
@@ -485,7 +487,7 @@ static RegisterPrimOp primop_isFloat({
 });
 
 /* Determine whether the argument is a string. */
-static void prim_isString(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isString(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nString);
@@ -501,7 +503,7 @@ static RegisterPrimOp primop_isString({
 });
 
 /* Determine whether the argument is a Boolean. */
-static void prim_isBool(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isBool(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nBool);
@@ -517,7 +519,7 @@ static RegisterPrimOp primop_isBool({
 });
 
 /* Determine whether the argument is a path. */
-static void prim_isPath(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isPath(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nPath);
@@ -585,31 +587,31 @@ static Bindings::iterator getAttr(
     std::string_view funcName,
     Symbol attrSym,
     Bindings * attrSet,
-    const Pos & pos)
+    const PosIdx pos)
 {
     Bindings::iterator value = attrSet->find(attrSym);
     if (value == attrSet->end()) {
         hintformat errorMsg = hintfmt(
             "attribute '%s' missing for call to '%s'",
-            attrSym,
+            state.symbols[attrSym],
             funcName
         );
 
-        Pos aPos = *attrSet->pos;
-        if (aPos == noPos) {
+        auto aPos = attrSet->pos;
+        if (!aPos) {
             throw TypeError({
                 .msg = errorMsg,
-                .errPos = pos,
+                .errPos = state.positions[pos],
             });
         } else {
             auto e = TypeError({
                 .msg = errorMsg,
-                .errPos = aPos,
+                .errPos = state.positions[aPos],
             });
 
             // Adding another trace for the function name to make it clear
             // which call received wrong arguments.
-            e.addTrace(pos, hintfmt("while invoking '%s'", funcName));
+            e.addTrace(state.positions[pos], hintfmt("while invoking '%s'", funcName));
             throw e;
         }
     }
@@ -617,7 +619,7 @@ static Bindings::iterator getAttr(
     return value;
 }
 
-static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_genericClosure(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
 
@@ -666,7 +668,7 @@ static void prim_genericClosure(EvalState & state, const Pos & pos, Value * * ar
         if (key == e->attrs->end())
             throw EvalError({
                 .msg = hintfmt("attribute 'key' required"),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
         state.forceValue(*key->value, pos);
 
@@ -729,7 +731,7 @@ static RegisterPrimOp primop_abort({
     .doc = R"(
       Abort Nix expression evaluation and print the error message *s*.
     )",
-    .fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
+    .fun = [](EvalState & state, const PosIdx pos, Value * * args, Value & v)
     {
         PathSet context;
         auto s = state.coerceToString(pos, *args[0], context).toOwned();
@@ -747,7 +749,7 @@ static RegisterPrimOp primop_throw({
       derivations, a derivation that throws an error is silently skipped
       (which is not the case for `abort`).
     )",
-    .fun = [](EvalState & state, const Pos & pos, Value * * args, Value & v)
+    .fun = [](EvalState & state, const PosIdx pos, Value * * args, Value & v)
     {
       PathSet context;
       auto s = state.coerceToString(pos, *args[0], context).toOwned();
@@ -755,7 +757,7 @@ static RegisterPrimOp primop_throw({
     }
 });
 
-static void prim_addErrorContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_addErrorContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     try {
         state.forceValue(*args[1], pos);
@@ -773,7 +775,7 @@ static RegisterPrimOp primop_addErrorContext(RegisterPrimOp::Info {
     .fun = prim_addErrorContext,
 });
 
-static void prim_ceil(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_ceil(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto value = state.forceFloat(*args[0], args[0]->determinePos(pos));
     v.mkInt(ceil(value));
@@ -792,7 +794,7 @@ static RegisterPrimOp primop_ceil({
     .fun = prim_ceil,
 });
 
-static void prim_floor(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_floor(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto value = state.forceFloat(*args[0], args[0]->determinePos(pos));
     v.mkInt(floor(value));
@@ -813,7 +815,7 @@ static RegisterPrimOp primop_floor({
 
 /* Try evaluating the argument. Success => {success=true; value=something;},
  * else => {success=false; value=false;} */
-static void prim_tryEval(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_tryEval(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto attrs = state.buildBindings(2);
     try {
@@ -849,7 +851,7 @@ static RegisterPrimOp primop_tryEval({
 });
 
 /* Return an environment variable.  Use with care. */
-static void prim_getEnv(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_getEnv(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     std::string name(state.forceStringNoCtx(*args[0], pos));
     v.mkString(evalSettings.restrictEval || evalSettings.pureEval ? "" : getEnv(name).value_or(""));
@@ -873,7 +875,7 @@ static RegisterPrimOp primop_getEnv({
 });
 
 /* Evaluate the first argument, then return the second argument. */
-static void prim_seq(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_seq(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     state.forceValue(*args[1], pos);
@@ -892,7 +894,7 @@ static RegisterPrimOp primop_seq({
 
 /* Evaluate the first argument deeply (i.e. recursing into lists and
    attrsets), then return the second argument. */
-static void prim_deepSeq(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_deepSeq(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValueDeep(*args[0]);
     state.forceValue(*args[1], pos);
@@ -912,13 +914,13 @@ static RegisterPrimOp primop_deepSeq({
 
 /* Evaluate the first expression and print it on standard error.  Then
    return the second expression.  Useful for debugging. */
-static void prim_trace(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_trace(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     if (args[0]->type() == nString)
         printError("trace: %1%", args[0]->string.s);
     else
-        printError("trace: %1%", *args[0]);
+        printError("trace: %1%", printValue(state, *args[0]));
     state.forceValue(*args[1], pos);
     v = *args[1];
 }
@@ -947,7 +949,7 @@ static RegisterPrimOp primop_trace({
    derivation; `drvPath' containing the path of the Nix expression;
    and `type' set to `derivation' to indicate that this is a
    derivation. */
-static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_derivationStrict(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
 
@@ -961,11 +963,11 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
     );
 
     std::string drvName;
-    Pos & posDrvName(*attr->pos);
+    const auto posDrvName = attr->pos;
     try {
         drvName = state.forceStringNoCtx(*attr->value, pos);
     } catch (Error & e) {
-        e.addTrace(posDrvName, "while evaluating the derivation attribute 'name'");
+        e.addTrace(state.positions[posDrvName], "while evaluating the derivation attribute 'name'");
         throw;
     }
 
@@ -997,9 +999,9 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
     StringSet outputs;
     outputs.insert("out");
 
-    for (auto & i : args[0]->attrs->lexicographicOrder()) {
+    for (auto & i : args[0]->attrs->lexicographicOrder(state.symbols)) {
         if (i->name == state.sIgnoreNulls) continue;
-        const std::string & key = i->name;
+        const std::string & key = state.symbols[i->name];
         vomit("processing attribute '%1%'", key);
 
         auto handleHashMode = [&](const std::string_view s) {
@@ -1008,7 +1010,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
             else
                 throw EvalError({
                     .msg = hintfmt("invalid value '%s' for 'outputHashMode' attribute", s),
-                    .errPos = posDrvName
+                    .errPos = state.positions[posDrvName]
                 });
         };
 
@@ -1018,7 +1020,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
                 if (outputs.find(j) != outputs.end())
                     throw EvalError({
                         .msg = hintfmt("duplicate derivation output '%1%'", j),
-                        .errPos = posDrvName
+                        .errPos = state.positions[posDrvName]
                     });
                 /* !!! Check whether j is a valid attribute
                    name. */
@@ -1028,14 +1030,14 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
                 if (j == "drv")
                     throw EvalError({
                         .msg = hintfmt("invalid derivation output name 'drv'" ),
-                        .errPos = posDrvName
+                        .errPos = state.positions[posDrvName]
                     });
                 outputs.insert(j);
             }
             if (outputs.empty())
                 throw EvalError({
                     .msg = hintfmt("derivation cannot have an empty set of outputs"),
-                    .errPos = posDrvName
+                    .errPos = state.positions[posDrvName]
                 });
         };
 
@@ -1099,7 +1101,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
                     }
 
                 } else {
-                    auto s = state.coerceToString(*i->pos, *i->value, context, true).toOwned();
+                    auto s = state.coerceToString(i->pos, *i->value, context, true).toOwned();
                     drv.env.emplace(key, s);
                     if (i->name == state.sBuilder) drv.builder = std::move(s);
                     else if (i->name == state.sSystem) drv.platform = std::move(s);
@@ -1113,7 +1115,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
             }
 
         } catch (Error & e) {
-            e.addTrace(posDrvName,
+            e.addTrace(state.positions[posDrvName],
                 "while evaluating the attribute '%1%' of the derivation '%2%'",
                 key, drvName);
             throw;
@@ -1163,20 +1165,20 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
     if (drv.builder == "")
         throw EvalError({
             .msg = hintfmt("required attribute 'builder' missing"),
-            .errPos = posDrvName
+            .errPos = state.positions[posDrvName]
         });
 
     if (drv.platform == "")
         throw EvalError({
             .msg = hintfmt("required attribute 'system' missing"),
-            .errPos = posDrvName
+            .errPos = state.positions[posDrvName]
         });
 
     /* Check whether the derivation name is valid. */
     if (isDerivation(drvName))
         throw EvalError({
             .msg = hintfmt("derivation names are not allowed to end in '%s'", drvExtension),
-            .errPos = posDrvName
+            .errPos = state.positions[posDrvName]
         });
 
     if (outputHash) {
@@ -1187,7 +1189,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
         if (outputs.size() != 1 || *(outputs.begin()) != "out")
             throw Error({
                 .msg = hintfmt("multiple outputs are not supported in fixed-output derivations"),
-                .errPos = posDrvName
+                .errPos = state.positions[posDrvName]
             });
 
         auto h = newHashAllowEmpty(*outputHash, parseHashTypeOpt(outputHashAlgo));
@@ -1208,7 +1210,7 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
         if (contentAddressed && isImpure)
             throw EvalError({
                 .msg = hintfmt("derivation cannot be both content-addressed and impure"),
-                .errPos = posDrvName
+                .errPos = state.positions[posDrvName]
             });
 
         auto ht = parseHashTypeOpt(outputHashAlgo).value_or(htSHA256);
@@ -1248,8 +1250,13 @@ static void prim_derivationStrict(EvalState & state, const Pos & pos, Value * *
         switch (hashModulo.kind) {
         case DrvHash::Kind::Regular:
             for (auto & i : outputs) {
-                auto h = hashModulo.hashes.at(i);
-                auto outPath = state.store->makeOutputPath(i, h, drvName);
+                auto h = get(hashModulo.hashes, i);
+                if (!h)
+                    throw AssertionError({
+                        .msg = hintfmt("derivation produced no hash for output '%s'", i),
+                        .errPos = state.positions[posDrvName],
+                    });
+                auto outPath = state.store->makeOutputPath(i, *h, drvName);
                 drv.env[i] = state.store->printStorePath(outPath);
                 drv.outputs.insert_or_assign(
                     i,
@@ -1300,7 +1307,7 @@ static RegisterPrimOp primop_derivationStrict(RegisterPrimOp::Info {
    time, any occurrence of this string in an derivation attribute will
    be replaced with the concrete path in the Nix store of the output
    ‘out’. */
-static void prim_placeholder(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_placeholder(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     v.mkString(hashPlaceholder(state.forceStringNoCtx(*args[0], pos)));
 }
@@ -1323,7 +1330,7 @@ static RegisterPrimOp primop_placeholder({
 
 
 /* Convert the argument to a path.  !!! obsolete? */
-static void prim_toPath(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_toPath(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     Path path = state.coerceToPath(pos, *args[0], context);
@@ -1348,12 +1355,12 @@ static RegisterPrimOp primop_toPath({
    /nix/store/newhash-oldhash-oldname.  In the past, `toPath' had
    special case behaviour for store paths, but that created weird
    corner cases. */
-static void prim_storePath(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_storePath(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     if (evalSettings.pureEval)
         throw EvalError({
             .msg = hintfmt("'%s' is not allowed in pure evaluation mode", "builtins.storePath"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     PathSet context;
@@ -1365,7 +1372,7 @@ static void prim_storePath(EvalState & state, const Pos & pos, Value * * args, V
     if (!state.store->isInStore(path))
         throw EvalError({
             .msg = hintfmt("path '%1%' is not in the Nix store", path),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
     auto path2 = state.store->toStorePath(path).first;
     if (!settings.readOnlyMode)
@@ -1392,7 +1399,7 @@ static RegisterPrimOp primop_storePath({
     .fun = prim_storePath,
 });
 
-static void prim_pathExists(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_pathExists(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     /* We don’t check the path right now, because we don’t want to
       throw if the path isn’t allowed, but just return false (and we
@@ -1424,7 +1431,7 @@ static RegisterPrimOp primop_pathExists({
 
 /* Return the base name of the given string, i.e., everything
    following the last slash. */
-static void prim_baseNameOf(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_baseNameOf(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     v.mkString(baseNameOf(*state.coerceToString(pos, *args[0], context, false, false)), context);
@@ -1444,7 +1451,7 @@ static RegisterPrimOp primop_baseNameOf({
 /* Return the directory of the given path, i.e., everything before the
    last slash.  Return either a path or a string depending on the type
    of the argument. */
-static void prim_dirOf(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_dirOf(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     auto path = state.coerceToString(pos, *args[0], context, false, false);
@@ -1464,7 +1471,7 @@ static RegisterPrimOp primop_dirOf({
 });
 
 /* Return the contents of a file as a string. */
-static void prim_readFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_readFile(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto path = realisePath(state, pos, *args[0]);
     auto s = readFile(path);
@@ -1492,7 +1499,7 @@ static RegisterPrimOp primop_readFile({
 
 /* Find a file in the Nix search path. Used to implement <x> paths,
    which are desugared to 'findFile __nixPath "x"'. */
-static void prim_findFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_findFile(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[0], pos);
 
@@ -1523,7 +1530,7 @@ static void prim_findFile(EvalState & state, const Pos & pos, Value * * args, Va
         } catch (InvalidPathError & e) {
             throw EvalError({
                 .msg = hintfmt("cannot find '%1%', since path '%2%' is not valid", path, e.path),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
         }
 
@@ -1543,14 +1550,14 @@ static RegisterPrimOp primop_findFile(RegisterPrimOp::Info {
 });
 
 /* Return the cryptographic hash of a file in base-16. */
-static void prim_hashFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_hashFile(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto type = state.forceStringNoCtx(*args[0], pos);
     std::optional<HashType> ht = parseHashType(type);
     if (!ht)
         throw Error({
             .msg = hintfmt("unknown hash type '%1%'", type),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     auto path = realisePath(state, pos, *args[1]);
@@ -1570,7 +1577,7 @@ static RegisterPrimOp primop_hashFile({
 });
 
 /* Read a directory (without . or ..) */
-static void prim_readDir(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_readDir(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto path = realisePath(state, pos, *args[0]);
 
@@ -1619,7 +1626,7 @@ static RegisterPrimOp primop_readDir({
 /* Convert the argument (which can be any Nix expression) to an XML
    representation returned in a string.  Not all Nix expressions can
    be sensibly or completely represented (e.g., functions). */
-static void prim_toXML(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_toXML(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     std::ostringstream out;
     PathSet context;
@@ -1727,7 +1734,7 @@ static RegisterPrimOp primop_toXML({
 /* Convert the argument (which can be any Nix expression) to a JSON
    string.  Not all Nix expressions can be sensibly or completely
    represented (e.g., functions). */
-static void prim_toJSON(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_toJSON(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     std::ostringstream out;
     PathSet context;
@@ -1750,13 +1757,13 @@ static RegisterPrimOp primop_toJSON({
 });
 
 /* Parse a JSON string to a value. */
-static void prim_fromJSON(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_fromJSON(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto s = state.forceStringNoCtx(*args[0], pos);
     try {
         parseJSON(state, s, v);
     } catch (JSONParseError &e) {
-        e.addTrace(pos, "while decoding a JSON string");
+        e.addTrace(state.positions[pos], "while decoding a JSON string");
         throw;
     }
 }
@@ -1778,7 +1785,7 @@ static RegisterPrimOp primop_fromJSON({
 
 /* Store a string in the Nix store as a source file that can be used
    as an input by derivations. */
-static void prim_toFile(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_toFile(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     std::string name(state.forceStringNoCtx(*args[0], pos));
@@ -1793,20 +1800,21 @@ static void prim_toFile(EvalState & state, const Pos & pos, Value * * args, Valu
                     "in 'toFile': the file named '%1%' must not contain a reference "
                     "to a derivation but contains (%2%)",
                     name, path),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
         refs.insert(state.store->parseStorePath(path));
     }
 
-    auto storePath = state.store->printStorePath(settings.readOnlyMode
+    auto storePath = settings.readOnlyMode
         ? state.store->computeStorePathForText(name, contents, refs)
-        : state.store->addTextToStore(name, contents, refs, state.repair));
+        : state.store->addTextToStore(name, contents, refs, state.repair);
 
     /* Note: we don't need to add `context' to the context of the
        result, since `storePath' itself has references to the paths
        used in args[1]. */
 
-    v.mkString(storePath, {storePath});
+    /* Add the output of this to the allowed paths. */
+    state.allowAndSetStorePathString(storePath, v);
 }
 
 static RegisterPrimOp primop_toFile({
@@ -1889,7 +1897,7 @@ static RegisterPrimOp primop_toFile({
 
 static void addPath(
     EvalState & state,
-    const Pos & pos,
+    const PosIdx pos,
     const std::string & name,
     Path path,
     Value * filterFun,
@@ -1956,13 +1964,13 @@ static void addPath(
         } else
             state.allowAndSetStorePathString(*expectedStorePath, v);
     } catch (Error & e) {
-        e.addTrace(pos, "while adding path '%s'", path);
+        e.addTrace(state.positions[pos], "while adding path '%s'", path);
         throw;
     }
 }
 
 
-static void prim_filterSource(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_filterSource(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     Path path = state.coerceToPath(pos, *args[1], context);
@@ -1973,7 +1981,7 @@ static void prim_filterSource(EvalState & state, const Pos & pos, Value * * args
             .msg = hintfmt(
                 "first argument in call to 'filterSource' is not a function but %1%",
                 showType(*args[0])),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     addPath(state, pos, std::string(baseNameOf(path)), path, args[0], FileIngestionMethod::Recursive, std::nullopt, v, context);
@@ -2034,7 +2042,7 @@ static RegisterPrimOp primop_filterSource({
     .fun = prim_filterSource,
 });
 
-static void prim_path(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_path(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
     Path path;
@@ -2045,28 +2053,28 @@ static void prim_path(EvalState & state, const Pos & pos, Value * * args, Value
     PathSet context;
 
     for (auto & attr : *args[0]->attrs) {
-        auto & n(attr.name);
+        auto n = state.symbols[attr.name];
         if (n == "path")
-            path = state.coerceToPath(*attr.pos, *attr.value, context);
+            path = state.coerceToPath(attr.pos, *attr.value, context);
         else if (attr.name == state.sName)
-            name = state.forceStringNoCtx(*attr.value, *attr.pos);
+            name = state.forceStringNoCtx(*attr.value, attr.pos);
         else if (n == "filter") {
             state.forceValue(*attr.value, pos);
             filterFun = attr.value;
         } else if (n == "recursive")
-            method = FileIngestionMethod { state.forceBool(*attr.value, *attr.pos) };
+            method = FileIngestionMethod { state.forceBool(*attr.value, attr.pos) };
         else if (n == "sha256")
-            expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA256);
+            expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos), htSHA256);
         else
             throw EvalError({
-                .msg = hintfmt("unsupported argument '%1%' to 'addPath'", attr.name),
-                .errPos = *attr.pos
+                .msg = hintfmt("unsupported argument '%1%' to 'addPath'", state.symbols[attr.name]),
+                .errPos = state.positions[attr.pos]
             });
     }
     if (path.empty())
         throw EvalError({
             .msg = hintfmt("'path' required"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
     if (name.empty())
         name = baseNameOf(path);
@@ -2117,7 +2125,7 @@ static RegisterPrimOp primop_path({
 
 /* Return the names of the attributes in a set as a sorted list of
    strings. */
-static void prim_attrNames(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_attrNames(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
 
@@ -2125,7 +2133,7 @@ static void prim_attrNames(EvalState & state, const Pos & pos, Value * * args, V
 
     size_t n = 0;
     for (auto & i : *args[0]->attrs)
-        (v.listElems()[n++] = state.allocValue())->mkString(i.name);
+        (v.listElems()[n++] = state.allocValue())->mkString(state.symbols[i.name]);
 
     std::sort(v.listElems(), v.listElems() + n,
               [](Value * v1, Value * v2) { return strcmp(v1->string.s, v2->string.s) < 0; });
@@ -2144,7 +2152,7 @@ static RegisterPrimOp primop_attrNames({
 
 /* Return the values of the attributes in a set as a list, in the same
    order as attrNames. */
-static void prim_attrValues(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_attrValues(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
 
@@ -2155,8 +2163,9 @@ static void prim_attrValues(EvalState & state, const Pos & pos, Value * * args,
         v.listElems()[n++] = (Value *) &i;
 
     std::sort(v.listElems(), v.listElems() + n,
-        [](Value * v1, Value * v2) {
-            std::string_view s1 = ((Attr *) v1)->name, s2 = ((Attr *) v2)->name;
+        [&](Value * v1, Value * v2) {
+            std::string_view s1 = state.symbols[((Attr *) v1)->name],
+                s2 = state.symbols[((Attr *) v2)->name];
             return s1 < s2;
         });
 
@@ -2175,7 +2184,7 @@ static RegisterPrimOp primop_attrValues({
 });
 
 /* Dynamic version of the `.' operator. */
-void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)
+void prim_getAttr(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto attr = state.forceStringNoCtx(*args[0], pos);
     state.forceAttrs(*args[1], pos);
@@ -2187,7 +2196,7 @@ void prim_getAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)
         pos
     );
     // !!! add to stack trace?
-    if (state.countCalls && *i->pos != noPos) state.attrSelects[*i->pos]++;
+    if (state.countCalls && i->pos) state.attrSelects[i->pos]++;
     state.forceValue(*i->value, pos);
     v = *i->value;
 }
@@ -2205,7 +2214,7 @@ static RegisterPrimOp primop_getAttr({
 });
 
 /* Return position information of the specified attribute. */
-static void prim_unsafeGetAttrPos(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_unsafeGetAttrPos(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto attr = state.forceStringNoCtx(*args[0], pos);
     state.forceAttrs(*args[1], pos);
@@ -2223,7 +2232,7 @@ static RegisterPrimOp primop_unsafeGetAttrPos(RegisterPrimOp::Info {
 });
 
 /* Dynamic version of the `?' operator. */
-static void prim_hasAttr(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_hasAttr(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto attr = state.forceStringNoCtx(*args[0], pos);
     state.forceAttrs(*args[1], pos);
@@ -2242,7 +2251,7 @@ static RegisterPrimOp primop_hasAttr({
 });
 
 /* Determine whether the argument is a set. */
-static void prim_isAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isAttrs(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nAttrs);
@@ -2257,7 +2266,7 @@ static RegisterPrimOp primop_isAttrs({
     .fun = prim_isAttrs,
 });
 
-static void prim_removeAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_removeAttrs(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
     state.forceList(*args[1], pos);
@@ -2305,7 +2314,7 @@ static RegisterPrimOp primop_removeAttrs({
    "nameN"; value = valueN;}] is transformed to {name1 = value1;
    ... nameN = valueN;}.  In case of duplicate occurrences of the same
    name, the first takes precedence. */
-static void prim_listToAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_listToAttrs(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[0], pos);
 
@@ -2324,9 +2333,9 @@ static void prim_listToAttrs(EvalState & state, const Pos & pos, Value * * args,
             pos
         );
 
-        auto name = state.forceStringNoCtx(*j->value, *j->pos);
+        auto name = state.forceStringNoCtx(*j->value, j->pos);
 
-        Symbol sym = state.symbols.create(name);
+        auto sym = state.symbols.create(name);
         if (seen.insert(sym).second) {
             Bindings::iterator j2 = getAttr(
                 state,
@@ -2367,7 +2376,7 @@ static RegisterPrimOp primop_listToAttrs({
     .fun = prim_listToAttrs,
 });
 
-static void prim_intersectAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_intersectAttrs(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
     state.forceAttrs(*args[1], pos);
@@ -2393,9 +2402,9 @@ static RegisterPrimOp primop_intersectAttrs({
     .fun = prim_intersectAttrs,
 });
 
-static void prim_catAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_catAttrs(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
-    Symbol attrName = state.symbols.create(state.forceStringNoCtx(*args[0], pos));
+    auto attrName = state.symbols.create(state.forceStringNoCtx(*args[0], pos));
     state.forceList(*args[1], pos);
 
     Value * res[args[1]->listSize()];
@@ -2430,7 +2439,7 @@ static RegisterPrimOp primop_catAttrs({
     .fun = prim_catAttrs,
 });
 
-static void prim_functionArgs(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_functionArgs(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     if (args[0]->isPrimOpApp() || args[0]->isPrimOp()) {
@@ -2440,7 +2449,7 @@ static void prim_functionArgs(EvalState & state, const Pos & pos, Value * * args
     if (!args[0]->isLambda())
         throw TypeError({
             .msg = hintfmt("'functionArgs' requires a function"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     if (!args[0]->lambda.fun->hasFormals()) {
@@ -2451,7 +2460,7 @@ static void prim_functionArgs(EvalState & state, const Pos & pos, Value * * args
     auto attrs = state.buildBindings(args[0]->lambda.fun->formals->formals.size());
     for (auto & i : args[0]->lambda.fun->formals->formals)
         // !!! should optimise booleans (allocate only once)
-        attrs.alloc(i.name, ptr(&i.pos)).mkBool(i.def);
+        attrs.alloc(i.name, i.pos).mkBool(i.def);
     v.mkAttrs(attrs);
 }
 
@@ -2473,7 +2482,7 @@ static RegisterPrimOp primop_functionArgs({
 });
 
 /*  */
-static void prim_mapAttrs(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_mapAttrs(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[1], pos);
 
@@ -2482,7 +2491,7 @@ static void prim_mapAttrs(EvalState & state, const Pos & pos, Value * * args, Va
     for (auto & i : *args[1]->attrs) {
         Value * vName = state.allocValue();
         Value * vFun2 = state.allocValue();
-        vName->mkString(i.name);
+        vName->mkString(state.symbols[i.name]);
         vFun2->mkApp(args[0], vName);
         attrs.alloc(i.name).mkApp(vFun2, i.value);
     }
@@ -2505,7 +2514,7 @@ static RegisterPrimOp primop_mapAttrs({
     .fun = prim_mapAttrs,
 });
 
-static void prim_zipAttrsWith(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_zipAttrsWith(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     // we will first count how many values are present for each given key.
     // we then allocate a single attrset and pre-populate it with lists of
@@ -2528,7 +2537,7 @@ static void prim_zipAttrsWith(EvalState & state, const Pos & pos, Value * * args
             for (auto & attr : *vElem->attrs)
                 attrsSeen[attr.name].first++;
         } catch (TypeError & e) {
-            e.addTrace(pos, hintfmt("while invoking '%s'", "zipAttrsWith"));
+            e.addTrace(state.positions[pos], hintfmt("while invoking '%s'", "zipAttrsWith"));
             throw;
         }
     }
@@ -2549,7 +2558,7 @@ static void prim_zipAttrsWith(EvalState & state, const Pos & pos, Value * * args
 
     for (auto & attr : *v.attrs) {
         auto name = state.allocValue();
-        name->mkString(attr.name);
+        name->mkString(state.symbols[attr.name]);
         auto call1 = state.allocValue();
         call1->mkApp(args[0], name);
         auto call2 = state.allocValue();
@@ -2597,7 +2606,7 @@ static RegisterPrimOp primop_zipAttrsWith({
 
 
 /* Determine whether the argument is a list. */
-static void prim_isList(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_isList(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     v.mkBool(args[0]->type() == nList);
@@ -2612,20 +2621,20 @@ static RegisterPrimOp primop_isList({
     .fun = prim_isList,
 });
 
-static void elemAt(EvalState & state, const Pos & pos, Value & list, int n, Value & v)
+static void elemAt(EvalState & state, const PosIdx pos, Value & list, int n, Value & v)
 {
     state.forceList(list, pos);
     if (n < 0 || (unsigned int) n >= list.listSize())
         throw Error({
             .msg = hintfmt("list index %1% is out of bounds", n),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
     state.forceValue(*list.listElems()[n], pos);
     v = *list.listElems()[n];
 }
 
 /* Return the n-1'th element of a list. */
-static void prim_elemAt(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_elemAt(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     elemAt(state, pos, *args[0], state.forceInt(*args[1], pos), v);
 }
@@ -2641,7 +2650,7 @@ static RegisterPrimOp primop_elemAt({
 });
 
 /* Return the first element of a list. */
-static void prim_head(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_head(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     elemAt(state, pos, *args[0], 0, v);
 }
@@ -2660,13 +2669,13 @@ static RegisterPrimOp primop_head({
 /* Return a list consisting of everything but the first element of
    a list.  Warning: this function takes O(n) time, so you probably
    don't want to use it!  */
-static void prim_tail(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_tail(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[0], pos);
     if (args[0]->listSize() == 0)
         throw Error({
             .msg = hintfmt("'tail' called on an empty list"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     state.mkList(v, args[0]->listSize() - 1);
@@ -2691,7 +2700,7 @@ static RegisterPrimOp primop_tail({
 });
 
 /* Apply a function to every element of a list. */
-static void prim_map(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_map(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[1], pos);
 
@@ -2721,7 +2730,7 @@ static RegisterPrimOp primop_map({
 /* Filter a list using a predicate; that is, return a list containing
    every element from the list for which the predicate function
    returns true. */
-static void prim_filter(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_filter(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceFunction(*args[0], pos);
     state.forceList(*args[1], pos);
@@ -2759,7 +2768,7 @@ static RegisterPrimOp primop_filter({
 });
 
 /* Return true if a list contains a given element. */
-static void prim_elem(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_elem(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     bool res = false;
     state.forceList(*args[1], pos);
@@ -2782,7 +2791,7 @@ static RegisterPrimOp primop_elem({
 });
 
 /* Concatenate a list of lists. */
-static void prim_concatLists(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_concatLists(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[0], pos);
     state.concatLists(v, args[0]->listSize(), args[0]->listElems(), pos);
@@ -2798,7 +2807,7 @@ static RegisterPrimOp primop_concatLists({
 });
 
 /* Return the length of a list.  This is an O(1) time operation. */
-static void prim_length(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_length(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[0], pos);
     v.mkInt(args[0]->listSize());
@@ -2815,7 +2824,7 @@ static RegisterPrimOp primop_length({
 
 /* Reduce a list by applying a binary operator, from left to
    right. The operator is applied strictly. */
-static void prim_foldlStrict(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_foldlStrict(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceFunction(*args[0], pos);
     state.forceList(*args[2], pos);
@@ -2848,7 +2857,7 @@ static RegisterPrimOp primop_foldlStrict({
     .fun = prim_foldlStrict,
 });
 
-static void anyOrAll(bool any, EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void anyOrAll(bool any, EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceFunction(*args[0], pos);
     state.forceList(*args[1], pos);
@@ -2867,7 +2876,7 @@ static void anyOrAll(bool any, EvalState & state, const Pos & pos, Value * * arg
 }
 
 
-static void prim_any(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_any(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     anyOrAll(true, state, pos, args, v);
 }
@@ -2882,7 +2891,7 @@ static RegisterPrimOp primop_any({
     .fun = prim_any,
 });
 
-static void prim_all(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_all(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     anyOrAll(false, state, pos, args, v);
 }
@@ -2897,14 +2906,14 @@ static RegisterPrimOp primop_all({
     .fun = prim_all,
 });
 
-static void prim_genList(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_genList(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto len = state.forceInt(*args[1], pos);
 
     if (len < 0)
         throw EvalError({
             .msg = hintfmt("cannot create list of size %1%", len),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     state.mkList(v, len);
@@ -2932,10 +2941,10 @@ static RegisterPrimOp primop_genList({
     .fun = prim_genList,
 });
 
-static void prim_lessThan(EvalState & state, const Pos & pos, Value * * args, Value & v);
+static void prim_lessThan(EvalState & state, const PosIdx pos, Value * * args, Value & v);
 
 
-static void prim_sort(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_sort(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceFunction(*args[0], pos);
     state.forceList(*args[1], pos);
@@ -2986,7 +2995,7 @@ static RegisterPrimOp primop_sort({
     .fun = prim_sort,
 });
 
-static void prim_partition(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_partition(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceFunction(*args[0], pos);
     state.forceList(*args[1], pos);
@@ -3046,7 +3055,7 @@ static RegisterPrimOp primop_partition({
     .fun = prim_partition,
 });
 
-static void prim_groupBy(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_groupBy(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceFunction(*args[0], pos);
     state.forceList(*args[1], pos);
@@ -3057,7 +3066,7 @@ static void prim_groupBy(EvalState & state, const Pos & pos, Value * * args, Val
         Value res;
         state.callFunction(*args[0], *vElem, res, pos);
         auto name = state.forceStringNoCtx(res, pos);
-        Symbol sym = state.symbols.create(name);
+        auto sym = state.symbols.create(name);
         auto vector = attrs.try_emplace(sym, ValueVector()).first;
         vector->second.push_back(vElem);
     }
@@ -3098,7 +3107,7 @@ static RegisterPrimOp primop_groupBy({
     .fun = prim_groupBy,
 });
 
-static void prim_concatMap(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_concatMap(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceFunction(*args[0], pos);
     state.forceList(*args[1], pos);
@@ -3113,7 +3122,7 @@ static void prim_concatMap(EvalState & state, const Pos & pos, Value * * args, V
         try {
             state.forceList(lists[n], lists[n].determinePos(args[0]->determinePos(pos)));
         } catch (TypeError &e) {
-            e.addTrace(pos, hintfmt("while invoking '%s'", "concatMap"));
+            e.addTrace(state.positions[pos], hintfmt("while invoking '%s'", "concatMap"));
             throw;
         }
         len += lists[n].listSize();
@@ -3145,7 +3154,7 @@ static RegisterPrimOp primop_concatMap({
  *************************************************************/
 
 
-static void prim_add(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_add(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     state.forceValue(*args[1], pos);
@@ -3164,7 +3173,7 @@ static RegisterPrimOp primop_add({
     .fun = prim_add,
 });
 
-static void prim_sub(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_sub(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     state.forceValue(*args[1], pos);
@@ -3183,7 +3192,7 @@ static RegisterPrimOp primop_sub({
     .fun = prim_sub,
 });
 
-static void prim_mul(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_mul(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     state.forceValue(*args[1], pos);
@@ -3202,7 +3211,7 @@ static RegisterPrimOp primop_mul({
     .fun = prim_mul,
 });
 
-static void prim_div(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_div(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     state.forceValue(*args[1], pos);
@@ -3211,7 +3220,7 @@ static void prim_div(EvalState & state, const Pos & pos, Value * * args, Value &
     if (f2 == 0)
         throw EvalError({
             .msg = hintfmt("division by zero"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     if (args[0]->type() == nFloat || args[1]->type() == nFloat) {
@@ -3223,7 +3232,7 @@ static void prim_div(EvalState & state, const Pos & pos, Value * * args, Value &
         if (i1 == std::numeric_limits<NixInt>::min() && i2 == -1)
             throw EvalError({
                 .msg = hintfmt("overflow in integer division"),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
 
         v.mkInt(i1 / i2);
@@ -3239,7 +3248,7 @@ static RegisterPrimOp primop_div({
     .fun = prim_div,
 });
 
-static void prim_bitAnd(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_bitAnd(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     v.mkInt(state.forceInt(*args[0], pos) & state.forceInt(*args[1], pos));
 }
@@ -3253,7 +3262,7 @@ static RegisterPrimOp primop_bitAnd({
     .fun = prim_bitAnd,
 });
 
-static void prim_bitOr(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_bitOr(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     v.mkInt(state.forceInt(*args[0], pos) | state.forceInt(*args[1], pos));
 }
@@ -3267,7 +3276,7 @@ static RegisterPrimOp primop_bitOr({
     .fun = prim_bitOr,
 });
 
-static void prim_bitXor(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_bitXor(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     v.mkInt(state.forceInt(*args[0], pos) ^ state.forceInt(*args[1], pos));
 }
@@ -3281,7 +3290,7 @@ static RegisterPrimOp primop_bitXor({
     .fun = prim_bitXor,
 });
 
-static void prim_lessThan(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_lessThan(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceValue(*args[0], pos);
     state.forceValue(*args[1], pos);
@@ -3309,7 +3318,7 @@ static RegisterPrimOp primop_lessThan({
 /* Convert the argument to a string.  Paths are *not* copied to the
    store, so `toString /foo/bar' yields `"/foo/bar"', not
    `"/nix/store/whatever..."'. */
-static void prim_toString(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_toString(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     auto s = state.coerceToString(pos, *args[0], context, true, false);
@@ -3344,7 +3353,7 @@ static RegisterPrimOp primop_toString({
    at character position `min(start, stringLength str)' inclusive and
    ending at `min(start + len, stringLength str)'.  `start' must be
    non-negative. */
-static void prim_substring(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_substring(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     int start = state.forceInt(*args[0], pos);
     int len = state.forceInt(*args[1], pos);
@@ -3354,7 +3363,7 @@ static void prim_substring(EvalState & state, const Pos & pos, Value * * args, V
     if (start < 0)
         throw EvalError({
             .msg = hintfmt("negative start position in 'substring'"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     v.mkString((unsigned int) start >= s->size() ? "" : s->substr(start, len), context);
@@ -3380,7 +3389,7 @@ static RegisterPrimOp primop_substring({
     .fun = prim_substring,
 });
 
-static void prim_stringLength(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_stringLength(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     auto s = state.coerceToString(pos, *args[0], context);
@@ -3398,14 +3407,14 @@ static RegisterPrimOp primop_stringLength({
 });
 
 /* Return the cryptographic hash of a string in base-16. */
-static void prim_hashString(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_hashString(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto type = state.forceStringNoCtx(*args[0], pos);
     std::optional<HashType> ht = parseHashType(type);
     if (!ht)
         throw Error({
             .msg = hintfmt("unknown hash type '%1%'", type),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     PathSet context; // discarded
@@ -3446,7 +3455,7 @@ std::shared_ptr<RegexCache> makeRegexCache()
     return std::make_shared<RegexCache>();
 }
 
-void prim_match(EvalState & state, const Pos & pos, Value * * args, Value & v)
+void prim_match(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto re = state.forceStringNoCtx(*args[0], pos);
 
@@ -3478,12 +3487,12 @@ void prim_match(EvalState & state, const Pos & pos, Value * * args, Value & v)
             // limit is _GLIBCXX_REGEX_STATE_LIMIT for libstdc++
             throw EvalError({
                 .msg = hintfmt("memory limit exceeded by regular expression '%s'", re),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
         } else {
             throw EvalError({
                 .msg = hintfmt("invalid regular expression '%s'", re),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
         }
     }
@@ -3527,7 +3536,7 @@ static RegisterPrimOp primop_match({
 
 /* Split a string with a regular expression, and return a list of the
    non-matching parts interleaved by the lists of the matching groups. */
-void prim_split(EvalState & state, const Pos & pos, Value * * args, Value & v)
+void prim_split(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto re = state.forceStringNoCtx(*args[0], pos);
 
@@ -3583,12 +3592,12 @@ void prim_split(EvalState & state, const Pos & pos, Value * * args, Value & v)
             // limit is _GLIBCXX_REGEX_STATE_LIMIT for libstdc++
             throw EvalError({
                 .msg = hintfmt("memory limit exceeded by regular expression '%s'", re),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
         } else {
             throw EvalError({
                 .msg = hintfmt("invalid regular expression '%s'", re),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
         }
     }
@@ -3623,7 +3632,7 @@ static RegisterPrimOp primop_split({
       Evaluates to `[ "" [ "a" null ] "b" [ null "c" ] "" ]`.
 
       ```nix
-      builtins.split "([[:upper:]]+)" "  FOO   "
+      builtins.split "([[:upper:]]+)" " FOO "
       ```
 
       Evaluates to `[ " " [ "FOO" ] " " ]`.
@@ -3631,7 +3640,7 @@ static RegisterPrimOp primop_split({
     .fun = prim_split,
 });
 
-static void prim_concatStringsSep(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_concatStringsSep(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
 
@@ -3661,14 +3670,14 @@ static RegisterPrimOp primop_concatStringsSep({
     .fun = prim_concatStringsSep,
 });
 
-static void prim_replaceStrings(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_replaceStrings(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceList(*args[0], pos);
     state.forceList(*args[1], pos);
     if (args[0]->listSize() != args[1]->listSize())
         throw EvalError({
             .msg = hintfmt("'from' and 'to' arguments to 'replaceStrings' have different lengths"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     std::vector<std::string> from;
@@ -3741,7 +3750,7 @@ static RegisterPrimOp primop_replaceStrings({
  *************************************************************/
 
 
-static void prim_parseDrvName(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_parseDrvName(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto name = state.forceStringNoCtx(*args[0], pos);
     DrvName parsed(name);
@@ -3765,7 +3774,7 @@ static RegisterPrimOp primop_parseDrvName({
     .fun = prim_parseDrvName,
 });
 
-static void prim_compareVersions(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_compareVersions(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto version1 = state.forceStringNoCtx(*args[0], pos);
     auto version2 = state.forceStringNoCtx(*args[1], pos);
@@ -3785,7 +3794,7 @@ static RegisterPrimOp primop_compareVersions({
     .fun = prim_compareVersions,
 });
 
-static void prim_splitVersion(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_splitVersion(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto version = state.forceStringNoCtx(*args[0], pos);
     auto iter = version.cbegin();
@@ -3906,7 +3915,7 @@ void EvalState::createBaseEnv()
                 addPrimOp({
                     .fun = primOp.fun,
                     .arity = std::max(primOp.args.size(), primOp.arity),
-                    .name = symbols.create(primOp.name),
+                    .name = primOp.name,
                     .args = primOp.args,
                     .doc = primOp.doc,
                 });
@@ -3914,7 +3923,7 @@ void EvalState::createBaseEnv()
 
     /* Add a wrapper around the derivation primop that computes the
        `drvPath' and `outPath' attributes lazily. */
-    sDerivationNix = symbols.create("//builtin/derivation.nix");
+    sDerivationNix = symbols.create(derivationNixPath);
     auto vDerivation = allocValue();
     addConstant("derivation", vDerivation);
 
@@ -3931,7 +3940,7 @@ void EvalState::createBaseEnv()
         // the parser needs two NUL bytes as terminators; one of them
         // is implied by being a C string.
         "\0";
-    eval(parse(code, sizeof(code), foFile, sDerivationNix, "/", staticBaseEnv), *vDerivation);
+    eval(parse(code, sizeof(code), foFile, derivationNixPath, "/", staticBaseEnv), *vDerivation);
 }
 
 
diff --git a/src/libexpr/primops.hh b/src/libexpr/primops.hh
index 905bd0366..1cfb4356b 100644
--- a/src/libexpr/primops.hh
+++ b/src/libexpr/primops.hh
@@ -38,9 +38,9 @@ struct RegisterPrimOp
    them. */
 
 /* Load a ValueInitializer from a DSO and return whatever it initializes */
-void prim_importNative(EvalState & state, const Pos & pos, Value * * args, Value & v);
+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 Pos & pos, Value * * args, Value & v);
+void prim_exec(EvalState & state, const PosIdx pos, Value * * args, Value & v);
 
 }
diff --git a/src/libexpr/primops/context.cc b/src/libexpr/primops/context.cc
index cc74c7f58..979136984 100644
--- a/src/libexpr/primops/context.cc
+++ b/src/libexpr/primops/context.cc
@@ -5,7 +5,7 @@
 
 namespace nix {
 
-static void prim_unsafeDiscardStringContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_unsafeDiscardStringContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     auto s = state.coerceToString(pos, *args[0], context);
@@ -15,7 +15,7 @@ static void prim_unsafeDiscardStringContext(EvalState & state, const Pos & pos,
 static RegisterPrimOp primop_unsafeDiscardStringContext("__unsafeDiscardStringContext", 1, prim_unsafeDiscardStringContext);
 
 
-static void prim_hasContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_hasContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     state.forceString(*args[0], context, pos);
@@ -31,7 +31,7 @@ static RegisterPrimOp primop_hasContext("__hasContext", 1, prim_hasContext);
    source-only deployment).  This primop marks the string context so
    that builtins.derivation adds the path to drv.inputSrcs rather than
    drv.inputDrvs. */
-static void prim_unsafeDiscardOutputDependency(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_unsafeDiscardOutputDependency(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     auto s = state.coerceToString(pos, *args[0], context);
@@ -65,7 +65,7 @@ static RegisterPrimOp primop_unsafeDiscardOutputDependency("__unsafeDiscardOutpu
    Note that for a given path any combination of the above attributes
    may be present.
 */
-static void prim_getContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_getContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     struct ContextInfo {
         bool path = false;
@@ -134,7 +134,7 @@ static RegisterPrimOp primop_getContext("__getContext", 1, prim_getContext);
    See the commentary above unsafeGetContext for details of the
    context representation.
 */
-static void prim_appendContext(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_appendContext(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     PathSet context;
     auto orig = state.forceString(*args[0], context, pos);
@@ -144,45 +144,46 @@ static void prim_appendContext(EvalState & state, const Pos & pos, Value * * arg
     auto sPath = state.symbols.create("path");
     auto sAllOutputs = state.symbols.create("allOutputs");
     for (auto & i : *args[1]->attrs) {
-        if (!state.store->isStorePath(i.name))
+        const auto & name = state.symbols[i.name];
+        if (!state.store->isStorePath(name))
             throw EvalError({
-                .msg = hintfmt("Context key '%s' is not a store path", i.name),
-                .errPos = *i.pos
+                .msg = hintfmt("Context key '%s' is not a store path", name),
+                .errPos = state.positions[i.pos]
             });
         if (!settings.readOnlyMode)
-            state.store->ensurePath(state.store->parseStorePath(i.name));
-        state.forceAttrs(*i.value, *i.pos);
+            state.store->ensurePath(state.store->parseStorePath(name));
+        state.forceAttrs(*i.value, i.pos);
         auto iter = i.value->attrs->find(sPath);
         if (iter != i.value->attrs->end()) {
-            if (state.forceBool(*iter->value, *iter->pos))
-                context.insert(i.name);
+            if (state.forceBool(*iter->value, iter->pos))
+                context.emplace(name);
         }
 
         iter = i.value->attrs->find(sAllOutputs);
         if (iter != i.value->attrs->end()) {
-            if (state.forceBool(*iter->value, *iter->pos)) {
-                if (!isDerivation(i.name)) {
+            if (state.forceBool(*iter->value, iter->pos)) {
+                if (!isDerivation(name)) {
                     throw EvalError({
-                        .msg = hintfmt("Tried to add all-outputs context of %s, which is not a derivation, to a string", i.name),
-                        .errPos = *i.pos
+                        .msg = hintfmt("Tried to add all-outputs context of %s, which is not a derivation, to a string", name),
+                        .errPos = state.positions[i.pos]
                     });
                 }
-                context.insert("=" + std::string(i.name));
+                context.insert(concatStrings("=", name));
             }
         }
 
         iter = i.value->attrs->find(state.sOutputs);
         if (iter != i.value->attrs->end()) {
-            state.forceList(*iter->value, *iter->pos);
-            if (iter->value->listSize() && !isDerivation(i.name)) {
+            state.forceList(*iter->value, iter->pos);
+            if (iter->value->listSize() && !isDerivation(name)) {
                 throw EvalError({
-                    .msg = hintfmt("Tried to add derivation output context of %s, which is not a derivation, to a string", i.name),
-                    .errPos = *i.pos
+                    .msg = hintfmt("Tried to add derivation output context of %s, which is not a derivation, to a string", name),
+                    .errPos = state.positions[i.pos]
                 });
             }
             for (auto elem : iter->value->listItems()) {
-                auto name = state.forceStringNoCtx(*elem, *iter->pos);
-                context.insert(concatStrings("!", name, "!", i.name));
+                auto outputName = state.forceStringNoCtx(*elem, iter->pos);
+                context.insert(concatStrings("!", outputName, "!", name));
             }
         }
     }
diff --git a/src/libexpr/primops/fetchClosure.cc b/src/libexpr/primops/fetchClosure.cc
index 821eba698..662c9652e 100644
--- a/src/libexpr/primops/fetchClosure.cc
+++ b/src/libexpr/primops/fetchClosure.cc
@@ -5,7 +5,7 @@
 
 namespace nix {
 
-static void prim_fetchClosure(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_fetchClosure(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     state.forceAttrs(*args[0], pos);
 
@@ -15,40 +15,42 @@ static void prim_fetchClosure(EvalState & state, const Pos & pos, Value * * args
     std::optional<StorePath> toPath;
 
     for (auto & attr : *args[0]->attrs) {
-        if (attr.name == "fromPath") {
+        const auto & attrName = state.symbols[attr.name];
+
+        if (attrName == "fromPath") {
             PathSet context;
-            fromPath = state.coerceToStorePath(*attr.pos, *attr.value, context);
+            fromPath = state.coerceToStorePath(attr.pos, *attr.value, context);
         }
 
-        else if (attr.name == "toPath") {
-            state.forceValue(*attr.value, *attr.pos);
+        else if (attrName == "toPath") {
+            state.forceValue(*attr.value, attr.pos);
             toCA = true;
             if (attr.value->type() != nString || attr.value->string.s != std::string("")) {
                 PathSet context;
-                toPath = state.coerceToStorePath(*attr.pos, *attr.value, context);
+                toPath = state.coerceToStorePath(attr.pos, *attr.value, context);
             }
         }
 
-        else if (attr.name == "fromStore")
-            fromStoreUrl = state.forceStringNoCtx(*attr.value, *attr.pos);
+        else if (attrName == "fromStore")
+            fromStoreUrl = state.forceStringNoCtx(*attr.value, attr.pos);
 
         else
             throw Error({
-                .msg = hintfmt("attribute '%s' isn't supported in call to 'fetchClosure'", attr.name),
-                .errPos = pos
+                .msg = hintfmt("attribute '%s' isn't supported in call to 'fetchClosure'", attrName),
+                .errPos = state.positions[pos]
             });
     }
 
     if (!fromPath)
         throw Error({
             .msg = hintfmt("attribute '%s' is missing in call to 'fetchClosure'", "fromPath"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     if (!fromStoreUrl)
         throw Error({
             .msg = hintfmt("attribute '%s' is missing in call to 'fetchClosure'", "fromStore"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     auto parsedURL = parseURL(*fromStoreUrl);
@@ -58,13 +60,13 @@ static void prim_fetchClosure(EvalState & state, const Pos & pos, Value * * args
         !(getEnv("_NIX_IN_TEST").has_value() && parsedURL.scheme == "file"))
         throw Error({
             .msg = hintfmt("'fetchClosure' only supports http:// and https:// stores"),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     if (!parsedURL.query.empty())
         throw Error({
             .msg = hintfmt("'fetchClosure' does not support URL query parameters (in '%s')", *fromStoreUrl),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
 
     auto fromStore = openStore(parsedURL.to_string());
@@ -80,7 +82,7 @@ static void prim_fetchClosure(EvalState & state, const Pos & pos, Value * * args
                         state.store->printStorePath(*fromPath),
                         state.store->printStorePath(i->second),
                         state.store->printStorePath(*toPath)),
-                    .errPos = pos
+                    .errPos = state.positions[pos]
                 });
             if (!toPath)
                 throw Error({
@@ -89,7 +91,7 @@ static void prim_fetchClosure(EvalState & state, const Pos & pos, Value * * args
                         "please set this in the 'toPath' attribute passed to 'fetchClosure'",
                         state.store->printStorePath(*fromPath),
                         state.store->printStorePath(i->second)),
-                    .errPos = pos
+                    .errPos = state.positions[pos]
                 });
         }
     } else {
@@ -105,7 +107,7 @@ static void prim_fetchClosure(EvalState & state, const Pos & pos, Value * * args
             throw Error({
                 .msg = hintfmt("in pure mode, 'fetchClosure' requires a content-addressed path, which '%s' isn't",
                     state.store->printStorePath(*toPath)),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
     }
 
diff --git a/src/libexpr/primops/fetchMercurial.cc b/src/libexpr/primops/fetchMercurial.cc
index b7f715859..249c0934e 100644
--- a/src/libexpr/primops/fetchMercurial.cc
+++ b/src/libexpr/primops/fetchMercurial.cc
@@ -7,7 +7,7 @@
 
 namespace nix {
 
-static void prim_fetchMercurial(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_fetchMercurial(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     std::string url;
     std::optional<Hash> rev;
@@ -22,31 +22,31 @@ static void prim_fetchMercurial(EvalState & state, const Pos & pos, Value * * ar
         state.forceAttrs(*args[0], pos);
 
         for (auto & attr : *args[0]->attrs) {
-            std::string_view n(attr.name);
+            std::string_view n(state.symbols[attr.name]);
             if (n == "url")
-                url = state.coerceToString(*attr.pos, *attr.value, context, false, false).toOwned();
+                url = state.coerceToString(attr.pos, *attr.value, context, 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);
+                auto value = state.forceStringNoCtx(*attr.value, attr.pos);
                 if (std::regex_match(value.begin(), value.end(), revRegex))
                     rev = Hash::parseAny(value, htSHA1);
                 else
                     ref = value;
             }
             else if (n == "name")
-                name = state.forceStringNoCtx(*attr.value, *attr.pos);
+                name = state.forceStringNoCtx(*attr.value, attr.pos);
             else
                 throw EvalError({
-                    .msg = hintfmt("unsupported argument '%s' to 'fetchMercurial'", attr.name),
-                    .errPos = *attr.pos
+                    .msg = hintfmt("unsupported argument '%s' to 'fetchMercurial'", state.symbols[attr.name]),
+                    .errPos = state.positions[attr.pos]
                 });
         }
 
         if (url.empty())
             throw EvalError({
                 .msg = hintfmt("'url' argument required"),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
 
     } else
diff --git a/src/libexpr/primops/fetchTree.cc b/src/libexpr/primops/fetchTree.cc
index 42c98e312..d7c3c9918 100644
--- a/src/libexpr/primops/fetchTree.cc
+++ b/src/libexpr/primops/fetchTree.cc
@@ -90,7 +90,7 @@ struct FetchTreeParams {
 
 static void fetchTree(
     EvalState & state,
-    const Pos & pos,
+    const PosIdx pos,
     Value * * args,
     Value & v,
     std::optional<std::string> type,
@@ -110,43 +110,43 @@ static void fetchTree(
             if (type)
                 throw Error({
                     .msg = hintfmt("unexpected attribute 'type'"),
-                    .errPos = pos
+                    .errPos = state.positions[pos]
                 });
-            type = state.forceStringNoCtx(*aType->value, *aType->pos);
+            type = state.forceStringNoCtx(*aType->value, aType->pos);
         } else if (!type)
             throw Error({
                 .msg = hintfmt("attribute 'type' is missing in call to 'fetchTree'"),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
 
         attrs.emplace("type", type.value());
 
         for (auto & attr : *args[0]->attrs) {
             if (attr.name == state.sType) continue;
-            state.forceValue(*attr.value, *attr.pos);
+            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(attr.name,
-                    attr.name == "url"
+                auto s = state.coerceToString(attr.pos, *attr.value, context, false, false).toOwned();
+                attrs.emplace(state.symbols[attr.name],
+                    state.symbols[attr.name] == "url"
                     ? type == "git"
                       ? fixURIForGit(s, state)
                       : fixURI(s, state)
                     : s);
             }
             else if (attr.value->type() == nBool)
-                attrs.emplace(attr.name, Explicit<bool>{attr.value->boolean});
+                attrs.emplace(state.symbols[attr.name], Explicit<bool>{attr.value->boolean});
             else if (attr.value->type() == nInt)
-                attrs.emplace(attr.name, uint64_t(attr.value->integer));
+                attrs.emplace(state.symbols[attr.name], uint64_t(attr.value->integer));
             else
                 throw TypeError("fetchTree argument '%s' is %s while a string, Boolean or integer is expected",
-                    attr.name, showType(*attr.value));
+                    state.symbols[attr.name], showType(*attr.value));
         }
 
         if (!params.allowNameArgument)
             if (auto nameIter = attrs.find("name"); nameIter != attrs.end())
                 throw Error({
                     .msg = hintfmt("attribute 'name' isn't supported in call to 'fetchTree'"),
-                    .errPos = pos
+                    .errPos = state.positions[pos]
                 });
 
         input = fetchers::Input::fromAttrs(std::move(attrs));
@@ -167,7 +167,7 @@ static void fetchTree(
         input = lookupInRegistries(state.store, input).first;
 
     if (evalSettings.pureEval && !input.isLocked())
-        throw Error("in pure evaluation mode, 'fetchTree' requires a locked input, at %s", pos);
+        throw Error("in pure evaluation mode, 'fetchTree' requires a locked input, at %s", state.positions[pos]);
 
     auto [tree, input2] = input.fetch(state.store);
 
@@ -176,7 +176,7 @@ static void fetchTree(
     emitTreeAttrs(state, tree, input2, v, params.emptyRevFallback, false);
 }
 
-static void prim_fetchTree(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_fetchTree(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     settings.requireExperimentalFeature(Xp::Flakes);
     fetchTree(state, pos, args, v, std::nullopt, FetchTreeParams { .allowNameArgument = false });
@@ -185,7 +185,7 @@ static void prim_fetchTree(EvalState & state, const Pos & pos, Value * * args, V
 // FIXME: document
 static RegisterPrimOp primop_fetchTree("fetchTree", 1, prim_fetchTree);
 
-static void fetch(EvalState & state, const Pos & pos, Value * * args, Value & v,
+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;
@@ -198,24 +198,24 @@ static void fetch(EvalState & state, const Pos & pos, Value * * args, Value & v,
         state.forceAttrs(*args[0], pos);
 
         for (auto & attr : *args[0]->attrs) {
-            std::string n(attr.name);
+            std::string_view n(state.symbols[attr.name]);
             if (n == "url")
-                url = state.forceStringNoCtx(*attr.value, *attr.pos);
+                url = state.forceStringNoCtx(*attr.value, attr.pos);
             else if (n == "sha256")
-                expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA256);
+                expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos), htSHA256);
             else if (n == "name")
-                name = state.forceStringNoCtx(*attr.value, *attr.pos);
+                name = state.forceStringNoCtx(*attr.value, attr.pos);
             else
                 throw EvalError({
-                    .msg = hintfmt("unsupported argument '%s' to '%s'", attr.name, who),
-                    .errPos = *attr.pos
+                    .msg = hintfmt("unsupported argument '%s' to '%s'", n, who),
+                    .errPos = state.positions[attr.pos]
                 });
             }
 
         if (!url)
             throw EvalError({
                 .msg = hintfmt("'url' argument required"),
-                .errPos = pos
+                .errPos = state.positions[pos]
             });
     } else
         url = state.forceStringNoCtx(*args[0], pos);
@@ -262,7 +262,7 @@ static void fetch(EvalState & state, const Pos & pos, Value * * args, Value & v,
     state.allowAndSetStorePathString(storePath, v);
 }
 
-static void prim_fetchurl(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_fetchurl(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     fetch(state, pos, args, v, "fetchurl", false, "");
 }
@@ -278,7 +278,7 @@ static RegisterPrimOp primop_fetchurl({
     .fun = prim_fetchurl,
 });
 
-static void prim_fetchTarball(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_fetchTarball(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     fetch(state, pos, args, v, "fetchTarball", true, "source");
 }
@@ -329,7 +329,7 @@ static RegisterPrimOp primop_fetchTarball({
     .fun = prim_fetchTarball,
 });
 
-static void prim_fetchGit(EvalState & state, const Pos & pos, Value * * args, Value & v)
+static void prim_fetchGit(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     fetchTree(state, pos, args, v, "git", FetchTreeParams { .emptyRevFallback = true, .allowNameArgument = true });
 }
diff --git a/src/libexpr/primops/fromTOML.cc b/src/libexpr/primops/fromTOML.cc
index dd4280030..9753e2ac9 100644
--- a/src/libexpr/primops/fromTOML.cc
+++ b/src/libexpr/primops/fromTOML.cc
@@ -5,7 +5,7 @@
 
 namespace nix {
 
-static void prim_fromTOML(EvalState & state, const Pos & pos, Value * * args, Value & val)
+static void prim_fromTOML(EvalState & state, const PosIdx pos, Value * * args, Value & val)
 {
     auto toml = state.forceStringNoCtx(*args[0], pos);
 
@@ -73,7 +73,7 @@ static void prim_fromTOML(EvalState & state, const Pos & pos, Value * * args, Va
     } catch (std::exception & e) { // TODO: toml::syntax_error
         throw EvalError({
             .msg = hintfmt("while parsing a TOML string: %s", e.what()),
-            .errPos = pos
+            .errPos = state.positions[pos]
         });
     }
 }
diff --git a/src/libexpr/symbol-table.hh b/src/libexpr/symbol-table.hh
index 48d20c29d..288c15602 100644
--- a/src/libexpr/symbol-table.hh
+++ b/src/libexpr/symbol-table.hh
@@ -5,44 +5,32 @@
 #include <unordered_map>
 
 #include "types.hh"
+#include "chunked-vector.hh"
 
 namespace nix {
 
 /* Symbol table used by the parser and evaluator to represent and look
    up identifiers and attributes efficiently.  SymbolTable::create()
    converts a string into a symbol.  Symbols have the property that
-   they can be compared efficiently (using a pointer equality test),
+   they can be compared efficiently (using an equality test),
    because the symbol table stores only one copy of each string. */
 
-class Symbol
+/* 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
 {
-private:
-    const std::string * s; // pointer into SymbolTable
-    Symbol(const std::string * s) : s(s) { };
     friend class SymbolTable;
 
-public:
-    Symbol() : s(0) { };
+private:
+    const std::string * s;
 
-    bool operator == (const Symbol & s2) const
-    {
-        return s == s2.s;
-    }
+    explicit SymbolStr(const std::string & symbol): s(&symbol) {}
 
-    // FIXME: remove
+public:
     bool operator == (std::string_view s2) const
     {
-        return s->compare(s2) == 0;
-    }
-
-    bool operator != (const Symbol & s2) const
-    {
-        return s != s2.s;
-    }
-
-    bool operator < (const Symbol & s2) const
-    {
-        return s < s2.s;
+        return *s == s2;
     }
 
     operator const std::string & () const
@@ -55,51 +43,78 @@ public:
         return *s;
     }
 
-    bool set() const
-    {
-        return s;
-    }
+    friend std::ostream & operator <<(std::ostream & os, const SymbolStr & symbol);
+};
 
-    bool empty() const
-    {
-        return s->empty();
-    }
+class Symbol
+{
+    friend class SymbolTable;
+
+private:
+    uint32_t id;
+
+    explicit Symbol(uint32_t id): id(id) {}
+
+public:
+    Symbol() : id(0) {}
 
-    friend std::ostream & operator << (std::ostream & str, const Symbol & sym);
+    explicit operator bool() const { return id > 0; }
+
+    bool operator<(const Symbol other) const { return id < other.id; }
+    bool operator==(const Symbol other) const { return id == other.id; }
+    bool operator!=(const Symbol other) const { return id != other.id; }
 };
 
 class SymbolTable
 {
 private:
-    std::unordered_map<std::string_view, Symbol> symbols;
-    std::list<std::string> store;
+    std::unordered_map<std::string_view, std::pair<const std::string *, uint32_t>> symbols;
+    ChunkedVector<std::string, 8192> store{16};
 
 public:
+
     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 it->second;
+        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);
+    }
 
-        auto & rawSym = store.emplace_back(s);
-        return symbols.emplace(rawSym, Symbol(&rawSym)).first->second;
+    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())
+            abort();
+        return SymbolStr(store[s.id - 1]);
     }
 
     size_t size() const
     {
-        return symbols.size();
+        return store.size();
     }
 
     size_t totalSize() const;
 
     template<typename T>
-    void dump(T callback)
+    void dump(T callback) const
     {
-        for (auto & s : store)
-            callback(s);
+        store.forEach(callback);
     }
 };
 
diff --git a/src/libexpr/tests/json.cc b/src/libexpr/tests/json.cc
new file mode 100644
index 000000000..f1ea1b197
--- /dev/null
+++ b/src/libexpr/tests/json.cc
@@ -0,0 +1,68 @@
+#include "libexprtests.hh"
+#include "value-to-json.hh"
+
+namespace nix {
+// Testing the conversion to JSON
+
+    class JSONValueTest : public LibExprTest {
+        protected:
+            std::string getJSONValue(Value& value) {
+                std::stringstream ss;
+                PathSet ps;
+                printValueAsJSON(state, true, value, noPos, ss, ps);
+                return ss.str();
+            }
+    };
+
+    TEST_F(JSONValueTest, null) {
+        Value v;
+        v.mkNull();
+        ASSERT_EQ(getJSONValue(v), "null");
+    }
+
+    TEST_F(JSONValueTest, BoolFalse) {
+        Value v;
+        v.mkBool(false);
+        ASSERT_EQ(getJSONValue(v),"false");
+    }
+
+    TEST_F(JSONValueTest, BoolTrue) {
+        Value v;
+        v.mkBool(true);
+        ASSERT_EQ(getJSONValue(v), "true");
+    }
+
+    TEST_F(JSONValueTest, IntPositive) {
+        Value v;
+        v.mkInt(100);
+        ASSERT_EQ(getJSONValue(v), "100");
+    }
+
+    TEST_F(JSONValueTest, IntNegative) {
+        Value v;
+        v.mkInt(-100);
+        ASSERT_EQ(getJSONValue(v), "-100");
+    }
+
+    TEST_F(JSONValueTest, String) {
+        Value v;
+        v.mkString("test");
+        ASSERT_EQ(getJSONValue(v), "\"test\"");
+    }
+
+    TEST_F(JSONValueTest, StringQuotes) {
+        Value v;
+
+        v.mkString("test\"");
+        ASSERT_EQ(getJSONValue(v), "\"test\\\"\"");
+    }
+
+    // The dummy store doesn't support writing files. Fails with this exception message:
+    // C++ exception with description "error: operation 'addToStoreFromDump' is
+    // not supported by store 'dummy'" thrown in the test body.
+    TEST_F(JSONValueTest, DISABLED_Path) {
+        Value v;
+        v.mkPath("test");
+        ASSERT_EQ(getJSONValue(v), "\"/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-x\"");
+    }
+} /* namespace nix */
diff --git a/src/libexpr/tests/libexprtests.hh b/src/libexpr/tests/libexprtests.hh
new file mode 100644
index 000000000..4f6915882
--- /dev/null
+++ b/src/libexpr/tests/libexprtests.hh
@@ -0,0 +1,136 @@
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "value.hh"
+#include "nixexpr.hh"
+#include "eval.hh"
+#include "eval-inline.hh"
+#include "store-api.hh"
+
+
+namespace nix {
+    class LibExprTest : public ::testing::Test {
+        public:
+            static void SetUpTestSuite() {
+                initGC();
+            }
+
+        protected:
+            LibExprTest()
+                : store(openStore("dummy://"))
+                , state({}, store)
+            {
+            }
+            Value eval(std::string input, bool forceValue = true) {
+                Value v;
+                Expr * e = state.parseExprFromString(input, "");
+                assert(e);
+                state.eval(e, v);
+                if (forceValue)
+                    state.forceValue(v, noPos);
+                return v;
+            }
+
+            Symbol createSymbol(const char * value) {
+                return state.symbols.create(value);
+            }
+
+            ref<Store> store;
+            EvalState state;
+    };
+
+    MATCHER(IsListType, "") {
+        return arg != nList;
+    }
+
+    MATCHER(IsList, "") {
+        return arg.type() == nList;
+    }
+
+    MATCHER(IsString, "") {
+        return arg.type() == nString;
+    }
+
+    MATCHER(IsNull, "") {
+        return arg.type() == nNull;
+    }
+
+    MATCHER(IsThunk, "") {
+        return arg.type() == nThunk;
+    }
+
+    MATCHER(IsAttrs, "") {
+        return arg.type() == nAttrs;
+    }
+
+    MATCHER_P(IsStringEq, s, fmt("The string is equal to \"%1%\"", s)) {
+        if (arg.type() != nString) {
+            return false;
+        }
+        return std::string_view(arg.string.s) == s;
+    }
+
+    MATCHER_P(IsIntEq, v, fmt("The string is equal to \"%1%\"", v)) {
+        if (arg.type() != nInt) {
+            return false;
+        }
+        return arg.integer == v;
+    }
+
+    MATCHER_P(IsFloatEq, v, fmt("The float is equal to \"%1%\"", v)) {
+        if (arg.type() != nFloat) {
+            return false;
+        }
+        return arg.fpoint == v;
+    }
+
+    MATCHER(IsTrue, "") {
+        if (arg.type() != nBool) {
+            return false;
+        }
+        return arg.boolean == true;
+    }
+
+    MATCHER(IsFalse, "") {
+        if (arg.type() != nBool) {
+            return false;
+        }
+        return arg.boolean == false;
+    }
+
+    MATCHER_P(IsPathEq, p, fmt("Is a path equal to \"%1%\"", p)) {
+            if (arg.type() != nPath) {
+                *result_listener << "Expected a path got " << arg.type();
+                return false;
+            } else if (std::string_view(arg.string.s) != p) {
+                *result_listener << "Expected a path that equals \"" << p << "\" but got: " << arg.string.s;
+                return false;
+            }
+            return true;
+    }
+
+
+    MATCHER_P(IsListOfSize, n, fmt("Is a list of size [%1%]", n)) {
+        if (arg.type() != nList) {
+            *result_listener << "Expected list got " << arg.type();
+            return false;
+        } else if (arg.listSize() != (size_t)n) {
+            *result_listener << "Expected as list of size " << n << " got " << arg.listSize();
+            return false;
+        }
+        return true;
+    }
+
+    MATCHER_P(IsAttrsOfSize, n, fmt("Is a set of size [%1%]", n)) {
+        if (arg.type() != nAttrs) {
+            *result_listener << "Expexted set got " << arg.type();
+            return false;
+        } else if (arg.attrs->size() != (size_t)n) {
+            *result_listener << "Expected a set with " << n << " attributes but got " << arg.attrs->size();
+            return false;
+        }
+        return true;
+    }
+
+
+} /* namespace nix */
diff --git a/src/libexpr/tests/local.mk b/src/libexpr/tests/local.mk
new file mode 100644
index 000000000..b95980cab
--- /dev/null
+++ b/src/libexpr/tests/local.mk
@@ -0,0 +1,15 @@
+check: libexpr-tests_RUN
+
+programs += libexpr-tests
+
+libexpr-tests_DIR := $(d)
+
+libexpr-tests_INSTALL_DIR :=
+
+libexpr-tests_SOURCES := $(wildcard $(d)/*.cc)
+
+libexpr-tests_CXXFLAGS += -I src/libexpr -I src/libutil -I src/libstore -I src/libexpr/tests
+
+libexpr-tests_LIBS = libexpr libutil libstore libfetchers
+
+libexpr-tests_LDFLAGS := $(GTEST_LIBS) -lgmock
diff --git a/src/libexpr/tests/primops.cc b/src/libexpr/tests/primops.cc
new file mode 100644
index 000000000..f65b6593d
--- /dev/null
+++ b/src/libexpr/tests/primops.cc
@@ -0,0 +1,839 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "libexprtests.hh"
+
+namespace nix {
+    class CaptureLogger : public Logger
+    {
+        std::ostringstream oss;
+
+        public:
+            CaptureLogger() {}
+
+            std::string get() const {
+                return oss.str();
+            }
+
+            void log(Verbosity lvl, const FormatOrString & fs) override {
+                oss << fs.s << std::endl;
+            }
+
+            void logEI(const ErrorInfo & ei) override {
+                showErrorInfo(oss, ei, loggerSettings.showTrace.get());
+            }
+    };
+
+    class CaptureLogging {
+        Logger * oldLogger;
+        std::unique_ptr<CaptureLogger> tempLogger;
+        public:
+            CaptureLogging() : tempLogger(std::make_unique<CaptureLogger>()) {
+                oldLogger = logger;
+                logger = tempLogger.get();
+            }
+
+            ~CaptureLogging() {
+                logger = oldLogger;
+            }
+
+            std::string get() const {
+                return tempLogger->get();
+            }
+    };
+
+
+    // Testing eval of PrimOp's
+    class PrimOpTest : public LibExprTest {};
+
+
+    TEST_F(PrimOpTest, throw) {
+        ASSERT_THROW(eval("throw \"foo\""), ThrownError);
+    }
+
+    TEST_F(PrimOpTest, abort) {
+        ASSERT_THROW(eval("abort \"abort\""), Abort);
+    }
+
+    TEST_F(PrimOpTest, ceil) {
+        auto v = eval("builtins.ceil 1.9");
+        ASSERT_THAT(v, IsIntEq(2));
+    }
+
+    TEST_F(PrimOpTest, floor) {
+        auto v = eval("builtins.floor 1.9");
+        ASSERT_THAT(v, IsIntEq(1));
+    }
+
+    TEST_F(PrimOpTest, tryEvalFailure) {
+        auto v = eval("builtins.tryEval (throw \"\")");
+        ASSERT_THAT(v, IsAttrsOfSize(2));
+        auto s = createSymbol("success");
+        auto p = v.attrs->get(s);
+        ASSERT_NE(p, nullptr);
+        ASSERT_THAT(*p->value, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, tryEvalSuccess) {
+        auto v = eval("builtins.tryEval 123");
+        ASSERT_THAT(v, IsAttrs());
+        auto s = createSymbol("success");
+        auto p = v.attrs->get(s);
+        ASSERT_NE(p, nullptr);
+        ASSERT_THAT(*p->value, IsTrue());
+        s = createSymbol("value");
+        p = v.attrs->get(s);
+        ASSERT_NE(p, nullptr);
+        ASSERT_THAT(*p->value, IsIntEq(123));
+    }
+
+    TEST_F(PrimOpTest, getEnv) {
+        setenv("_NIX_UNIT_TEST_ENV_VALUE", "test value", 1);
+        auto v = eval("builtins.getEnv \"_NIX_UNIT_TEST_ENV_VALUE\"");
+        ASSERT_THAT(v, IsStringEq("test value"));
+    }
+
+    TEST_F(PrimOpTest, seq) {
+        ASSERT_THROW(eval("let x = throw \"test\"; in builtins.seq x { }"), ThrownError);
+    }
+
+    TEST_F(PrimOpTest, seqNotDeep) {
+        auto v = eval("let x = { z =  throw \"test\"; }; in builtins.seq x { }");
+        ASSERT_THAT(v, IsAttrs());
+    }
+
+    TEST_F(PrimOpTest, deepSeq) {
+        ASSERT_THROW(eval("let x = { z =  throw \"test\"; }; in builtins.deepSeq x { }"), ThrownError);
+    }
+
+    TEST_F(PrimOpTest, trace) {
+        CaptureLogging l;
+        auto v = eval("builtins.trace \"test string 123\" 123");
+        ASSERT_THAT(v, IsIntEq(123));
+        auto text = l.get();
+        ASSERT_NE(text.find("test string 123"), std::string::npos);
+    }
+
+    TEST_F(PrimOpTest, placeholder) {
+        auto v = eval("builtins.placeholder \"out\"");
+        ASSERT_THAT(v, IsStringEq("/1rz4g4znpzjwh1xymhjpm42vipw92pr73vdgl6xs1hycac8kf2n9"));
+    }
+
+    TEST_F(PrimOpTest, baseNameOf) {
+        auto v = eval("builtins.baseNameOf /some/path");
+        ASSERT_THAT(v, IsStringEq("path"));
+    }
+
+    TEST_F(PrimOpTest, dirOf) {
+        auto v = eval("builtins.dirOf /some/path");
+        ASSERT_THAT(v, IsPathEq("/some"));
+    }
+
+    TEST_F(PrimOpTest, attrValues) {
+        auto v = eval("builtins.attrValues { x = \"foo\";  a = 1; }");
+        ASSERT_THAT(v, IsListOfSize(2));
+        ASSERT_THAT(*v.listElems()[0], IsIntEq(1));
+        ASSERT_THAT(*v.listElems()[1], IsStringEq("foo"));
+    }
+
+    TEST_F(PrimOpTest, getAttr) {
+        auto v = eval("builtins.getAttr \"x\" { x = \"foo\"; }");
+        ASSERT_THAT(v, IsStringEq("foo"));
+    }
+
+    TEST_F(PrimOpTest, getAttrNotFound) {
+        // FIXME: TypeError is really bad here, also the error wording is worse
+        // than on Nix <=2.3
+        ASSERT_THROW(eval("builtins.getAttr \"y\" { }"), TypeError);
+    }
+
+    TEST_F(PrimOpTest, unsafeGetAttrPos) {
+        // The `y` attribute is at position
+        const char* expr = "builtins.unsafeGetAttrPos \"y\" { y = \"x\"; }";
+        auto v = eval(expr);
+        ASSERT_THAT(v, IsAttrsOfSize(3));
+
+        auto file = v.attrs->find(createSymbol("file"));
+        ASSERT_NE(file, nullptr);
+        // FIXME: The file when running these tests is the input string?!?
+        ASSERT_THAT(*file->value, IsStringEq(expr));
+
+        auto line = v.attrs->find(createSymbol("line"));
+        ASSERT_NE(line, nullptr);
+        ASSERT_THAT(*line->value, IsIntEq(1));
+
+        auto column = v.attrs->find(createSymbol("column"));
+        ASSERT_NE(column, nullptr);
+        ASSERT_THAT(*column->value, IsIntEq(33));
+    }
+
+    TEST_F(PrimOpTest, hasAttr) {
+        auto v = eval("builtins.hasAttr \"x\" { x = 1; }");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, hasAttrNotFound) {
+        auto v = eval("builtins.hasAttr \"x\" { }");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, isAttrs) {
+        auto v = eval("builtins.isAttrs {}");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, isAttrsFalse) {
+        auto v = eval("builtins.isAttrs null");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, removeAttrs) {
+        auto v = eval("builtins.removeAttrs { x = 1; } [\"x\"]");
+        ASSERT_THAT(v, IsAttrsOfSize(0));
+    }
+
+    TEST_F(PrimOpTest, removeAttrsRetains) {
+        auto v = eval("builtins.removeAttrs { x = 1; y = 2; } [\"x\"]");
+        ASSERT_THAT(v, IsAttrsOfSize(1));
+        ASSERT_NE(v.attrs->find(createSymbol("y")), nullptr);
+    }
+
+    TEST_F(PrimOpTest, listToAttrsEmptyList) {
+        auto v = eval("builtins.listToAttrs []");
+        ASSERT_THAT(v, IsAttrsOfSize(0));
+        ASSERT_EQ(v.type(), nAttrs);
+        ASSERT_EQ(v.attrs->size(), 0);
+    }
+
+    TEST_F(PrimOpTest, listToAttrsNotFieldName) {
+        ASSERT_THROW(eval("builtins.listToAttrs [{}]"), Error);
+    }
+
+    TEST_F(PrimOpTest, listToAttrs) {
+        auto v = eval("builtins.listToAttrs [ { name = \"key\"; value = 123; } ]");
+        ASSERT_THAT(v, IsAttrsOfSize(1));
+        auto key = v.attrs->find(createSymbol("key"));
+        ASSERT_NE(key, nullptr);
+        ASSERT_THAT(*key->value, IsIntEq(123));
+    }
+
+    TEST_F(PrimOpTest, intersectAttrs) {
+        auto v = eval("builtins.intersectAttrs { a = 1; b = 2; } { b = 3; c = 4; }");
+        ASSERT_THAT(v, IsAttrsOfSize(1));
+        auto b = v.attrs->find(createSymbol("b"));
+        ASSERT_NE(b, nullptr);
+        ASSERT_THAT(*b->value, IsIntEq(3));
+    }
+
+    TEST_F(PrimOpTest, catAttrs) {
+        auto v = eval("builtins.catAttrs \"a\" [{a = 1;} {b = 0;} {a = 2;}]");
+        ASSERT_THAT(v, IsListOfSize(2));
+        ASSERT_THAT(*v.listElems()[0], IsIntEq(1));
+        ASSERT_THAT(*v.listElems()[1], IsIntEq(2));
+    }
+
+    TEST_F(PrimOpTest, functionArgs) {
+        auto v = eval("builtins.functionArgs ({ x, y ? 123}: 1)");
+        ASSERT_THAT(v, IsAttrsOfSize(2));
+
+        auto x = v.attrs->find(createSymbol("x"));
+        ASSERT_NE(x, nullptr);
+        ASSERT_THAT(*x->value, IsFalse());
+
+        auto y = v.attrs->find(createSymbol("y"));
+        ASSERT_NE(y, nullptr);
+        ASSERT_THAT(*y->value, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, mapAttrs) {
+        auto v = eval("builtins.mapAttrs (name: value: value * 10) { a = 1; b = 2; }");
+        ASSERT_THAT(v, IsAttrsOfSize(2));
+
+        auto a = v.attrs->find(createSymbol("a"));
+        ASSERT_NE(a, nullptr);
+        ASSERT_THAT(*a->value, IsThunk());
+        state.forceValue(*a->value, noPos);
+        ASSERT_THAT(*a->value, IsIntEq(10));
+
+        auto b = v.attrs->find(createSymbol("b"));
+        ASSERT_NE(b, nullptr);
+        ASSERT_THAT(*b->value, IsThunk());
+        state.forceValue(*b->value, noPos);
+        ASSERT_THAT(*b->value, IsIntEq(20));
+    }
+
+    TEST_F(PrimOpTest, isList) {
+        auto v = eval("builtins.isList []");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, isListFalse) {
+        auto v = eval("builtins.isList null");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, elemtAt) {
+        auto v = eval("builtins.elemAt [0 1 2 3] 3");
+        ASSERT_THAT(v, IsIntEq(3));
+    }
+
+    TEST_F(PrimOpTest, elemtAtOutOfBounds) {
+        ASSERT_THROW(eval("builtins.elemAt [0 1 2 3] 5"), Error);
+    }
+
+    TEST_F(PrimOpTest, head) {
+        auto v = eval("builtins.head [ 3 2 1 0 ]");
+        ASSERT_THAT(v, IsIntEq(3));
+    }
+
+    TEST_F(PrimOpTest, headEmpty) {
+        ASSERT_THROW(eval("builtins.head [ ]"), Error);
+    }
+
+    TEST_F(PrimOpTest, headWrongType) {
+        ASSERT_THROW(eval("builtins.head { }"), Error);
+    }
+
+    TEST_F(PrimOpTest, tail) {
+        auto v = eval("builtins.tail [ 3 2 1 0 ]");
+        ASSERT_THAT(v, IsListOfSize(3));
+        for (const auto [n, elem] : enumerate(v.listItems()))
+            ASSERT_THAT(*elem, IsIntEq(2 - static_cast<int>(n)));
+    }
+
+    TEST_F(PrimOpTest, tailEmpty) {
+        ASSERT_THROW(eval("builtins.tail []"), Error);
+    }
+
+    TEST_F(PrimOpTest, map) {
+        auto v = eval("map (x: \"foo\" + x) [ \"bar\" \"bla\" \"abc\" ]");
+        ASSERT_THAT(v, IsListOfSize(3));
+        auto elem = v.listElems()[0];
+        ASSERT_THAT(*elem, IsThunk());
+        state.forceValue(*elem, noPos);
+        ASSERT_THAT(*elem, IsStringEq("foobar"));
+
+        elem = v.listElems()[1];
+        ASSERT_THAT(*elem, IsThunk());
+        state.forceValue(*elem, noPos);
+        ASSERT_THAT(*elem, IsStringEq("foobla"));
+
+        elem = v.listElems()[2];
+        ASSERT_THAT(*elem, IsThunk());
+        state.forceValue(*elem, noPos);
+        ASSERT_THAT(*elem, IsStringEq("fooabc"));
+    }
+
+    TEST_F(PrimOpTest, filter) {
+        auto v = eval("builtins.filter (x: x == 2) [ 3 2 3 2 3 2 ]");
+        ASSERT_THAT(v, IsListOfSize(3));
+        for (const auto elem : v.listItems())
+            ASSERT_THAT(*elem, IsIntEq(2));
+    }
+
+    TEST_F(PrimOpTest, elemTrue) {
+        auto v = eval("builtins.elem 3 [ 1 2 3 4 5 ]");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, elemFalse) {
+        auto v = eval("builtins.elem 6 [ 1 2 3 4 5 ]");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, concatLists) {
+        auto v = eval("builtins.concatLists [[1 2] [3 4]]");
+        ASSERT_THAT(v, IsListOfSize(4));
+        for (const auto [i, elem] : enumerate(v.listItems()))
+            ASSERT_THAT(*elem, IsIntEq(static_cast<int>(i)+1));
+    }
+
+    TEST_F(PrimOpTest, length) {
+        auto v = eval("builtins.length [ 1 2 3 ]");
+        ASSERT_THAT(v, IsIntEq(3));
+    }
+
+    TEST_F(PrimOpTest, foldStrict) {
+        auto v = eval("builtins.foldl' (a: b: a + b) 0 [1 2 3]");
+        ASSERT_THAT(v, IsIntEq(6));
+    }
+
+    TEST_F(PrimOpTest, anyTrue) {
+        auto v = eval("builtins.any (x: x == 2) [ 1 2 3 ]");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, anyFalse) {
+        auto v = eval("builtins.any (x: x == 5) [ 1 2 3 ]");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, allTrue) {
+        auto v = eval("builtins.all (x: x > 0) [ 1 2 3 ]");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, allFalse) {
+        auto v = eval("builtins.all (x: x <= 0) [ 1 2 3 ]");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, genList) {
+        auto v = eval("builtins.genList (x: x + 1) 3");
+        ASSERT_EQ(v.type(), nList);
+        ASSERT_EQ(v.listSize(), 3);
+        for (const auto [i, elem] : enumerate(v.listItems())) {
+            ASSERT_THAT(*elem, IsThunk());
+            state.forceValue(*elem, noPos);
+            ASSERT_THAT(*elem, IsIntEq(static_cast<int>(i)+1));
+        }
+    }
+
+    TEST_F(PrimOpTest, sortLessThan) {
+        auto v = eval("builtins.sort builtins.lessThan [ 483 249 526 147 42 77 ]");
+        ASSERT_EQ(v.type(), nList);
+        ASSERT_EQ(v.listSize(), 6);
+
+        const std::vector<int> numbers = { 42, 77, 147, 249, 483, 526 };
+        for (const auto [n, elem] : enumerate(v.listItems()))
+            ASSERT_THAT(*elem, IsIntEq(numbers[n]));
+    }
+
+    TEST_F(PrimOpTest, partition) {
+        auto v = eval("builtins.partition (x: x > 10) [1 23 9 3 42]");
+        ASSERT_THAT(v, IsAttrsOfSize(2));
+
+        auto right = v.attrs->get(createSymbol("right"));
+        ASSERT_NE(right, nullptr);
+        ASSERT_THAT(*right->value, IsListOfSize(2));
+        ASSERT_THAT(*right->value->listElems()[0], IsIntEq(23));
+        ASSERT_THAT(*right->value->listElems()[1], IsIntEq(42));
+
+        auto wrong = v.attrs->get(createSymbol("wrong"));
+        ASSERT_NE(wrong, nullptr);
+        ASSERT_EQ(wrong->value->type(), nList);
+        ASSERT_EQ(wrong->value->listSize(), 3);
+        ASSERT_THAT(*wrong->value, IsListOfSize(3));
+        ASSERT_THAT(*wrong->value->listElems()[0], IsIntEq(1));
+        ASSERT_THAT(*wrong->value->listElems()[1], IsIntEq(9));
+        ASSERT_THAT(*wrong->value->listElems()[2], IsIntEq(3));
+    }
+
+    TEST_F(PrimOpTest, concatMap) {
+        auto v = eval("builtins.concatMap (x: x ++ [0]) [ [1 2] [3 4] ]");
+        ASSERT_EQ(v.type(), nList);
+        ASSERT_EQ(v.listSize(), 6);
+
+        const std::vector<int> numbers = { 1, 2, 0, 3, 4, 0 };
+        for (const auto [n, elem] : enumerate(v.listItems()))
+            ASSERT_THAT(*elem, IsIntEq(numbers[n]));
+    }
+
+    TEST_F(PrimOpTest, addInt) {
+        auto v = eval("builtins.add 3 5");
+        ASSERT_THAT(v, IsIntEq(8));
+    }
+
+    TEST_F(PrimOpTest, addFloat) {
+        auto v = eval("builtins.add 3.0 5.0");
+        ASSERT_THAT(v, IsFloatEq(8.0));
+    }
+
+    TEST_F(PrimOpTest, addFloatToInt) {
+        auto v = eval("builtins.add 3.0 5");
+        ASSERT_THAT(v, IsFloatEq(8.0));
+
+        v = eval("builtins.add 3 5.0");
+        ASSERT_THAT(v, IsFloatEq(8.0));
+    }
+
+    TEST_F(PrimOpTest, subInt) {
+        auto v = eval("builtins.sub 5 2");
+        ASSERT_THAT(v, IsIntEq(3));
+    }
+
+    TEST_F(PrimOpTest, subFloat) {
+        auto v = eval("builtins.sub 5.0 2.0");
+        ASSERT_THAT(v, IsFloatEq(3.0));
+    }
+
+    TEST_F(PrimOpTest, subFloatFromInt) {
+        auto v = eval("builtins.sub 5.0 2");
+        ASSERT_THAT(v, IsFloatEq(3.0));
+
+        v = eval("builtins.sub 4 2.0");
+        ASSERT_THAT(v, IsFloatEq(2.0));
+    }
+
+    TEST_F(PrimOpTest, mulInt) {
+        auto v = eval("builtins.mul 3 5");
+        ASSERT_THAT(v, IsIntEq(15));
+    }
+
+    TEST_F(PrimOpTest, mulFloat) {
+        auto v = eval("builtins.mul 3.0 5.0");
+        ASSERT_THAT(v, IsFloatEq(15.0));
+    }
+
+    TEST_F(PrimOpTest, mulFloatMixed) {
+        auto v = eval("builtins.mul 3 5.0");
+        ASSERT_THAT(v, IsFloatEq(15.0));
+
+        v = eval("builtins.mul 2.0 5");
+        ASSERT_THAT(v, IsFloatEq(10.0));
+    }
+
+    TEST_F(PrimOpTest, divInt) {
+        auto v = eval("builtins.div 5 (-1)");
+        ASSERT_THAT(v, IsIntEq(-5));
+    }
+
+    TEST_F(PrimOpTest, divIntZero) {
+        ASSERT_THROW(eval("builtins.div 5 0"), EvalError);
+    }
+
+    TEST_F(PrimOpTest, divFloat) {
+        auto v = eval("builtins.div 5.0 (-1)");
+        ASSERT_THAT(v, IsFloatEq(-5.0));
+    }
+
+    TEST_F(PrimOpTest, divFloatZero) {
+        ASSERT_THROW(eval("builtins.div 5.0 0.0"), EvalError);
+    }
+
+    TEST_F(PrimOpTest, bitOr) {
+        auto v = eval("builtins.bitOr 1 2");
+        ASSERT_THAT(v, IsIntEq(3));
+    }
+
+    TEST_F(PrimOpTest, bitXor) {
+        auto v = eval("builtins.bitXor 3 2");
+        ASSERT_THAT(v, IsIntEq(1));
+    }
+
+    TEST_F(PrimOpTest, lessThanFalse) {
+        auto v = eval("builtins.lessThan 3 1");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(PrimOpTest, lessThanTrue) {
+        auto v = eval("builtins.lessThan 1 3");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(PrimOpTest, toStringAttrsThrows) {
+        ASSERT_THROW(eval("builtins.toString {}"), EvalError);
+    }
+
+    TEST_F(PrimOpTest, toStringLambdaThrows) {
+        ASSERT_THROW(eval("builtins.toString (x: x)"), EvalError);
+    }
+
+    class ToStringPrimOpTest :
+        public PrimOpTest,
+        public testing::WithParamInterface<std::tuple<std::string, std::string_view>>
+        {};
+
+    TEST_P(ToStringPrimOpTest, toString) {
+        const auto [input, output] = GetParam();
+        auto v = eval(input);
+        ASSERT_THAT(v, IsStringEq(output));
+    }
+
+#define CASE(input, output) (std::make_tuple(std::string_view("builtins.toString " #input), std::string_view(output)))
+    INSTANTIATE_TEST_SUITE_P(
+            toString,
+            ToStringPrimOpTest,
+            testing::Values(
+                CASE("foo", "foo"),
+                CASE(1, "1"),
+                CASE([1 2 3], "1 2 3"),
+                CASE(.123, "0.123000"),
+                CASE(true, "1"),
+                CASE(false, ""),
+                CASE(null, ""),
+                CASE({ v = "bar"; __toString = self: self.v; }, "bar"),
+                CASE({ v = "bar"; __toString = self: self.v; outPath = "foo"; }, "bar"),
+                CASE({ outPath = "foo"; }, "foo"),
+                CASE(./test, "/test")
+            )
+    );
+#undef CASE
+
+    TEST_F(PrimOpTest, substring){
+        auto v = eval("builtins.substring 0 3 \"nixos\"");
+        ASSERT_THAT(v, IsStringEq("nix"));
+    }
+
+    TEST_F(PrimOpTest, substringSmallerString){
+        auto v = eval("builtins.substring 0 3 \"n\"");
+        ASSERT_THAT(v, IsStringEq("n"));
+    }
+
+    TEST_F(PrimOpTest, substringEmptyString){
+        auto v = eval("builtins.substring 1 3 \"\"");
+        ASSERT_THAT(v, IsStringEq(""));
+    }
+
+    TEST_F(PrimOpTest, stringLength) {
+        auto v = eval("builtins.stringLength \"123\"");
+        ASSERT_THAT(v, IsIntEq(3));
+    }
+    TEST_F(PrimOpTest, hashStringMd5) {
+        auto v = eval("builtins.hashString \"md5\" \"asdf\"");
+        ASSERT_THAT(v, IsStringEq("912ec803b2ce49e4a541068d495ab570"));
+    }
+
+    TEST_F(PrimOpTest, hashStringSha1) {
+        auto v = eval("builtins.hashString \"sha1\" \"asdf\"");
+        ASSERT_THAT(v, IsStringEq("3da541559918a808c2402bba5012f6c60b27661c"));
+    }
+
+    TEST_F(PrimOpTest, hashStringSha256) {
+        auto v = eval("builtins.hashString \"sha256\" \"asdf\"");
+        ASSERT_THAT(v, IsStringEq("f0e4c2f76c58916ec258f246851bea091d14d4247a2fc3e18694461b1816e13b"));
+    }
+
+    TEST_F(PrimOpTest, hashStringSha512) {
+        auto v = eval("builtins.hashString \"sha512\" \"asdf\"");
+        ASSERT_THAT(v, IsStringEq("401b09eab3c013d4ca54922bb802bec8fd5318192b0a75f201d8b3727429080fb337591abd3e44453b954555b7a0812e1081c39b740293f765eae731f5a65ed1"));
+    }
+
+    TEST_F(PrimOpTest, hashStringInvalidHashType) {
+        ASSERT_THROW(eval("builtins.hashString \"foobar\" \"asdf\""), Error);
+    }
+
+    TEST_F(PrimOpTest, nixPath) {
+        auto v = eval("builtins.nixPath");
+        ASSERT_EQ(v.type(), nList);
+        // We can't test much more as currently the EvalSettings are a global
+        // that we can't easily swap / replace
+    }
+
+    TEST_F(PrimOpTest, langVersion) {
+        auto v = eval("builtins.langVersion");
+        ASSERT_EQ(v.type(), nInt);
+    }
+
+    TEST_F(PrimOpTest, storeDir) {
+        auto v = eval("builtins.storeDir");
+        ASSERT_THAT(v, IsStringEq("/nix/store"));
+    }
+
+    TEST_F(PrimOpTest, nixVersion) {
+        auto v = eval("builtins.nixVersion");
+        ASSERT_THAT(v, IsStringEq(nixVersion));
+    }
+
+    TEST_F(PrimOpTest, currentSystem) {
+        auto v = eval("builtins.currentSystem");
+        ASSERT_THAT(v, IsStringEq(settings.thisSystem.get()));
+    }
+
+    TEST_F(PrimOpTest, derivation) {
+        auto v = eval("derivation");
+        ASSERT_EQ(v.type(), nFunction);
+        ASSERT_TRUE(v.isLambda());
+        ASSERT_NE(v.lambda.fun, nullptr);
+        ASSERT_TRUE(v.lambda.fun->hasFormals());
+    }
+
+    TEST_F(PrimOpTest, currentTime) {
+        auto v = eval("builtins.currentTime");
+        ASSERT_EQ(v.type(), nInt);
+        ASSERT_TRUE(v.integer > 0);
+    }
+
+    TEST_F(PrimOpTest, splitVersion) {
+        auto v = eval("builtins.splitVersion \"1.2.3git\"");
+        ASSERT_THAT(v, IsListOfSize(4));
+
+        const std::vector<std::string_view> strings = { "1", "2", "3", "git" };
+        for (const auto [n, p] : enumerate(v.listItems()))
+            ASSERT_THAT(*p, IsStringEq(strings[n]));
+    }
+
+    class CompareVersionsPrimOpTest :
+        public PrimOpTest,
+        public testing::WithParamInterface<std::tuple<std::string, const int>>
+        {};
+
+    TEST_P(CompareVersionsPrimOpTest, compareVersions) {
+        auto [expression, expectation] = GetParam();
+        auto v = eval(expression);
+        ASSERT_THAT(v, IsIntEq(expectation));
+    }
+
+#define CASE(a, b, expected) (std::make_tuple("builtins.compareVersions \"" #a "\" \"" #b "\"", expected))
+    INSTANTIATE_TEST_SUITE_P(
+            compareVersions,
+            CompareVersionsPrimOpTest,
+            testing::Values(
+                // The first two are weird cases. Intuition tells they should
+                // be the same but they aren't.
+                CASE(1.0, 1.0.0, -1),
+                CASE(1.0.0, 1.0, 1),
+                // the following are from the nix-env manual:
+                CASE(1.0, 2.3, -1),
+                CASE(2.1, 2.3, -1),
+                CASE(2.3, 2.3, 0),
+                CASE(2.5, 2.3, 1),
+                CASE(3.1, 2.3, 1),
+                CASE(2.3.1, 2.3, 1),
+                CASE(2.3.1, 2.3a, 1),
+                CASE(2.3pre1, 2.3, -1),
+                CASE(2.3pre3, 2.3pre12, -1),
+                CASE(2.3a, 2.3c, -1),
+                CASE(2.3pre1, 2.3c, -1),
+                CASE(2.3pre1, 2.3q, -1)
+            )
+    );
+#undef CASE
+
+
+  class ParseDrvNamePrimOpTest :
+      public PrimOpTest,
+      public testing::WithParamInterface<std::tuple<std::string, std::string_view, std::string_view>>
+      {};
+
+    TEST_P(ParseDrvNamePrimOpTest, parseDrvName) {
+        auto [input, expectedName, expectedVersion] = GetParam();
+        const auto expr = fmt("builtins.parseDrvName \"%1%\"", input);
+        auto v = eval(expr);
+        ASSERT_THAT(v, IsAttrsOfSize(2));
+
+        auto name = v.attrs->find(createSymbol("name"));
+        ASSERT_TRUE(name);
+        ASSERT_THAT(*name->value, IsStringEq(expectedName));
+
+        auto version = v.attrs->find(createSymbol("version"));
+        ASSERT_TRUE(version);
+        ASSERT_THAT(*version->value, IsStringEq(expectedVersion));
+    }
+
+    INSTANTIATE_TEST_SUITE_P(
+            parseDrvName,
+            ParseDrvNamePrimOpTest,
+            testing::Values(
+                std::make_tuple("nix-0.12pre12876", "nix", "0.12pre12876"),
+                std::make_tuple("a-b-c-1234pre5+git", "a-b-c", "1234pre5+git")
+            )
+    );
+
+    TEST_F(PrimOpTest, replaceStrings) {
+        // FIXME: add a test that verifies the string context is as expected
+        auto v = eval("builtins.replaceStrings [\"oo\" \"a\"] [\"a\" \"i\"] \"foobar\"");
+        ASSERT_EQ(v.type(), nString);
+        ASSERT_EQ(v.string.s, std::string_view("fabir"));
+    }
+
+    TEST_F(PrimOpTest, concatStringsSep) {
+        // FIXME: add a test that verifies the string context is as expected
+        auto v = eval("builtins.concatStringsSep \"%\" [\"foo\" \"bar\" \"baz\"]");
+        ASSERT_EQ(v.type(), nString);
+        ASSERT_EQ(std::string_view(v.string.s), "foo%bar%baz");
+    }
+
+    TEST_F(PrimOpTest, split1) {
+        // v = [ "" [ "a" ] "c" ]
+        auto v = eval("builtins.split \"(a)b\" \"abc\"");
+        ASSERT_THAT(v, IsListOfSize(3));
+
+        ASSERT_THAT(*v.listElems()[0], IsStringEq(""));
+
+        ASSERT_THAT(*v.listElems()[1], IsListOfSize(1));
+        ASSERT_THAT(*v.listElems()[1]->listElems()[0], IsStringEq("a"));
+
+        ASSERT_THAT(*v.listElems()[2], IsStringEq("c"));
+    }
+
+    TEST_F(PrimOpTest, split2) {
+        // v is expected to be a list [ "" [ "a" ] "b" [ "c"] "" ]
+        auto v = eval("builtins.split \"([ac])\" \"abc\"");
+        ASSERT_THAT(v, IsListOfSize(5));
+
+        ASSERT_THAT(*v.listElems()[0], IsStringEq(""));
+
+        ASSERT_THAT(*v.listElems()[1], IsListOfSize(1));
+        ASSERT_THAT(*v.listElems()[1]->listElems()[0], IsStringEq("a"));
+
+        ASSERT_THAT(*v.listElems()[2], IsStringEq("b"));
+
+        ASSERT_THAT(*v.listElems()[3], IsListOfSize(1));
+        ASSERT_THAT(*v.listElems()[3]->listElems()[0], IsStringEq("c"));
+
+        ASSERT_THAT(*v.listElems()[4], IsStringEq(""));
+    }
+
+    TEST_F(PrimOpTest, split3) {
+        auto v = eval("builtins.split \"(a)|(c)\" \"abc\"");
+        ASSERT_THAT(v, IsListOfSize(5));
+
+        // First list element
+        ASSERT_THAT(*v.listElems()[0], IsStringEq(""));
+
+        // 2nd list element is a list [ "" null ]
+        ASSERT_THAT(*v.listElems()[1], IsListOfSize(2));
+        ASSERT_THAT(*v.listElems()[1]->listElems()[0], IsStringEq("a"));
+        ASSERT_THAT(*v.listElems()[1]->listElems()[1], IsNull());
+
+        // 3rd element
+        ASSERT_THAT(*v.listElems()[2], IsStringEq("b"));
+
+        // 4th element is a list: [ null "c" ]
+        ASSERT_THAT(*v.listElems()[3], IsListOfSize(2));
+        ASSERT_THAT(*v.listElems()[3]->listElems()[0], IsNull());
+        ASSERT_THAT(*v.listElems()[3]->listElems()[1], IsStringEq("c"));
+
+        // 5th element is the empty string
+        ASSERT_THAT(*v.listElems()[4], IsStringEq(""));
+    }
+
+    TEST_F(PrimOpTest, split4) {
+        auto v = eval("builtins.split \"([[:upper:]]+)\" \" FOO \"");
+        ASSERT_THAT(v, IsListOfSize(3));
+        auto first = v.listElems()[0];
+        auto second = v.listElems()[1];
+        auto third = v.listElems()[2];
+
+        ASSERT_THAT(*first, IsStringEq(" "));
+
+        ASSERT_THAT(*second, IsListOfSize(1));
+        ASSERT_THAT(*second->listElems()[0], IsStringEq("FOO"));
+
+        ASSERT_THAT(*third, IsStringEq(" "));
+    }
+
+    TEST_F(PrimOpTest, match1) {
+        auto v = eval("builtins.match \"ab\" \"abc\"");
+        ASSERT_THAT(v, IsNull());
+    }
+
+    TEST_F(PrimOpTest, match2) {
+        auto v = eval("builtins.match \"abc\" \"abc\"");
+        ASSERT_THAT(v, IsListOfSize(0));
+    }
+
+    TEST_F(PrimOpTest, match3) {
+        auto v = eval("builtins.match \"a(b)(c)\" \"abc\"");
+        ASSERT_THAT(v, IsListOfSize(2));
+        ASSERT_THAT(*v.listElems()[0], IsStringEq("b"));
+        ASSERT_THAT(*v.listElems()[1], IsStringEq("c"));
+    }
+
+    TEST_F(PrimOpTest, match4) {
+        auto v = eval("builtins.match \"[[:space:]]+([[:upper:]]+)[[:space:]]+\" \"  FOO   \"");
+        ASSERT_THAT(v, IsListOfSize(1));
+        ASSERT_THAT(*v.listElems()[0], IsStringEq("FOO"));
+    }
+
+    TEST_F(PrimOpTest, attrNames) {
+        auto v = eval("builtins.attrNames { x = 1; y = 2; z = 3; a = 2; }");
+        ASSERT_THAT(v, IsListOfSize(4));
+
+        // ensure that the list is sorted
+        const std::vector<std::string_view> expected { "a", "x", "y", "z" };
+        for (const auto [n, elem] : enumerate(v.listItems()))
+            ASSERT_THAT(*elem, IsStringEq(expected[n]));
+    }
+} /* namespace nix */
diff --git a/src/libexpr/tests/trivial.cc b/src/libexpr/tests/trivial.cc
new file mode 100644
index 000000000..8ce276e52
--- /dev/null
+++ b/src/libexpr/tests/trivial.cc
@@ -0,0 +1,196 @@
+#include "libexprtests.hh"
+
+namespace nix {
+    // Testing of trivial expressions
+    class TrivialExpressionTest : public LibExprTest {};
+
+    TEST_F(TrivialExpressionTest, true) {
+        auto v = eval("true");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(TrivialExpressionTest, false) {
+        auto v = eval("false");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(TrivialExpressionTest, null) {
+        auto v = eval("null");
+        ASSERT_THAT(v, IsNull());
+    }
+
+    TEST_F(TrivialExpressionTest, 1) {
+        auto v = eval("1");
+        ASSERT_THAT(v, IsIntEq(1));
+    }
+
+    TEST_F(TrivialExpressionTest, 1plus1) {
+        auto v = eval("1+1");
+        ASSERT_THAT(v, IsIntEq(2));
+    }
+
+    TEST_F(TrivialExpressionTest, minus1) {
+        auto v = eval("-1");
+        ASSERT_THAT(v, IsIntEq(-1));
+    }
+
+    TEST_F(TrivialExpressionTest, 1minus1) {
+        auto v = eval("1-1");
+        ASSERT_THAT(v, IsIntEq(0));
+    }
+
+    TEST_F(TrivialExpressionTest, lambdaAdd) {
+        auto v = eval("let add = a: b: a + b; in add 1 2");
+        ASSERT_THAT(v, IsIntEq(3));
+    }
+
+    TEST_F(TrivialExpressionTest, list) {
+        auto v = eval("[]");
+        ASSERT_THAT(v, IsListOfSize(0));
+    }
+
+    TEST_F(TrivialExpressionTest, attrs) {
+        auto v = eval("{}");
+        ASSERT_THAT(v, IsAttrsOfSize(0));
+    }
+
+    TEST_F(TrivialExpressionTest, float) {
+        auto v = eval("1.234");
+        ASSERT_THAT(v, IsFloatEq(1.234));
+    }
+
+    TEST_F(TrivialExpressionTest, updateAttrs) {
+        auto v = eval("{ a = 1; } // { b = 2; a = 3; }");
+        ASSERT_THAT(v, IsAttrsOfSize(2));
+        auto a = v.attrs->find(createSymbol("a"));
+        ASSERT_NE(a, nullptr);
+        ASSERT_THAT(*a->value, IsIntEq(3));
+
+        auto b = v.attrs->find(createSymbol("b"));
+        ASSERT_NE(b, nullptr);
+        ASSERT_THAT(*b->value, IsIntEq(2));
+    }
+
+    TEST_F(TrivialExpressionTest, hasAttrOpFalse) {
+        auto v = eval("{} ? a");
+        ASSERT_THAT(v, IsFalse());
+    }
+
+    TEST_F(TrivialExpressionTest, hasAttrOpTrue) {
+        auto v = eval("{ a = 123; } ? a");
+        ASSERT_THAT(v, IsTrue());
+    }
+
+    TEST_F(TrivialExpressionTest, withFound) {
+        auto v = eval("with { a = 23; }; a");
+        ASSERT_THAT(v, IsIntEq(23));
+    }
+
+    TEST_F(TrivialExpressionTest, withNotFound) {
+        ASSERT_THROW(eval("with {}; a"), Error);
+    }
+
+    TEST_F(TrivialExpressionTest, withOverride) {
+        auto v = eval("with { a = 23; }; with { a = 42; }; a");
+        ASSERT_THAT(v, IsIntEq(42));
+    }
+
+    TEST_F(TrivialExpressionTest, letOverWith) {
+        auto v = eval("let a = 23; in with { a = 1; }; a");
+        ASSERT_THAT(v, IsIntEq(23));
+    }
+
+    TEST_F(TrivialExpressionTest, multipleLet) {
+        auto v = eval("let a = 23; in let a = 42; in a");
+        ASSERT_THAT(v, IsIntEq(42));
+    }
+
+    TEST_F(TrivialExpressionTest, defaultFunctionArgs) {
+        auto v = eval("({ a ? 123 }: a) {}");
+        ASSERT_THAT(v, IsIntEq(123));
+    }
+
+    TEST_F(TrivialExpressionTest, defaultFunctionArgsOverride) {
+        auto v = eval("({ a ? 123 }: a) { a = 5; }");
+        ASSERT_THAT(v, IsIntEq(5));
+    }
+
+    TEST_F(TrivialExpressionTest, defaultFunctionArgsCaptureBack) {
+        auto v = eval("({ a ? 123 }@args: args) {}");
+        ASSERT_THAT(v, IsAttrsOfSize(0));
+    }
+
+    TEST_F(TrivialExpressionTest, defaultFunctionArgsCaptureFront) {
+        auto v = eval("(args@{ a ? 123 }: args) {}");
+        ASSERT_THAT(v, IsAttrsOfSize(0));
+    }
+
+    TEST_F(TrivialExpressionTest, assertThrows) {
+        ASSERT_THROW(eval("let x = arg: assert arg == 1; 123; in x 2"), Error);
+    }
+
+    TEST_F(TrivialExpressionTest, assertPassed) {
+        auto v = eval("let x = arg: assert arg == 1; 123; in x 1");
+        ASSERT_THAT(v, IsIntEq(123));
+    }
+
+    class AttrSetMergeTrvialExpressionTest :
+        public TrivialExpressionTest,
+        public testing::WithParamInterface<const char*>
+        {};
+
+    TEST_P(AttrSetMergeTrvialExpressionTest, attrsetMergeLazy) {
+        // Usually Nix rejects duplicate keys in an attrset but it does allow
+        // so if it is an attribute set that contains disjoint sets of keys.
+        // The below is equivalent to `{a.b = 1; a.c = 2; }`.
+        // The attribute set `a` will be a Thunk at first as the attribuets
+        // have to be merged (or otherwise computed) and that is done in a lazy
+        // manner.
+
+        auto expr = GetParam();
+        auto v = eval(expr);
+        ASSERT_THAT(v, IsAttrsOfSize(1));
+
+        auto a = v.attrs->find(createSymbol("a"));
+        ASSERT_NE(a, nullptr);
+
+        ASSERT_THAT(*a->value, IsThunk());
+        state.forceValue(*a->value, noPos);
+
+        ASSERT_THAT(*a->value, IsAttrsOfSize(2));
+
+        auto b = a->value->attrs->find(createSymbol("b"));
+        ASSERT_NE(b, nullptr);
+        ASSERT_THAT(*b->value, IsIntEq(1));
+
+        auto c = a->value->attrs->find(createSymbol("c"));
+        ASSERT_NE(c, nullptr);
+        ASSERT_THAT(*c->value, IsIntEq(2));
+    }
+
+    INSTANTIATE_TEST_SUITE_P(
+            attrsetMergeLazy,
+            AttrSetMergeTrvialExpressionTest,
+            testing::Values(
+                "{ a.b = 1; a.c = 2; }",
+                "{ a = { b = 1; }; a = { c = 2; }; }"
+            )
+    );
+
+    TEST_F(TrivialExpressionTest, functor) {
+        auto v = eval("{ __functor = self: arg: self.v + arg; v = 10; } 5");
+        ASSERT_THAT(v, IsIntEq(15));
+    }
+
+    TEST_F(TrivialExpressionTest, bindOr) {
+        auto v = eval("{ or = 1; }");
+        ASSERT_THAT(v, IsAttrsOfSize(1));
+        auto b = v.attrs->find(createSymbol("or"));
+        ASSERT_NE(b, nullptr);
+        ASSERT_THAT(*b->value, IsIntEq(1));
+    }
+
+    TEST_F(TrivialExpressionTest, orCantBeUsed) {
+        ASSERT_THROW(eval("let or = 1; in or"), Error);
+    }
+} /* namespace nix */
diff --git a/src/libexpr/value-to-json.cc b/src/libexpr/value-to-json.cc
index 7b35abca2..68235ad11 100644
--- a/src/libexpr/value-to-json.cc
+++ b/src/libexpr/value-to-json.cc
@@ -10,7 +10,7 @@
 namespace nix {
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const Pos & pos, JSONPlaceholder & out, PathSet & context)
+    Value & v, const PosIdx pos, JSONPlaceholder & out, PathSet & context)
 {
     checkInterrupt();
 
@@ -50,14 +50,14 @@ void printValueAsJSON(EvalState & state, bool strict,
                 auto obj(out.object());
                 StringSet names;
                 for (auto & j : *v.attrs)
-                    names.insert(j.name);
+                    names.emplace(state.symbols[j.name]);
                 for (auto & j : names) {
                     Attr & a(*v.attrs->find(state.symbols.create(j)));
                     auto placeholder(obj.placeholder(j));
-                    printValueAsJSON(state, strict, *a.value, *a.pos, placeholder, context);
+                    printValueAsJSON(state, strict, *a.value, a.pos, placeholder, context);
                 }
             } else
-                printValueAsJSON(state, strict, *i->value, *i->pos, out, context);
+                printValueAsJSON(state, strict, *i->value, i->pos, out, context);
             break;
         }
 
@@ -82,15 +82,15 @@ void printValueAsJSON(EvalState & state, bool strict,
         case nFunction:
             auto e = TypeError({
                 .msg = hintfmt("cannot convert %1% to JSON", showType(v)),
-                .errPos = v.determinePos(pos)
+                .errPos = state.positions[v.determinePos(pos)]
             });
-            e.addTrace(pos, hintfmt("message for the trace"));
+            e.addTrace(state.positions[pos], hintfmt("message for the trace"));
             throw e;
     }
 }
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const Pos & pos, std::ostream & str, PathSet & context)
+    Value & v, const PosIdx pos, std::ostream & str, PathSet & context)
 {
     JSONPlaceholder out(str);
     printValueAsJSON(state, strict, v, pos, out, context);
diff --git a/src/libexpr/value-to-json.hh b/src/libexpr/value-to-json.hh
index c2f797b29..c020a817a 100644
--- a/src/libexpr/value-to-json.hh
+++ b/src/libexpr/value-to-json.hh
@@ -11,9 +11,9 @@ namespace nix {
 class JSONPlaceholder;
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const Pos & pos, JSONPlaceholder & out, PathSet & context);
+    Value & v, const PosIdx pos, JSONPlaceholder & out, PathSet & context);
 
 void printValueAsJSON(EvalState & state, bool strict,
-    Value & v, const Pos & pos, std::ostream & str, PathSet & context);
+    Value & v, const PosIdx pos, std::ostream & str, PathSet & context);
 
 }
diff --git a/src/libexpr/value-to-xml.cc b/src/libexpr/value-to-xml.cc
index afeaf5694..7c3bf9492 100644
--- a/src/libexpr/value-to-xml.cc
+++ b/src/libexpr/value-to-xml.cc
@@ -19,10 +19,10 @@ static XMLAttrs singletonAttrs(const std::string & name, const std::string & val
 
 static void printValueAsXML(EvalState & state, bool strict, bool location,
     Value & v, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-    const Pos & pos);
+    const PosIdx pos);
 
 
-static void posToXML(XMLAttrs & xmlAttrs, const Pos & pos)
+static void posToXML(EvalState & state, XMLAttrs & xmlAttrs, const Pos & pos)
 {
     xmlAttrs["path"] = pos.file;
     xmlAttrs["line"] = (format("%1%") % pos.line).str();
@@ -36,25 +36,25 @@ static void showAttrs(EvalState & state, bool strict, bool location,
     StringSet names;
 
     for (auto & i : attrs)
-        names.insert(i.name);
+        names.emplace(state.symbols[i.name]);
 
     for (auto & i : names) {
         Attr & a(*attrs.find(state.symbols.create(i)));
 
         XMLAttrs xmlAttrs;
         xmlAttrs["name"] = i;
-        if (location && a.pos != ptr(&noPos)) posToXML(xmlAttrs, *a.pos);
+        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);
+            *a.value, doc, context, drvsSeen, a.pos);
     }
 }
 
 
 static void printValueAsXML(EvalState & state, bool strict, bool location,
     Value & v, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-    const Pos & pos)
+    const PosIdx pos)
 {
     checkInterrupt();
 
@@ -93,14 +93,14 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,
                 Path drvPath;
                 a = v.attrs->find(state.sDrvPath);
                 if (a != v.attrs->end()) {
-                    if (strict) state.forceValue(*a->value, *a->pos);
+                    if (strict) state.forceValue(*a->value, a->pos);
                     if (a->value->type() == nString)
                         xmlAttrs["drvPath"] = drvPath = a->value->string.s;
                 }
 
                 a = v.attrs->find(state.sOutPath);
                 if (a != v.attrs->end()) {
-                    if (strict) state.forceValue(*a->value, *a->pos);
+                    if (strict) state.forceValue(*a->value, a->pos);
                     if (a->value->type() == nString)
                         xmlAttrs["outPath"] = a->value->string.s;
                 }
@@ -134,18 +134,18 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,
                 break;
             }
             XMLAttrs xmlAttrs;
-            if (location) posToXML(xmlAttrs, v.lambda.fun->pos);
+            if (location) posToXML(state, xmlAttrs, state.positions[v.lambda.fun->pos]);
             XMLOpenElement _(doc, "function", xmlAttrs);
 
             if (v.lambda.fun->hasFormals()) {
                 XMLAttrs attrs;
-                if (!v.lambda.fun->arg.empty()) attrs["name"] = v.lambda.fun->arg;
+                if (v.lambda.fun->arg) attrs["name"] = state.symbols[v.lambda.fun->arg];
                 if (v.lambda.fun->formals->ellipsis) attrs["ellipsis"] = "1";
                 XMLOpenElement _(doc, "attrspat", attrs);
-                for (auto & i : v.lambda.fun->formals->lexicographicOrder())
-                    doc.writeEmptyElement("attr", singletonAttrs("name", i.name));
+                for (auto & i : v.lambda.fun->formals->lexicographicOrder(state.symbols))
+                    doc.writeEmptyElement("attr", singletonAttrs("name", state.symbols[i.name]));
             } else
-                doc.writeEmptyElement("varpat", singletonAttrs("name", v.lambda.fun->arg));
+                doc.writeEmptyElement("varpat", singletonAttrs("name", state.symbols[v.lambda.fun->arg]));
 
             break;
         }
@@ -166,14 +166,14 @@ static void printValueAsXML(EvalState & state, bool strict, bool location,
 
 void ExternalValueBase::printValueAsXML(EvalState & state, bool strict,
     bool location, XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-    const Pos & pos) const
+    const PosIdx pos) const
 {
     doc.writeEmptyElement("unevaluated");
 }
 
 
 void printValueAsXML(EvalState & state, bool strict, bool location,
-    Value & v, std::ostream & out, PathSet & context, const Pos & pos)
+    Value & v, std::ostream & out, PathSet & context, const PosIdx pos)
 {
     XMLWriter doc(true, out);
     XMLOpenElement root(doc, "expr");
diff --git a/src/libexpr/value-to-xml.hh b/src/libexpr/value-to-xml.hh
index cc778a2cb..506f32b6b 100644
--- a/src/libexpr/value-to-xml.hh
+++ b/src/libexpr/value-to-xml.hh
@@ -9,6 +9,6 @@
 namespace nix {
 
 void printValueAsXML(EvalState & state, bool strict, bool location,
-    Value & v, std::ostream & out, PathSet & context, const Pos & pos);
+    Value & v, std::ostream & out, PathSet & context, const PosIdx pos);
 
 }
diff --git a/src/libexpr/value.hh b/src/libexpr/value.hh
index 3d07c3198..58a8a56a0 100644
--- a/src/libexpr/value.hh
+++ b/src/libexpr/value.hh
@@ -56,6 +56,7 @@ struct Expr;
 struct ExprLambda;
 struct PrimOp;
 class Symbol;
+class PosIdx;
 struct Pos;
 class StorePath;
 class Store;
@@ -103,7 +104,7 @@ class ExternalValueBase
     /* Print the value as XML. Defaults to unevaluated */
     virtual void printValueAsXML(EvalState & state, bool strict, bool location,
         XMLWriter & doc, PathSet & context, PathSet & drvsSeen,
-        const Pos & pos) const;
+        const PosIdx pos) const;
 
     virtual ~ExternalValueBase()
     {
@@ -120,11 +121,11 @@ private:
 
     friend std::string showType(const Value & v);
 
-    void print(std::ostream & str, std::set<const void *> * seen) const;
+    void print(const SymbolTable & symbols, std::ostream & str, std::set<const void *> * seen) const;
 
 public:
 
-    void print(std::ostream & str, bool showRepeated = false) const;
+    void print(const SymbolTable & symbols, std::ostream & str, bool showRepeated = false) const;
 
     // Functions needed to distinguish the type
     // These should be removed eventually, by putting the functionality that's
@@ -250,11 +251,6 @@ public:
 
     void mkStringMove(const char * s, const PathSet & context);
 
-    inline void mkString(const Symbol & s)
-    {
-        mkString(((const std::string &) s).c_str());
-    }
-
     inline void mkPath(const char * s)
     {
         clearValue();
@@ -368,7 +364,7 @@ public:
         return internalType == tList1 ? 1 : internalType == tList2 ? 2 : bigList.size;
     }
 
-    Pos determinePos(const Pos & pos) const;
+    PosIdx determinePos(const PosIdx pos) const;
 
     /* Check whether forcing this value requires a trivial amount of
        computation. In particular, function applications are
diff --git a/src/libfetchers/git.cc b/src/libfetchers/git.cc
index 34b1342a0..d23a820a4 100644
--- a/src/libfetchers/git.cc
+++ b/src/libfetchers/git.cc
@@ -5,15 +5,20 @@
 #include "store-api.hh"
 #include "url-parts.hh"
 #include "pathlocks.hh"
+#include "util.hh"
+#include "git.hh"
 
 #include "fetch-settings.hh"
 
+#include <regex>
+#include <string.h>
 #include <sys/time.h>
 #include <sys/wait.h>
 
 using namespace std::string_literals;
 
 namespace nix::fetchers {
+namespace {
 
 // Explicit initial branch of our bare repo to suppress warnings from new version of git.
 // The value itself does not matter, since we always fetch a specific revision or branch.
@@ -21,16 +26,231 @@ namespace nix::fetchers {
 // old version of git, which will ignore unrecognized `-c` options.
 const std::string gitInitialBranch = "__nix_dummy_branch";
 
-static std::string readHead(const Path & path)
+std::string getGitDir()
 {
-    return chomp(runProgram("git", true, { "-C", path, "rev-parse", "--abbrev-ref", "HEAD" }));
+    return getEnv("GIT_DIR").value_or(".git");
 }
 
-static bool isNotDotGitDirectory(const Path & path)
+bool isCacheFileWithinTtl(const time_t now, const struct stat & st)
+{
+    return st.st_mtime + settings.tarballTtl > now;
+}
+
+bool touchCacheFile(const Path& path, const time_t& touch_time)
+{
+  struct timeval times[2];
+  times[0].tv_sec = touch_time;
+  times[0].tv_usec = 0;
+  times[1].tv_sec = touch_time;
+  times[1].tv_usec = 0;
+
+  return lutimes(path.c_str(), times) == 0;
+}
+
+Path getCachePath(std::string key)
+{
+    return getCacheDir() + "/nix/gitv3/" +
+        hashString(htSHA256, key).to_string(Base32, false);
+}
+
+// Returns the name of the HEAD branch.
+//
+// Returns the head branch name as reported by git ls-remote --symref, e.g., if
+// ls-remote returns the output below, "main" is returned based on the ref line.
+//
+//   ref: refs/heads/main       HEAD
+//   ...
+std::optional<std::string> readHead(const Path & path)
+{
+    auto [exit_code, output] = runProgram(RunOptions {
+        .program = "git",
+        .args = {"ls-remote", "--symref", path},
+    });
+    if (exit_code != 0) {
+        return std::nullopt;
+    }
+
+    std::string_view line = output;
+    line = line.substr(0, line.find("\n"));
+    if (const auto parseResult = git::parseLsRemoteLine(line)) {
+        switch (parseResult->kind) {
+            case git::LsRemoteRefLine::Kind::Symbolic:
+                debug("resolved HEAD ref '%s' for repo '%s'", parseResult->target, path);
+                break;
+            case git::LsRemoteRefLine::Kind::Object:
+                debug("resolved HEAD rev '%s' for repo '%s'", parseResult->target, path);
+                break;
+        }
+        return parseResult->target;
+    }
+    return std::nullopt;
+}
+
+// Persist the HEAD ref from the remote repo in the local cached repo.
+bool storeCachedHead(const std::string& actualUrl, const std::string& headRef)
+{
+    Path cacheDir = getCachePath(actualUrl);
+    try {
+        runProgram("git", true, { "-C", cacheDir, "symbolic-ref", "--", "HEAD", headRef });
+    } catch (ExecError &e) {
+        if (!WIFEXITED(e.status)) throw;
+        return false;
+    }
+    /* No need to touch refs/HEAD, because `git symbolic-ref` updates the mtime. */
+    return true;
+}
+
+std::optional<std::string> readHeadCached(const std::string& actualUrl)
+{
+    // Create a cache path to store the branch of the HEAD ref. Append something
+    // in front of the URL to prevent collision with the repository itself.
+    Path cacheDir = getCachePath(actualUrl);
+    Path headRefFile = cacheDir + "/HEAD";
+
+    time_t now = time(0);
+    struct stat st;
+    std::optional<std::string> cachedRef;
+    if (stat(headRefFile.c_str(), &st) == 0) {
+        cachedRef = readHead(cacheDir);
+        if (cachedRef != std::nullopt &&
+            *cachedRef != gitInitialBranch &&
+            isCacheFileWithinTtl(now, st)) {
+            debug("using cached HEAD ref '%s' for repo '%s'", *cachedRef, actualUrl);
+            return cachedRef;
+        }
+    }
+
+    auto ref = readHead(actualUrl);
+    if (ref) {
+        return ref;
+    }
+
+    if (cachedRef) {
+        // If the cached git ref is expired in fetch() below, and the 'git fetch'
+        // fails, it falls back to continuing with the most recent version.
+        // This function must behave the same way, so we return the expired
+        // cached ref here.
+        warn("could not get HEAD ref for repository '%s'; using expired cached ref '%s'", actualUrl, *cachedRef);
+        return *cachedRef;
+    }
+
+    return std::nullopt;
+}
+
+bool isNotDotGitDirectory(const Path & path)
 {
     return baseNameOf(path) != ".git";
 }
 
+struct WorkdirInfo
+{
+    bool clean = false;
+    bool hasHead = false;
+};
+
+// Returns whether a git workdir is clean and has commits.
+WorkdirInfo getWorkdirInfo(const Input & input, const Path & workdir)
+{
+    const bool submodules = maybeGetBoolAttr(input.attrs, "submodules").value_or(false);
+    auto gitDir = getGitDir();
+
+    auto env = getEnv();
+    // Set LC_ALL to C: because we rely on the error messages from git rev-parse to determine what went wrong
+    // that way unknown errors can lead to a failure instead of continuing through the wrong code path
+    env["LC_ALL"] = "C";
+
+    /* Check whether HEAD points to something that looks like a commit,
+       since that is the refrence we want to use later on. */
+    auto result = runProgram(RunOptions {
+        .program = "git",
+        .args = { "-C", workdir, "--git-dir", gitDir, "rev-parse", "--verify", "--no-revs", "HEAD^{commit}" },
+        .environment = env,
+        .mergeStderrToStdout = true
+    });
+    auto exitCode = WEXITSTATUS(result.first);
+    auto errorMessage = result.second;
+
+    if (errorMessage.find("fatal: not a git repository") != std::string::npos) {
+        throw Error("'%s' is not a Git repository", workdir);
+    } else if (errorMessage.find("fatal: Needed a single revision") != std::string::npos) {
+        // indicates that the repo does not have any commits
+        // we want to proceed and will consider it dirty later
+    } else if (exitCode != 0) {
+        // any other errors should lead to a failure
+        throw Error("getting the HEAD of the Git tree '%s' failed with exit code %d:\n%s", workdir, exitCode, errorMessage);
+    }
+
+    bool clean = false;
+    bool hasHead = exitCode == 0;
+
+    try {
+        if (hasHead) {
+            // Using git diff is preferrable over lower-level operations here,
+            // because its conceptually simpler and we only need the exit code anyways.
+            auto gitDiffOpts = Strings({ "-C", workdir, "diff", "HEAD", "--quiet"});
+            if (!submodules) {
+                // Changes in submodules should only make the tree dirty
+                // when those submodules will be copied as well.
+                gitDiffOpts.emplace_back("--ignore-submodules");
+            }
+            gitDiffOpts.emplace_back("--");
+            runProgram("git", true, gitDiffOpts);
+
+            clean = true;
+        }
+    } catch (ExecError & e) {
+        if (!WIFEXITED(e.status) || WEXITSTATUS(e.status) != 1) throw;
+    }
+
+    return WorkdirInfo { .clean = clean, .hasHead = hasHead };
+}
+
+std::pair<StorePath, Input> fetchFromWorkdir(ref<Store> store, Input & input, const Path & workdir, const WorkdirInfo & workdirInfo)
+{
+    const bool submodules = maybeGetBoolAttr(input.attrs, "submodules").value_or(false);
+
+    if (!fetchSettings.allowDirty)
+        throw Error("Git tree '%s' is dirty", workdir);
+
+    if (fetchSettings.warnDirty)
+        warn("Git tree '%s' is dirty", workdir);
+
+    auto gitOpts = Strings({ "-C", workdir, "ls-files", "-z" });
+    if (submodules)
+        gitOpts.emplace_back("--recurse-submodules");
+
+    auto files = tokenizeString<std::set<std::string>>(
+        runProgram("git", true, gitOpts), "\0"s);
+
+    Path actualPath(absPath(workdir));
+
+    PathFilter filter = [&](const Path & p) -> bool {
+        assert(hasPrefix(p, actualPath));
+        std::string file(p, actualPath.size() + 1);
+
+        auto st = lstat(p);
+
+        if (S_ISDIR(st.st_mode)) {
+            auto prefix = file + "/";
+            auto i = files.lower_bound(prefix);
+            return i != files.end() && hasPrefix(*i, prefix);
+        }
+
+        return files.count(file);
+    };
+
+    auto storePath = store->addToStore(input.getName(), actualPath, FileIngestionMethod::Recursive, htSHA256, filter);
+
+    // FIXME: maybe we should use the timestamp of the last
+    // modified dirty file?
+    input.attrs.insert_or_assign(
+        "lastModified",
+        workdirInfo.hasHead ? std::stoull(runProgram("git", true, { "-C", actualPath, "log", "-1", "--format=%ct", "--no-show-signature", "HEAD" })) : 0);
+
+    return {std::move(storePath), input};
+}
+}  // end namespace
+
 struct GitInputScheme : InputScheme
 {
     std::optional<Input> inputFromURL(const ParsedURL & url) override
@@ -150,13 +370,14 @@ struct GitInputScheme : InputScheme
     {
         auto sourcePath = getSourcePath(input);
         assert(sourcePath);
+        auto gitDir = getGitDir();
 
         runProgram("git", true,
-            { "-C", *sourcePath, "add", "--force", "--intent-to-add", "--", std::string(file) });
+            { "-C", *sourcePath, "--git-dir", gitDir, "add", "--force", "--intent-to-add", "--", std::string(file) });
 
         if (commitMsg)
             runProgram("git", true,
-                { "-C", *sourcePath, "commit", std::string(file), "-m", *commitMsg });
+                { "-C", *sourcePath, "--git-dir", gitDir, "commit", std::string(file), "-m", *commitMsg });
     }
 
     std::pair<bool, std::string> getActualUrl(const Input & input) const
@@ -175,6 +396,7 @@ struct GitInputScheme : InputScheme
     std::pair<StorePath, Input> fetch(ref<Store> store, const Input & _input) override
     {
         Input input(_input);
+        auto gitDir = getGitDir();
 
         std::string name = input.getName();
 
@@ -223,106 +445,16 @@ struct GitInputScheme : InputScheme
         auto [isLocal, actualUrl_] = getActualUrl(input);
         auto actualUrl = actualUrl_; // work around clang bug
 
-        // If this is a local directory and no ref or revision is
-        // given, then allow the use of an unclean working tree.
+        /* If this is a local directory and no ref or revision is given,
+           allow fetching directly from a dirty workdir. */
         if (!input.getRef() && !input.getRev() && isLocal) {
-            bool clean = false;
-
-            auto env = getEnv();
-            // Set LC_ALL to C: because we rely on the error messages from git rev-parse to determine what went wrong
-            // that way unknown errors can lead to a failure instead of continuing through the wrong code path
-            env["LC_ALL"] = "C";
-
-            /* Check whether HEAD points to something that looks like a commit,
-               since that is the refrence we want to use later on. */
-            auto result = runProgram(RunOptions {
-                .program = "git",
-                .args = { "-C", actualUrl, "--git-dir=.git", "rev-parse", "--verify", "--no-revs", "HEAD^{commit}" },
-                .environment = env,
-                .mergeStderrToStdout = true
-            });
-            auto exitCode = WEXITSTATUS(result.first);
-            auto errorMessage = result.second;
-
-            if (errorMessage.find("fatal: not a git repository") != std::string::npos) {
-                throw Error("'%s' is not a Git repository", actualUrl);
-            } else if (errorMessage.find("fatal: Needed a single revision") != std::string::npos) {
-                // indicates that the repo does not have any commits
-                // we want to proceed and will consider it dirty later
-            } else if (exitCode != 0) {
-                // any other errors should lead to a failure
-                throw Error("getting the HEAD of the Git tree '%s' failed with exit code %d:\n%s", actualUrl, exitCode, errorMessage);
-            }
-
-            bool hasHead = exitCode == 0;
-            try {
-                if (hasHead) {
-                    // Using git diff is preferrable over lower-level operations here,
-                    // because its conceptually simpler and we only need the exit code anyways.
-                    auto gitDiffOpts = Strings({ "-C", actualUrl, "diff", "HEAD", "--quiet"});
-                    if (!submodules) {
-                        // Changes in submodules should only make the tree dirty
-                        // when those submodules will be copied as well.
-                        gitDiffOpts.emplace_back("--ignore-submodules");
-                    }
-                    gitDiffOpts.emplace_back("--");
-                    runProgram("git", true, gitDiffOpts);
-
-                    clean = true;
-                }
-            } catch (ExecError & e) {
-                if (!WIFEXITED(e.status) || WEXITSTATUS(e.status) != 1) throw;
-            }
-
-            if (!clean) {
-
-                /* This is an unclean working tree. So copy all tracked files. */
-
-                if (!fetchSettings.allowDirty)
-                    throw Error("Git tree '%s' is dirty", actualUrl);
-
-                if (fetchSettings.warnDirty)
-                    warn("Git tree '%s' is dirty", actualUrl);
-
-                auto gitOpts = Strings({ "-C", actualUrl, "ls-files", "-z" });
-                if (submodules)
-                    gitOpts.emplace_back("--recurse-submodules");
-
-                auto files = tokenizeString<std::set<std::string>>(
-                    runProgram("git", true, gitOpts), "\0"s);
-
-                Path actualPath(absPath(actualUrl));
-
-                PathFilter filter = [&](const Path & p) -> bool {
-                    assert(hasPrefix(p, actualPath));
-                    std::string file(p, actualPath.size() + 1);
-
-                    auto st = lstat(p);
-
-                    if (S_ISDIR(st.st_mode)) {
-                        auto prefix = file + "/";
-                        auto i = files.lower_bound(prefix);
-                        return i != files.end() && hasPrefix(*i, prefix);
-                    }
-
-                    return files.count(file);
-                };
-
-                auto storePath = store->addToStore(input.getName(), actualPath, FileIngestionMethod::Recursive, htSHA256, filter);
-
-                // FIXME: maybe we should use the timestamp of the last
-                // modified dirty file?
-                input.attrs.insert_or_assign(
-                    "lastModified",
-                    hasHead ? std::stoull(runProgram("git", true, { "-C", actualPath, "log", "-1", "--format=%ct", "--no-show-signature", "HEAD" })) : 0);
-
-                return {std::move(storePath), input};
+            auto workdirInfo = getWorkdirInfo(input, actualUrl);
+            if (!workdirInfo.clean) {
+                return fetchFromWorkdir(store, input, actualUrl, workdirInfo);
             }
         }
 
-        if (!input.getRef()) input.attrs.insert_or_assign("ref", isLocal ? readHead(actualUrl) : "master");
-
-        Attrs unlockedAttrs({
+        const Attrs unlockedAttrs({
             {"type", cacheType},
             {"name", name},
             {"url", actualUrl},
@@ -332,14 +464,30 @@ struct GitInputScheme : InputScheme
         Path repoDir;
 
         if (isLocal) {
+            if (!input.getRef()) {
+                auto head = readHead(actualUrl);
+                if (!head) {
+                    warn("could not read HEAD ref from repo at '%s', using 'master'", actualUrl);
+                    head = "master";
+                }
+                input.attrs.insert_or_assign("ref", *head);
+            }
 
             if (!input.getRev())
                 input.attrs.insert_or_assign("rev",
-                    Hash::parseAny(chomp(runProgram("git", true, { "-C", actualUrl, "rev-parse", *input.getRef() })), htSHA1).gitRev());
+                    Hash::parseAny(chomp(runProgram("git", true, { "-C", actualUrl, "--git-dir", gitDir, "rev-parse", *input.getRef() })), htSHA1).gitRev());
 
             repoDir = actualUrl;
-
         } else {
+            const bool useHeadRef = !input.getRef();
+            if (useHeadRef) {
+                auto head = readHeadCached(actualUrl);
+                if (!head) {
+                    warn("could not read HEAD ref from repo at '%s', using 'master'", actualUrl);
+                    head = "master";
+                }
+                input.attrs.insert_or_assign("ref", *head);
+            }
 
             if (auto res = getCache()->lookup(store, unlockedAttrs)) {
                 auto rev2 = Hash::parseAny(getStrAttr(res->first, "rev"), htSHA1);
@@ -349,8 +497,9 @@ struct GitInputScheme : InputScheme
                 }
             }
 
-            Path cacheDir = getCacheDir() + "/nix/gitv3/" + hashString(htSHA256, actualUrl).to_string(Base32, false);
+            Path cacheDir = getCachePath(actualUrl);
             repoDir = cacheDir;
+            gitDir = ".";
 
             createDirs(dirOf(cacheDir));
             PathLocks cacheDirLock({cacheDir + ".lock"});
@@ -371,7 +520,7 @@ struct GitInputScheme : InputScheme
                repo. */
             if (input.getRev()) {
                 try {
-                    runProgram("git", true, { "-C", repoDir, "cat-file", "-e", input.getRev()->gitRev() });
+                    runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "cat-file", "-e", input.getRev()->gitRev() });
                     doFetch = false;
                 } catch (ExecError & e) {
                     if (WIFEXITED(e.status)) {
@@ -388,7 +537,7 @@ struct GitInputScheme : InputScheme
                        git fetch to update the local ref to the remote ref. */
                     struct stat st;
                     doFetch = stat(localRefFile.c_str(), &st) != 0 ||
-                        (uint64_t) st.st_mtime + settings.tarballTtl <= (uint64_t) now;
+                        !isCacheFileWithinTtl(now, st);
                 }
             }
 
@@ -406,19 +555,16 @@ struct GitInputScheme : InputScheme
                             : ref == "HEAD"
                                 ? *ref
                                 : "refs/heads/" + *ref;
-                    runProgram("git", true, { "-C", repoDir, "fetch", "--quiet", "--force", "--", actualUrl, fmt("%s:%s", fetchRef, fetchRef) });
+                    runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "fetch", "--quiet", "--force", "--", actualUrl, fmt("%s:%s", fetchRef, fetchRef) });
                 } catch (Error & e) {
                     if (!pathExists(localRefFile)) throw;
                     warn("could not update local clone of Git repository '%s'; continuing with the most recent version", actualUrl);
                 }
 
-                struct timeval times[2];
-                times[0].tv_sec = now;
-                times[0].tv_usec = 0;
-                times[1].tv_sec = now;
-                times[1].tv_usec = 0;
-
-                utimes(localRefFile.c_str(), times);
+                if (!touchCacheFile(localRefFile, now))
+                    warn("could not update mtime for file '%s': %s", localRefFile, strerror(errno));
+                if (useHeadRef && !storeCachedHead(actualUrl, *input.getRef()))
+                    warn("could not update cached head '%s' for '%s'", *input.getRef(), actualUrl);
             }
 
             if (!input.getRev())
@@ -427,7 +573,7 @@ struct GitInputScheme : InputScheme
             // cache dir lock is removed at scope end; we will only use read-only operations on specific revisions in the remainder
         }
 
-        bool isShallow = chomp(runProgram("git", true, { "-C", repoDir, "rev-parse", "--is-shallow-repository" })) == "true";
+        bool isShallow = chomp(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "rev-parse", "--is-shallow-repository" })) == "true";
 
         if (isShallow && !shallow)
             throw Error("'%s' is a shallow Git repository, but a non-shallow repository is needed", actualUrl);
@@ -447,7 +593,7 @@ struct GitInputScheme : InputScheme
 
         auto result = runProgram(RunOptions {
             .program = "git",
-            .args = { "-C", repoDir, "cat-file", "commit", input.getRev()->gitRev() },
+            .args = { "-C", repoDir, "--git-dir", gitDir, "cat-file", "commit", input.getRev()->gitRev() },
             .mergeStderrToStdout = true
         });
         if (WEXITSTATUS(result.first) == 128
@@ -486,7 +632,7 @@ struct GitInputScheme : InputScheme
             auto source = sinkToSource([&](Sink & sink) {
                 runProgram2({
                     .program = "git",
-                    .args = { "-C", repoDir, "archive", input.getRev()->gitRev() },
+                    .args = { "-C", repoDir, "--git-dir", gitDir, "archive", input.getRev()->gitRev() },
                     .standardOut = &sink
                 });
             });
@@ -496,7 +642,7 @@ struct GitInputScheme : InputScheme
 
         auto storePath = store->addToStore(name, tmpDir, FileIngestionMethod::Recursive, htSHA256, filter);
 
-        auto lastModified = std::stoull(runProgram("git", true, { "-C", repoDir, "log", "-1", "--format=%ct", "--no-show-signature", input.getRev()->gitRev() }));
+        auto lastModified = std::stoull(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "log", "-1", "--format=%ct", "--no-show-signature", input.getRev()->gitRev() }));
 
         Attrs infoAttrs({
             {"rev", input.getRev()->gitRev()},
@@ -505,7 +651,7 @@ struct GitInputScheme : InputScheme
 
         if (!shallow)
             infoAttrs.insert_or_assign("revCount",
-                std::stoull(runProgram("git", true, { "-C", repoDir, "rev-list", "--count", input.getRev()->gitRev() })));
+                std::stoull(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "rev-list", "--count", input.getRev()->gitRev() })));
 
         if (!_input.getRev())
             getCache()->add(
diff --git a/src/libfetchers/github.cc b/src/libfetchers/github.cc
index 58b6e7c04..0631fb6e8 100644
--- a/src/libfetchers/github.cc
+++ b/src/libfetchers/github.cc
@@ -4,7 +4,7 @@
 #include "store-api.hh"
 #include "types.hh"
 #include "url-parts.hh"
-
+#include "git.hh"
 #include "fetchers.hh"
 #include "fetch-settings.hh"
 
@@ -243,7 +243,10 @@ struct GitHubInputScheme : GitArchiveInputScheme
     Hash getRevFromRef(nix::ref<Store> store, const Input & input) const override
     {
         auto host = maybeGetStrAttr(input.attrs, "host").value_or("github.com");
-        auto url = fmt("https://api.%s/repos/%s/%s/commits/%s", // FIXME: check
+        auto url = fmt(
+            host == "github.com"
+            ? "https://api.%s/repos/%s/%s/commits/%s"
+            : "https://%s/api/v3/repos/%s/%s/commits/%s",
             host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo"), *input.getRef());
 
         Headers headers = makeHeadersWithAuthTokens(host);
@@ -262,7 +265,10 @@ struct GitHubInputScheme : GitArchiveInputScheme
         // FIXME: use regular /archive URLs instead? api.github.com
         // might have stricter rate limits.
         auto host = maybeGetStrAttr(input.attrs, "host").value_or("github.com");
-        auto url = fmt("https://api.%s/repos/%s/%s/tarball/%s", // FIXME: check if this is correct for self hosted instances
+        auto url = fmt(
+            host == "github.com"
+            ? "https://api.%s/repos/%s/%s/tarball/%s"
+            : "https://%s/api/v3/repos/%s/%s/tarball/%s",
             host, getStrAttr(input.attrs, "owner"), getStrAttr(input.attrs, "repo"),
             input.getRev()->to_string(Base16, false));
 
@@ -383,35 +389,31 @@ struct SourceHutInputScheme : GitArchiveInputScheme
             std::string line;
             getline(is, line);
 
-            auto ref_index = line.find("ref: ");
-            if (ref_index == std::string::npos) {
+            auto remoteLine = git::parseLsRemoteLine(line);
+            if (!remoteLine) {
                 throw BadURL("in '%d', couldn't resolve HEAD ref '%d'", input.to_string(), ref);
             }
-
-            ref_uri = line.substr(ref_index+5, line.length()-1);
-        } else
+            ref_uri = remoteLine->target;
+        } else {
             ref_uri = fmt("refs/(heads|tags)/%s", ref);
+        }
 
         auto file = store->toRealPath(
             downloadFile(store, fmt("%s/info/refs", base_url), "source", false, headers).storePath);
         std::ifstream is(file);
 
         std::string line;
-        std::string id;
-        while(getline(is, line)) {
-            // Append $ to avoid partial name matches
-            std::regex pattern(fmt("%s$", ref_uri));
-
-            if (std::regex_search(line, pattern)) {
-                id = line.substr(0, line.find('\t'));
-                break;
-            }
+        std::optional<std::string> id;
+        while(!id && getline(is, line)) {
+            auto parsedLine = git::parseLsRemoteLine(line);
+            if (parsedLine && parsedLine->reference == ref_uri)
+                id = parsedLine->target;
         }
 
-        if(id.empty())
+        if(!id)
             throw BadURL("in '%d', couldn't find ref '%d'", input.to_string(), ref);
 
-        auto rev = Hash::parseAny(id, htSHA1);
+        auto rev = Hash::parseAny(*id, htSHA1);
         debug("HEAD revision for '%s' is %s", fmt("%s/%s", base_url, ref), rev.gitRev());
         return rev;
     }
diff --git a/src/libfetchers/mercurial.cc b/src/libfetchers/mercurial.cc
index 1beb8b944..5c5671681 100644
--- a/src/libfetchers/mercurial.cc
+++ b/src/libfetchers/mercurial.cc
@@ -36,7 +36,7 @@ static std::string runHg(const Strings & args, const std::optional<std::string>
     auto res = runProgram(std::move(opts));
 
     if (!statusOk(res.first))
-        throw ExecError(res.first, fmt("hg %1%", statusToString(res.first)));
+        throw ExecError(res.first, "hg %1%", statusToString(res.first));
 
     return res.second;
 }
@@ -273,7 +273,7 @@ struct MercurialInputScheme : InputScheme
                         runHg({ "recover", "-R", cacheDir });
                         runHg({ "pull", "-R", cacheDir, "--", actualUrl });
                     } else {
-                        throw ExecError(e.status, fmt("'hg pull' %s", statusToString(e.status)));
+                        throw ExecError(e.status, "'hg pull' %s", statusToString(e.status));
                     }
                 }
             } else {
diff --git a/src/libmain/shared.cc b/src/libmain/shared.cc
index 562d1b414..31454e49d 100644
--- a/src/libmain/shared.cc
+++ b/src/libmain/shared.cc
@@ -60,37 +60,37 @@ void printMissing(ref<Store> store, const StorePathSet & willBuild,
 {
     if (!willBuild.empty()) {
         if (willBuild.size() == 1)
-            printMsg(lvl, fmt("this derivation will be built:"));
+            printMsg(lvl, "this derivation will be built:");
         else
-            printMsg(lvl, fmt("these %d derivations will be built:", willBuild.size()));
+            printMsg(lvl, "these %d derivations will be built:", willBuild.size());
         auto sorted = store->topoSortPaths(willBuild);
         reverse(sorted.begin(), sorted.end());
         for (auto & i : sorted)
-            printMsg(lvl, fmt("  %s", store->printStorePath(i)));
+            printMsg(lvl, "  %s", store->printStorePath(i));
     }
 
     if (!willSubstitute.empty()) {
         const float downloadSizeMiB = downloadSize / (1024.f * 1024.f);
         const float narSizeMiB = narSize / (1024.f * 1024.f);
         if (willSubstitute.size() == 1) {
-            printMsg(lvl, fmt("this path will be fetched (%.2f MiB download, %.2f MiB unpacked):",
+            printMsg(lvl, "this path will be fetched (%.2f MiB download, %.2f MiB unpacked):",
                 downloadSizeMiB,
-                narSizeMiB));
+                narSizeMiB);
         } else {
-            printMsg(lvl, fmt("these %d paths will be fetched (%.2f MiB download, %.2f MiB unpacked):",
+            printMsg(lvl, "these %d paths will be fetched (%.2f MiB download, %.2f MiB unpacked):",
                 willSubstitute.size(),
                 downloadSizeMiB,
-                narSizeMiB));
+                narSizeMiB);
         }
         for (auto & i : willSubstitute)
-            printMsg(lvl, fmt("  %s", store->printStorePath(i)));
+            printMsg(lvl, "  %s", store->printStorePath(i));
     }
 
     if (!unknown.empty()) {
-        printMsg(lvl, fmt("don't know how to build these paths%s:",
-                (settings.readOnlyMode ? " (may be caused by read-only store access)" : "")));
+        printMsg(lvl, "don't know how to build these paths%s:",
+                (settings.readOnlyMode ? " (may be caused by read-only store access)" : ""));
         for (auto & i : unknown)
-            printMsg(lvl, fmt("  %s", store->printStorePath(i)));
+            printMsg(lvl, "  %s", store->printStorePath(i));
     }
 }
 
diff --git a/src/libstore/build/derivation-goal.cc b/src/libstore/build/derivation-goal.cc
index 53f212c1d..3fff2385f 100644
--- a/src/libstore/build/derivation-goal.cc
+++ b/src/libstore/build/derivation-goal.cc
@@ -786,8 +786,7 @@ void runPostBuildHook(
     Store & store,
     Logger & logger,
     const StorePath & drvPath,
-    StorePathSet outputPaths
-)
+    const StorePathSet & outputPaths)
 {
     auto hook = settings.postBuildHook;
     if (hook == "")
@@ -906,7 +905,7 @@ void DerivationGoal::buildDone()
         auto builtOutputs = registerOutputs();
 
         StorePathSet outputPaths;
-        for (auto & [_, output] : buildResult.builtOutputs)
+        for (auto & [_, output] : builtOutputs)
             outputPaths.insert(output.outPath);
         runPostBuildHook(
             worker.store,
@@ -985,21 +984,28 @@ void DerivationGoal::resolvedFinished()
             realWantedOutputs = resolvedDrv.outputNames();
 
         for (auto & wantedOutput : realWantedOutputs) {
-            assert(initialOutputs.count(wantedOutput) != 0);
-            assert(resolvedHashes.count(wantedOutput) != 0);
-            auto realisation = resolvedResult.builtOutputs.at(
-                DrvOutput { resolvedHashes.at(wantedOutput), wantedOutput });
+            auto initialOutput = get(initialOutputs, wantedOutput);
+            auto resolvedHash = get(resolvedHashes, wantedOutput);
+            if ((!initialOutput) || (!resolvedHash))
+                throw Error(
+                    "derivation '%s' doesn't have expected output '%s' (derivation-goal.cc/resolvedFinished,resolve)",
+                    worker.store.printStorePath(drvPath), wantedOutput);
+            auto realisation = get(resolvedResult.builtOutputs, DrvOutput { *resolvedHash, wantedOutput });
+            if (!realisation)
+                throw Error(
+                    "derivation '%s' doesn't have expected output '%s' (derivation-goal.cc/resolvedFinished,realisation)",
+                    worker.store.printStorePath(resolvedDrvGoal->drvPath), wantedOutput);
             if (drv->type().isPure()) {
-                auto newRealisation = realisation;
-                newRealisation.id = DrvOutput { initialOutputs.at(wantedOutput).outputHash, wantedOutput };
+                auto newRealisation = *realisation;
+                newRealisation.id = DrvOutput { initialOutput->outputHash, wantedOutput };
                 newRealisation.signatures.clear();
                 if (!drv->type().isFixed())
-                    newRealisation.dependentRealisations = drvOutputReferences(worker.store, *drv, realisation.outPath);
+                    newRealisation.dependentRealisations = drvOutputReferences(worker.store, *drv, realisation->outPath);
                 signRealisation(newRealisation);
                 worker.store.registerDrvOutput(newRealisation);
             }
-            outputPaths.insert(realisation.outPath);
-            builtOutputs.emplace(realisation.id, realisation);
+            outputPaths.insert(realisation->outPath);
+            builtOutputs.emplace(realisation->id, *realisation);
         }
 
         runPostBuildHook(
@@ -1295,7 +1301,11 @@ std::pair<bool, DrvOutputs> DerivationGoal::checkPathValidity()
     DrvOutputs validOutputs;
 
     for (auto & i : queryPartialDerivationOutputMap()) {
-        InitialOutput & info = initialOutputs.at(i.first);
+        auto initialOutput = get(initialOutputs, i.first);
+        if (!initialOutput)
+            // this is an invalid output, gets catched with (!wantedOutputsLeft.empty())
+            continue;
+        auto & info = *initialOutput;
         info.wanted = wantOutput(i.first, wantedOutputs);
         if (info.wanted)
             wantedOutputsLeft.erase(i.first);
@@ -1310,7 +1320,7 @@ std::pair<bool, DrvOutputs> DerivationGoal::checkPathValidity()
                     : PathStatus::Corrupt,
             };
         }
-        auto drvOutput = DrvOutput{initialOutputs.at(i.first).outputHash, i.first};
+        auto drvOutput = DrvOutput{info.outputHash, i.first};
         if (settings.isExperimentalFeatureEnabled(Xp::CaDerivations)) {
             if (auto real = worker.store.queryRealisation(drvOutput)) {
                 info.known = {
diff --git a/src/libstore/build/local-derivation-goal.cc b/src/libstore/build/local-derivation-goal.cc
index 4c91fa4fb..3ac9c20f9 100644
--- a/src/libstore/build/local-derivation-goal.cc
+++ b/src/libstore/build/local-derivation-goal.cc
@@ -14,6 +14,7 @@
 #include "worker-protocol.hh"
 #include "topo-sort.hh"
 #include "callback.hh"
+#include "json-utils.hh"
 
 #include <regex>
 #include <queue>
@@ -56,8 +57,6 @@
 #include <pwd.h>
 #include <grp.h>
 
-#include <nlohmann/json.hpp>
-
 namespace nix {
 
 void handleDiffHook(
@@ -482,7 +481,7 @@ void LocalDerivationGoal::startBuilder()
            temporary build directory.  The text files have the format used
            by `nix-store --register-validity'.  However, the deriver
            fields are left empty. */
-        auto s = get(drv->env, "exportReferencesGraph").value_or("");
+        auto s = getOr(drv->env, "exportReferencesGraph", "");
         Strings ss = tokenizeString<Strings>(s);
         if (ss.size() % 2 != 0)
             throw BuildError("odd number of tokens in 'exportReferencesGraph': '%1%'", s);
@@ -989,7 +988,7 @@ void LocalDerivationGoal::initTmpDir() {
        there is no size constraint). */
     if (!parsedDrv->getStructuredAttrs()) {
 
-        StringSet passAsFile = tokenizeString<StringSet>(get(drv->env, "passAsFile").value_or(""));
+        StringSet passAsFile = tokenizeString<StringSet>(getOr(drv->env, "passAsFile", ""));
         for (auto & i : drv->env) {
             if (passAsFile.find(i.first) == passAsFile.end()) {
                 env[i.first] = i.second;
@@ -2128,12 +2127,22 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
     std::map<std::string, std::variant<AlreadyRegistered, PerhapsNeedToRegister>> outputReferencesIfUnregistered;
     std::map<std::string, struct stat> outputStats;
     for (auto & [outputName, _] : drv->outputs) {
-        auto actualPath = toRealPathChroot(worker.store.printStorePath(scratchOutputs.at(outputName)));
+        auto scratchOutput = get(scratchOutputs, outputName);
+        if (!scratchOutput)
+            throw BuildError(
+                "builder for '%s' has no scratch output for '%s'",
+                worker.store.printStorePath(drvPath), outputName);
+        auto actualPath = toRealPathChroot(worker.store.printStorePath(*scratchOutput));
 
         outputsToSort.insert(outputName);
 
         /* Updated wanted info to remove the outputs we definitely don't need to register */
-        auto & initialInfo = initialOutputs.at(outputName);
+        auto initialOutput = get(initialOutputs, outputName);
+        if (!initialOutput)
+            throw BuildError(
+                "builder for '%s' has no initial output for '%s'",
+                worker.store.printStorePath(drvPath), outputName);
+        auto & initialInfo = *initialOutput;
 
         /* Don't register if already valid, and not checking */
         initialInfo.wanted = buildMode == bmCheck
@@ -2185,6 +2194,11 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
 
     auto sortedOutputNames = topoSort(outputsToSort,
         {[&](const std::string & name) {
+            auto orifu = get(outputReferencesIfUnregistered, name);
+            if (!orifu)
+                throw BuildError(
+                    "no output reference for '%s' in build of '%s'",
+                    name, worker.store.printStorePath(drvPath));
             return std::visit(overloaded {
                 /* Since we'll use the already installed versions of these, we
                    can treat them as leaves and ignore any references they
@@ -2199,7 +2213,7 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
                                 referencedOutputs.insert(o);
                     return referencedOutputs;
                 },
-            }, outputReferencesIfUnregistered.at(name));
+            }, *orifu);
         }},
         {[&](const std::string & path, const std::string & parent) {
             // TODO with more -vvvv also show the temporary paths for manual inspection.
@@ -2213,9 +2227,10 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
     OutputPathMap finalOutputs;
 
     for (auto & outputName : sortedOutputNames) {
-        auto output = drv->outputs.at(outputName);
-        auto & scratchPath = scratchOutputs.at(outputName);
-        auto actualPath = toRealPathChroot(worker.store.printStorePath(scratchPath));
+        auto output = get(drv->outputs, outputName);
+        auto scratchPath = get(scratchOutputs, outputName);
+        assert(output && scratchPath);
+        auto actualPath = toRealPathChroot(worker.store.printStorePath(*scratchPath));
 
         auto finish = [&](StorePath finalStorePath) {
             /* Store the final path */
@@ -2223,10 +2238,13 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
             /* The rewrite rule will be used in downstream outputs that refer to
                use. This is why the topological sort is essential to do first
                before this for loop. */
-            if (scratchPath != finalStorePath)
-                outputRewrites[std::string { scratchPath.hashPart() }] = std::string { finalStorePath.hashPart() };
+            if (*scratchPath != finalStorePath)
+                outputRewrites[std::string { scratchPath->hashPart() }] = std::string { finalStorePath.hashPart() };
         };
 
+        auto orifu = get(outputReferencesIfUnregistered, outputName);
+        assert(orifu);
+
         std::optional<StorePathSet> referencesOpt = std::visit(overloaded {
             [&](const AlreadyRegistered & skippedFinalPath) -> std::optional<StorePathSet> {
                 finish(skippedFinalPath.path);
@@ -2235,7 +2253,7 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
             [&](const PerhapsNeedToRegister & r) -> std::optional<StorePathSet> {
                 return r.refs;
             },
-        }, outputReferencesIfUnregistered.at(outputName));
+        }, *orifu);
 
         if (!referencesOpt)
             continue;
@@ -2268,25 +2286,29 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
             for (auto & r : references) {
                 auto name = r.name();
                 auto origHash = std::string { r.hashPart() };
-                if (r == scratchPath)
+                if (r == *scratchPath) {
                     res.first = true;
-                else if (outputRewrites.count(origHash) == 0)
-                    res.second.insert(r);
-                else {
-                    std::string newRef = outputRewrites.at(origHash);
+                } else if (auto outputRewrite = get(outputRewrites, origHash)) {
+                    std::string newRef = *outputRewrite;
                     newRef += '-';
                     newRef += name;
                     res.second.insert(StorePath { newRef });
+                } else {
+                    res.second.insert(r);
                 }
             }
             return res;
         };
 
         auto newInfoFromCA = [&](const DerivationOutput::CAFloating outputHash) -> ValidPathInfo {
-            auto & st = outputStats.at(outputName);
+            auto st = get(outputStats, outputName);
+            if (!st)
+                throw BuildError(
+                    "output path %1% without valid stats info",
+                    actualPath);
             if (outputHash.method == FileIngestionMethod::Flat) {
                 /* The output path should be a regular file without execute permission. */
-                if (!S_ISREG(st.st_mode) || (st.st_mode & S_IXUSR) != 0)
+                if (!S_ISREG(st->st_mode) || (st->st_mode & S_IXUSR) != 0)
                     throw BuildError(
                         "output path '%1%' should be a non-executable regular file "
                         "since recursive hashing is not enabled (outputHashMode=flat)",
@@ -2294,7 +2316,7 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
             }
             rewriteOutput();
             /* FIXME optimize and deduplicate with addToStore */
-            std::string oldHashPart { scratchPath.hashPart() };
+            std::string oldHashPart { scratchPath->hashPart() };
             HashModuloSink caSink { outputHash.hashType, oldHashPart };
             switch (outputHash.method) {
             case FileIngestionMethod::Recursive:
@@ -2313,7 +2335,7 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
                     outputPathName(drv->name, outputName),
                     refs.second,
                     refs.first);
-            if (scratchPath != finalPath) {
+            if (*scratchPath != finalPath) {
                 // Also rewrite the output path
                 auto source = sinkToSource([&](Sink & nextSink) {
                     StringSink sink;
@@ -2354,9 +2376,9 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
                 auto requiredFinalPath = output.path;
                 /* Preemptively add rewrite rule for final hash, as that is
                    what the NAR hash will use rather than normalized-self references */
-                if (scratchPath != requiredFinalPath)
+                if (*scratchPath != requiredFinalPath)
                     outputRewrites.insert_or_assign(
-                        std::string { scratchPath.hashPart() },
+                        std::string { scratchPath->hashPart() },
                         std::string { requiredFinalPath.hashPart() });
                 rewriteOutput();
                 auto narHashAndSize = hashPath(htSHA256, actualPath);
@@ -2409,7 +2431,7 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
                 });
             },
 
-        }, output.raw());
+        }, output->raw());
 
         /* FIXME: set proper permissions in restorePath() so
             we don't have to do another traversal. */
@@ -2425,7 +2447,7 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
            derivations. */
         PathLocks dynamicOutputLock;
         dynamicOutputLock.setDeletion(true);
-        auto optFixedPath = output.path(worker.store, drv->name, outputName);
+        auto optFixedPath = output->path(worker.store, drv->name, outputName);
         if (!optFixedPath ||
             worker.store.printStorePath(*optFixedPath) != finalDestPath)
         {
@@ -2491,11 +2513,10 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
 
         /* For debugging, print out the referenced and unreferenced paths. */
         for (auto & i : inputPaths) {
-            auto j = references.find(i);
-            if (j == references.end())
-                debug("unreferenced input: '%1%'", worker.store.printStorePath(i));
-            else
+            if (references.count(i))
                 debug("referenced input: '%1%'", worker.store.printStorePath(i));
+            else
+                debug("unreferenced input: '%1%'", worker.store.printStorePath(i));
         }
 
         if (curRound == nrRounds) {
@@ -2612,9 +2633,11 @@ DrvOutputs LocalDerivationGoal::registerOutputs()
     DrvOutputs builtOutputs;
 
     for (auto & [outputName, newInfo] : infos) {
+        auto oldinfo = get(initialOutputs, outputName);
+        assert(oldinfo);
         auto thisRealisation = Realisation {
             .id = DrvOutput {
-                initialOutputs.at(outputName).outputHash,
+                oldinfo->outputHash,
                 outputName
             },
             .outPath = newInfo.path
@@ -2710,9 +2733,10 @@ void LocalDerivationGoal::checkOutputs(const std::map<std::string, ValidPathInfo
                 for (auto & i : *value) {
                     if (worker.store.isStorePath(i))
                         spec.insert(worker.store.parseStorePath(i));
-                    else if (outputs.count(i))
-                        spec.insert(outputs.at(i).path);
-                    else throw BuildError("derivation contains an illegal reference specifier '%s'", i);
+                    else if (auto output = get(outputs, i))
+                        spec.insert(output->path);
+                    else
+                        throw BuildError("derivation contains an illegal reference specifier '%s'", i);
                 }
 
                 auto used = recursive
@@ -2751,24 +2775,18 @@ void LocalDerivationGoal::checkOutputs(const std::map<std::string, ValidPathInfo
         };
 
         if (auto structuredAttrs = parsedDrv->getStructuredAttrs()) {
-            auto outputChecks = structuredAttrs->find("outputChecks");
-            if (outputChecks != structuredAttrs->end()) {
-                auto output = outputChecks->find(outputName);
-
-                if (output != outputChecks->end()) {
+            if (auto outputChecks = get(*structuredAttrs, "outputChecks")) {
+                if (auto output = get(*outputChecks, outputName)) {
                     Checks checks;
 
-                    auto maxSize = output->find("maxSize");
-                    if (maxSize != output->end())
+                    if (auto maxSize = get(*output, "maxSize"))
                         checks.maxSize = maxSize->get<uint64_t>();
 
-                    auto maxClosureSize = output->find("maxClosureSize");
-                    if (maxClosureSize != output->end())
+                    if (auto maxClosureSize = get(*output, "maxClosureSize"))
                         checks.maxClosureSize = maxClosureSize->get<uint64_t>();
 
-                    auto get = [&](const std::string & name) -> std::optional<Strings> {
-                        auto i = output->find(name);
-                        if (i != output->end()) {
+                    auto get_ = [&](const std::string & name) -> std::optional<Strings> {
+                        if (auto i = get(*output, name)) {
                             Strings res;
                             for (auto j = i->begin(); j != i->end(); ++j) {
                                 if (!j->is_string())
@@ -2781,10 +2799,10 @@ void LocalDerivationGoal::checkOutputs(const std::map<std::string, ValidPathInfo
                         return {};
                     };
 
-                    checks.allowedReferences = get("allowedReferences");
-                    checks.allowedRequisites = get("allowedRequisites");
-                    checks.disallowedReferences = get("disallowedReferences");
-                    checks.disallowedRequisites = get("disallowedRequisites");
+                    checks.allowedReferences = get_("allowedReferences");
+                    checks.allowedRequisites = get_("allowedRequisites");
+                    checks.disallowedReferences = get_("disallowedReferences");
+                    checks.disallowedRequisites = get_("disallowedRequisites");
 
                     applyChecks(checks);
                 }
diff --git a/src/libstore/build/worker.cc b/src/libstore/build/worker.cc
index f72c1cc9c..b192fbc77 100644
--- a/src/libstore/build/worker.cc
+++ b/src/libstore/build/worker.cc
@@ -350,7 +350,7 @@ void Worker::waitForInput()
        become `available'.  Note that `available' (i.e., non-blocking)
        includes EOF. */
     std::vector<struct pollfd> pollStatus;
-    std::map <int, int> fdToPollStatus;
+    std::map<int, size_t> fdToPollStatus;
     for (auto & i : children) {
         for (auto & j : i.fds) {
             pollStatus.push_back((struct pollfd) { .fd = j, .events = POLLIN });
@@ -380,7 +380,10 @@ void Worker::waitForInput()
         std::set<int> fds2(j->fds);
         std::vector<unsigned char> buffer(4096);
         for (auto & k : fds2) {
-            if (pollStatus.at(fdToPollStatus.at(k)).revents) {
+            const auto fdPollStatusId = get(fdToPollStatus, k);
+            assert(fdPollStatusId);
+            assert(*fdPollStatusId < pollStatus.size());
+            if (pollStatus.at(*fdPollStatusId).revents) {
                 ssize_t rd = ::read(k, buffer.data(), buffer.size());
                 // FIXME: is there a cleaner way to handle pt close
                 // than EIO? Is this even standard?
diff --git a/src/libstore/builtins/fetchurl.cc b/src/libstore/builtins/fetchurl.cc
index af3dfc409..7d7924d77 100644
--- a/src/libstore/builtins/fetchurl.cc
+++ b/src/libstore/builtins/fetchurl.cc
@@ -24,7 +24,7 @@ void builtinFetchurl(const BasicDerivation & drv, const std::string & netrcData)
 
     Path storePath = getAttr("out");
     auto mainUrl = getAttr("url");
-    bool unpack = get(drv.env, "unpack").value_or("") == "1";
+    bool unpack = getOr(drv.env, "unpack", "") == "1";
 
     /* Note: have to use a fresh fileTransfer here because we're in
        a forked process. */
diff --git a/src/libstore/ca-specific-schema.sql b/src/libstore/ca-specific-schema.sql
index 64cc97fde..4ca91f585 100644
--- a/src/libstore/ca-specific-schema.sql
+++ b/src/libstore/ca-specific-schema.sql
@@ -13,12 +13,27 @@ create table if not exists Realisations (
 
 create index if not exists IndexRealisations on Realisations(drvPath, outputName);
 
+-- We can end-up in a weird edge-case where a path depends on itself because
+-- it’s an output of a CA derivation, that happens to be the same as one of its
+-- dependencies.
+-- In that case we have a dependency loop (path -> realisation1 -> realisation2
+-- -> path) that we need to break by removing the dependencies between the
+-- realisations
+create trigger if not exists DeleteSelfRefsViaRealisations before delete on ValidPaths
+  begin
+    delete from RealisationsRefs where realisationReference in (
+      select id from Realisations where outputPath = old.id
+    );
+  end;
+
 create table if not exists RealisationsRefs (
     referrer integer not null,
     realisationReference integer,
     foreign key (referrer) references Realisations(id) on delete cascade,
     foreign key (realisationReference) references Realisations(id) on delete restrict
 );
+-- used by deletion trigger
+create index if not exists IndexRealisationsRefsRealisationReference on RealisationsRefs(realisationReference);
 
 -- used by QueryRealisationReferences
 create index if not exists IndexRealisationsRefs on RealisationsRefs(referrer);
diff --git a/src/libstore/derivations.cc b/src/libstore/derivations.cc
index 1c695de82..fe99c3c5e 100644
--- a/src/libstore/derivations.cc
+++ b/src/libstore/derivations.cc
@@ -661,8 +661,10 @@ DrvHash hashDerivationModulo(Store & store, const Derivation & drv, bool maskOut
         if (res.kind == DrvHash::Kind::Deferred)
             kind = DrvHash::Kind::Deferred;
         for (auto & outputName : inputOutputs) {
-            const auto h = res.hashes.at(outputName);
-            inputs2[h.to_string(Base16, false)].insert(outputName);
+            const auto h = get(res.hashes, outputName);
+            if (!h)
+                throw Error("no hash for output '%s' of derivation '%s'", outputName, drv.name);
+            inputs2[h->to_string(Base16, false)].insert(outputName);
         }
     }
 
@@ -836,8 +838,11 @@ static void rewriteDerivation(Store & store, BasicDerivation & drv, const String
     auto hashModulo = hashDerivationModulo(store, Derivation(drv), true);
     for (auto & [outputName, output] : drv.outputs) {
         if (std::holds_alternative<DerivationOutput::Deferred>(output.raw())) {
-            auto & h = hashModulo.hashes.at(outputName);
-            auto outPath = store.makeOutputPath(outputName, h, drv.name);
+            auto h = get(hashModulo.hashes, outputName);
+            if (!h)
+                throw Error("derivation '%s' output '%s' has no hash (derivations.cc/rewriteDerivation)",
+                    drv.name, outputName);
+            auto outPath = store.makeOutputPath(outputName, *h, drv.name);
             drv.env[outputName] = store.printStorePath(outPath);
             output = DerivationOutput::InputAddressed {
                 .path = std::move(outPath),
diff --git a/src/libstore/derived-path.cc b/src/libstore/derived-path.cc
index 319b1c790..44587ae78 100644
--- a/src/libstore/derived-path.cc
+++ b/src/libstore/derived-path.cc
@@ -4,6 +4,8 @@
 
 #include <nlohmann/json.hpp>
 
+#include <optional>
+
 namespace nix {
 
 nlohmann::json DerivedPath::Opaque::toJSON(ref<Store> store) const {
@@ -17,12 +19,12 @@ nlohmann::json DerivedPath::Built::toJSON(ref<Store> store) const {
     res["drvPath"] = store->printStorePath(drvPath);
     // Fallback for the input-addressed derivation case: We expect to always be
     // able to print the output paths, so let’s do it
-    auto knownOutputs = store->queryPartialDerivationOutputMap(drvPath);
+    const auto knownOutputs = store->queryPartialDerivationOutputMap(drvPath);
     for (const auto& output : outputs) {
-        if (knownOutputs.at(output))
-            res["outputs"][output] = store->printStorePath(knownOutputs.at(output).value());
-        else
-            res["outputs"][output] = nullptr;
+        auto knownOutput = get(knownOutputs, output);
+        res["outputs"][output] = (knownOutput && *knownOutput)
+          ? store->printStorePath(**knownOutput)
+          : nullptr;
     }
     return res;
 }
@@ -123,10 +125,15 @@ RealisedPath::Set BuiltPath::toRealisedPaths(Store & store) const
                 for (auto& [outputName, outputPath] : p.outputs) {
                     if (settings.isExperimentalFeatureEnabled(
                                 Xp::CaDerivations)) {
+                        auto drvOutput = get(drvHashes, outputName);
+                        if (!drvOutput)
+                            throw Error(
+                                "the derivation '%s' has unrealised output '%s' (derived-path.cc/toRealisedPaths)",
+                                store.printStorePath(p.drvPath), outputName);
                         auto thisRealisation = store.queryRealisation(
-                            DrvOutput{drvHashes.at(outputName), outputName});
-                        assert(thisRealisation);  // We’ve built it, so we must h
-                                                  // ve the realisation
+                            DrvOutput{*drvOutput, outputName});
+                        assert(thisRealisation);  // We’ve built it, so we must
+                                                  // have the realisation
                         res.insert(*thisRealisation);
                     } else {
                         res.insert(outputPath);
diff --git a/src/libstore/filetransfer.cc b/src/libstore/filetransfer.cc
index c46262299..8454ad7d2 100644
--- a/src/libstore/filetransfer.cc
+++ b/src/libstore/filetransfer.cc
@@ -443,14 +443,13 @@ struct curlFileTransfer : public FileTransfer
                     : httpStatus != 0
                     ? FileTransferError(err,
                         std::move(response),
-                        fmt("unable to %s '%s': HTTP error %d ('%s')",
-                            request.verb(), request.uri, httpStatus, statusMsg)
-                        + (code == CURLE_OK ? "" : fmt(" (curl error: %s)", curl_easy_strerror(code)))
-                        )
+                        "unable to %s '%s': HTTP error %d%s",
+                        request.verb(), request.uri, httpStatus,
+                        code == CURLE_OK ? "" : fmt(" (curl error: %s)", curl_easy_strerror(code)))
                     : FileTransferError(err,
                         std::move(response),
-                        fmt("unable to %s '%s': %s (%d)",
-                            request.verb(), request.uri, curl_easy_strerror(code), code));
+                        "unable to %s '%s': %s (%d)",
+                        request.verb(), request.uri, curl_easy_strerror(code), code);
 
                 /* If this is a transient error, then maybe retry the
                    download after a while. If we're writing to a
@@ -693,10 +692,10 @@ struct curlFileTransfer : public FileTransfer
 #if ENABLE_S3
                 auto [bucketName, key, params] = parseS3Uri(request.uri);
 
-                std::string profile = get(params, "profile").value_or("");
-                std::string region = get(params, "region").value_or(Aws::Region::US_EAST_1);
-                std::string scheme = get(params, "scheme").value_or("");
-                std::string endpoint = get(params, "endpoint").value_or("");
+                std::string profile = getOr(params, "profile", "");
+                std::string region = getOr(params, "region", Aws::Region::US_EAST_1);
+                std::string scheme = getOr(params, "scheme", "");
+                std::string endpoint = getOr(params, "endpoint", "");
 
                 S3Helper s3Helper(profile, region, scheme, endpoint);
 
@@ -704,7 +703,7 @@ struct curlFileTransfer : public FileTransfer
                 auto s3Res = s3Helper.getObject(bucketName, key);
                 FileTransferResult res;
                 if (!s3Res.data)
-                    throw FileTransferError(NotFound, {}, "S3 object '%s' does not exist", request.uri);
+                    throw FileTransferError(NotFound, "S3 object '%s' does not exist", request.uri);
                 res.data = std::move(*s3Res.data);
                 callback(std::move(res));
 #else
diff --git a/src/libstore/local-store.cc b/src/libstore/local-store.cc
index d77fff963..eba3b0fa5 100644
--- a/src/libstore/local-store.cc
+++ b/src/libstore/local-store.cc
@@ -81,7 +81,7 @@ int getSchema(Path schemaPath)
 
 void migrateCASchema(SQLite& db, Path schemaPath, AutoCloseFD& lockFd)
 {
-    const int nixCASchemaVersion = 3;
+    const int nixCASchemaVersion = 4;
     int curCASchema = getSchema(schemaPath);
     if (curCASchema != nixCASchemaVersion) {
         if (curCASchema > nixCASchemaVersion) {
@@ -143,6 +143,21 @@ void migrateCASchema(SQLite& db, Path schemaPath, AutoCloseFD& lockFd)
             )");
             txn.commit();
         }
+        if (curCASchema < 4) {
+            SQLiteTxn txn(db);
+            db.exec(R"(
+                create trigger if not exists DeleteSelfRefsViaRealisations before delete on ValidPaths
+                begin
+                    delete from RealisationsRefs where realisationReference in (
+                    select id from Realisations where outputPath = old.id
+                    );
+                end;
+                -- used by deletion trigger
+                create index if not exists IndexRealisationsRefsRealisationReference on RealisationsRefs(realisationReference);
+            )");
+            txn.commit();
+        }
+
         writeFile(schemaPath, fmt("%d", nixCASchemaVersion));
         lockFile(lockFd.get(), ltRead, true);
     }
@@ -482,18 +497,18 @@ void LocalStore::openDB(State & state, bool create)
         SQLiteStmt stmt;
         stmt.create(db, "pragma main.journal_mode;");
         if (sqlite3_step(stmt) != SQLITE_ROW)
-            throwSQLiteError(db, "querying journal mode");
+            SQLiteError::throw_(db, "querying journal mode");
         prevMode = std::string((const char *) sqlite3_column_text(stmt, 0));
     }
     if (prevMode != mode &&
         sqlite3_exec(db, ("pragma main.journal_mode = " + mode + ";").c_str(), 0, 0, 0) != SQLITE_OK)
-        throwSQLiteError(db, "setting journal mode");
+        SQLiteError::throw_(db, "setting journal mode");
 
     /* Increase the auto-checkpoint interval to 40000 pages.  This
        seems enough to ensure that instantiating the NixOS system
        derivation is done in a single fsync(). */
     if (mode == "wal" && sqlite3_exec(db, "pragma wal_autocheckpoint = 40000;", 0, 0, 0) != SQLITE_OK)
-        throwSQLiteError(db, "setting autocheckpoint interval");
+        SQLiteError::throw_(db, "setting autocheckpoint interval");
 
     /* Initialise the database schema, if necessary. */
     if (create) {
@@ -703,7 +718,11 @@ void LocalStore::checkDerivationOutputs(const StorePath & drvPath, const Derivat
                     // somewhat expensive so we do lazily
                     hashesModulo = hashDerivationModulo(*this, drv, true);
                 }
-                StorePath recomputed = makeOutputPath(i.first, hashesModulo->hashes.at(i.first), drvName);
+                auto currentOutputHash = get(hashesModulo->hashes, i.first);
+                if (!currentOutputHash)
+                    throw Error("derivation '%s' has unexpected output '%s' (local-store / hashesModulo) named '%s'",
+                        printStorePath(drvPath), printStorePath(doia.path), i.first);
+                StorePath recomputed = makeOutputPath(i.first, *currentOutputHash, drvName);
                 if (doia.path != recomputed)
                     throw Error("derivation '%s' has incorrect output '%s', should be '%s'",
                         printStorePath(drvPath), printStorePath(doia.path), printStorePath(recomputed));
diff --git a/src/libstore/misc.cc b/src/libstore/misc.cc
index 2bbd7aa70..fb985c97b 100644
--- a/src/libstore/misc.cc
+++ b/src/libstore/misc.cc
@@ -278,11 +278,16 @@ std::map<DrvOutput, StorePath> drvOutputReferences(
     std::set<Realisation> inputRealisations;
 
     for (const auto & [inputDrv, outputNames] : drv.inputDrvs) {
-        auto outputHashes =
+        const auto outputHashes =
             staticOutputHashes(store, store.readDerivation(inputDrv));
         for (const auto & outputName : outputNames) {
+            auto outputHash = get(outputHashes, outputName);
+            if (!outputHash)
+                throw Error(
+                    "output '%s' of derivation '%s' isn't realised", outputName,
+                    store.printStorePath(inputDrv));
             auto thisRealisation = store.queryRealisation(
-                DrvOutput{outputHashes.at(outputName), outputName});
+                DrvOutput{*outputHash, outputName});
             if (!thisRealisation)
                 throw Error(
                     "output '%s' of derivation '%s' isn't built", outputName,
diff --git a/src/libstore/path-with-outputs.cc b/src/libstore/path-with-outputs.cc
index 078c117bd..d6d67ea05 100644
--- a/src/libstore/path-with-outputs.cc
+++ b/src/libstore/path-with-outputs.cc
@@ -1,5 +1,8 @@
 #include "path-with-outputs.hh"
 #include "store-api.hh"
+#include "nlohmann/json.hpp"
+
+#include <regex>
 
 namespace nix {
 
@@ -68,4 +71,57 @@ StorePathWithOutputs followLinksToStorePathWithOutputs(const Store & store, std:
     return StorePathWithOutputs { store.followLinksToStorePath(path), std::move(outputs) };
 }
 
+std::pair<std::string, OutputsSpec> parseOutputsSpec(const std::string & s)
+{
+    static std::regex regex(R"((.*)\^((\*)|([a-z]+(,[a-z]+)*)))");
+
+    std::smatch match;
+    if (!std::regex_match(s, match, regex))
+        return {s, DefaultOutputs()};
+
+    if (match[3].matched)
+        return {match[1], AllOutputs()};
+
+    return {match[1], tokenizeString<OutputNames>(match[4].str(), ",")};
+}
+
+std::string printOutputsSpec(const OutputsSpec & outputsSpec)
+{
+    if (std::get_if<DefaultOutputs>(&outputsSpec))
+        return "";
+
+    if (std::get_if<AllOutputs>(&outputsSpec))
+        return "^*";
+
+    if (auto outputNames = std::get_if<OutputNames>(&outputsSpec))
+        return "^" + concatStringsSep(",", *outputNames);
+
+    assert(false);
+}
+
+void to_json(nlohmann::json & json, const OutputsSpec & outputsSpec)
+{
+    if (std::get_if<DefaultOutputs>(&outputsSpec))
+        json = nullptr;
+
+    else if (std::get_if<AllOutputs>(&outputsSpec))
+        json = std::vector<std::string>({"*"});
+
+    else if (auto outputNames = std::get_if<OutputNames>(&outputsSpec))
+        json = *outputNames;
+}
+
+void from_json(const nlohmann::json & json, OutputsSpec & outputsSpec)
+{
+    if (json.is_null())
+        outputsSpec = DefaultOutputs();
+    else {
+        auto names = json.get<OutputNames>();
+        if (names == OutputNames({"*"}))
+            outputsSpec = AllOutputs();
+        else
+            outputsSpec = names;
+    }
+}
+
 }
diff --git a/src/libstore/path-with-outputs.hh b/src/libstore/path-with-outputs.hh
index 4c4023dcb..0cb5eb223 100644
--- a/src/libstore/path-with-outputs.hh
+++ b/src/libstore/path-with-outputs.hh
@@ -4,6 +4,7 @@
 
 #include "path.hh"
 #include "derived-path.hh"
+#include "nlohmann/json_fwd.hpp"
 
 namespace nix {
 
@@ -32,4 +33,25 @@ StorePathWithOutputs parsePathWithOutputs(const Store & store, std::string_view
 
 StorePathWithOutputs followLinksToStorePathWithOutputs(const Store & store, std::string_view pathWithOutputs);
 
+typedef std::set<std::string> OutputNames;
+
+struct AllOutputs {
+    bool operator < (const AllOutputs & _) const { return false; }
+};
+
+struct DefaultOutputs {
+    bool operator < (const DefaultOutputs & _) const { return false; }
+};
+
+typedef std::variant<DefaultOutputs, AllOutputs, OutputNames> OutputsSpec;
+
+/* Parse a string of the form 'prefix^output1,...outputN' or
+   'prefix^*', returning the prefix and the outputs spec. */
+std::pair<std::string, OutputsSpec> parseOutputsSpec(const std::string & s);
+
+std::string printOutputsSpec(const OutputsSpec & outputsSpec);
+
+void to_json(nlohmann::json &, const OutputsSpec &);
+void from_json(const nlohmann::json &, OutputsSpec &);
+
 }
diff --git a/src/libstore/remote-store.cc b/src/libstore/remote-store.cc
index 347e32094..14aeba75c 100644
--- a/src/libstore/remote-store.cc
+++ b/src/libstore/remote-store.cc
@@ -853,15 +853,15 @@ std::vector<BuildResult> RemoteStore::buildPathsWithResults(
 
                         OutputPathMap outputs;
                         auto drv = evalStore->readDerivation(bfd.drvPath);
-                        auto outputHashes = staticOutputHashes(*evalStore, drv); // FIXME: expensive
-                        auto drvOutputs = drv.outputsAndOptPaths(*this);
+                        const auto outputHashes = staticOutputHashes(*evalStore, drv); // FIXME: expensive
+                        const auto drvOutputs = drv.outputsAndOptPaths(*this);
                         for (auto & output : bfd.outputs) {
-                            if (!outputHashes.count(output))
+                            auto outputHash = get(outputHashes, output);
+                            if (!outputHash)
                                 throw Error(
                                     "the derivation '%s' doesn't have an output named '%s'",
                                     printStorePath(bfd.drvPath), output);
-                            auto outputId =
-                                DrvOutput{outputHashes.at(output), output};
+                            auto outputId = DrvOutput{ *outputHash, output };
                             if (settings.isExperimentalFeatureEnabled(Xp::CaDerivations)) {
                                 auto realisation =
                                     queryRealisation(outputId);
@@ -874,13 +874,14 @@ std::vector<BuildResult> RemoteStore::buildPathsWithResults(
                             } else {
                                 // If ca-derivations isn't enabled, assume that
                                 // the output path is statically known.
-                                assert(drvOutputs.count(output));
-                                assert(drvOutputs.at(output).second);
+                                const auto drvOutput = get(drvOutputs, output);
+                                assert(drvOutput);
+                                assert(drvOutput->second);
                                 res.builtOutputs.emplace(
                                     outputId,
                                     Realisation {
                                         .id = outputId,
-                                        .outPath = *drvOutputs.at(output).second
+                                        .outPath = *drvOutput->second,
                                     });
                             }
                         }
diff --git a/src/libstore/s3.hh b/src/libstore/s3.hh
index 3f55c74db..cdb3e5908 100644
--- a/src/libstore/s3.hh
+++ b/src/libstore/s3.hh
@@ -5,6 +5,7 @@
 #include "ref.hh"
 
 #include <optional>
+#include <string>
 
 namespace Aws { namespace Client { class ClientConfiguration; } }
 namespace Aws { namespace S3 { class S3Client; } }
diff --git a/src/libstore/sqlite.cc b/src/libstore/sqlite.cc
index 1d82b4ab1..2090beabd 100644
--- a/src/libstore/sqlite.cc
+++ b/src/libstore/sqlite.cc
@@ -8,22 +8,32 @@
 
 namespace nix {
 
-[[noreturn]] void throwSQLiteError(sqlite3 * db, const FormatOrString & fs)
+SQLiteError::SQLiteError(const char *path, int errNo, int extendedErrNo, hintformat && hf)
+  : Error(""), path(path), errNo(errNo), extendedErrNo(extendedErrNo)
+{
+    err.msg = hintfmt("%s: %s (in '%s')",
+        normaltxt(hf.str()),
+        sqlite3_errstr(extendedErrNo),
+        path ? path : "(in-memory)");
+}
+
+[[noreturn]] void SQLiteError::throw_(sqlite3 * db, hintformat && hf)
 {
     int err = sqlite3_errcode(db);
     int exterr = sqlite3_extended_errcode(db);
 
     auto path = sqlite3_db_filename(db, nullptr);
-    if (!path) path = "(in-memory)";
 
     if (err == SQLITE_BUSY || err == SQLITE_PROTOCOL) {
-        throw SQLiteBusy(
+        auto exp = SQLiteBusy(path, err, exterr, std::move(hf));
+        exp.err.msg = hintfmt(
             err == SQLITE_PROTOCOL
-            ? fmt("SQLite database '%s' is busy (SQLITE_PROTOCOL)", path)
-            : fmt("SQLite database '%s' is busy", path));
-    }
-    else
-        throw SQLiteError("%s: %s (in '%s')", fs.s, sqlite3_errstr(exterr), path);
+                ? "SQLite database '%s' is busy (SQLITE_PROTOCOL)"
+                : "SQLite database '%s' is busy",
+            path ? path : "(in-memory)");
+        throw exp;
+    } else
+        throw SQLiteError(path, err, exterr, std::move(hf));
 }
 
 SQLite::SQLite(const Path & path, bool create)
@@ -37,7 +47,7 @@ SQLite::SQLite(const Path & path, bool create)
         throw Error("cannot open SQLite database '%s'", path);
 
     if (sqlite3_busy_timeout(db, 60 * 60 * 1000) != SQLITE_OK)
-        throwSQLiteError(db, "setting timeout");
+        SQLiteError::throw_(db, "setting timeout");
 
     exec("pragma foreign_keys = 1");
 }
@@ -46,7 +56,7 @@ SQLite::~SQLite()
 {
     try {
         if (db && sqlite3_close(db) != SQLITE_OK)
-            throwSQLiteError(db, "closing database");
+            SQLiteError::throw_(db, "closing database");
     } catch (...) {
         ignoreException();
     }
@@ -62,7 +72,7 @@ void SQLite::exec(const std::string & stmt)
 {
     retrySQLite<void>([&]() {
         if (sqlite3_exec(db, stmt.c_str(), 0, 0, 0) != SQLITE_OK)
-            throwSQLiteError(db, format("executing SQLite statement '%s'") % stmt);
+            SQLiteError::throw_(db, "executing SQLite statement '%s'", stmt);
     });
 }
 
@@ -76,7 +86,7 @@ void SQLiteStmt::create(sqlite3 * db, const std::string & sql)
     checkInterrupt();
     assert(!stmt);
     if (sqlite3_prepare_v2(db, sql.c_str(), -1, &stmt, 0) != SQLITE_OK)
-        throwSQLiteError(db, fmt("creating statement '%s'", sql));
+        SQLiteError::throw_(db, "creating statement '%s'", sql);
     this->db = db;
     this->sql = sql;
 }
@@ -85,7 +95,7 @@ SQLiteStmt::~SQLiteStmt()
 {
     try {
         if (stmt && sqlite3_finalize(stmt) != SQLITE_OK)
-            throwSQLiteError(db, fmt("finalizing statement '%s'", sql));
+            SQLiteError::throw_(db, "finalizing statement '%s'", sql);
     } catch (...) {
         ignoreException();
     }
@@ -109,7 +119,7 @@ SQLiteStmt::Use & SQLiteStmt::Use::operator () (std::string_view value, bool not
 {
     if (notNull) {
         if (sqlite3_bind_text(stmt, curArg++, value.data(), -1, SQLITE_TRANSIENT) != SQLITE_OK)
-            throwSQLiteError(stmt.db, "binding argument");
+            SQLiteError::throw_(stmt.db, "binding argument");
     } else
         bind();
     return *this;
@@ -119,7 +129,7 @@ SQLiteStmt::Use & SQLiteStmt::Use::operator () (const unsigned char * data, size
 {
     if (notNull) {
         if (sqlite3_bind_blob(stmt, curArg++, data, len, SQLITE_TRANSIENT) != SQLITE_OK)
-            throwSQLiteError(stmt.db, "binding argument");
+            SQLiteError::throw_(stmt.db, "binding argument");
     } else
         bind();
     return *this;
@@ -129,7 +139,7 @@ SQLiteStmt::Use & SQLiteStmt::Use::operator () (int64_t value, bool notNull)
 {
     if (notNull) {
         if (sqlite3_bind_int64(stmt, curArg++, value) != SQLITE_OK)
-            throwSQLiteError(stmt.db, "binding argument");
+            SQLiteError::throw_(stmt.db, "binding argument");
     } else
         bind();
     return *this;
@@ -138,7 +148,7 @@ SQLiteStmt::Use & SQLiteStmt::Use::operator () (int64_t value, bool notNull)
 SQLiteStmt::Use & SQLiteStmt::Use::bind()
 {
     if (sqlite3_bind_null(stmt, curArg++) != SQLITE_OK)
-        throwSQLiteError(stmt.db, "binding argument");
+        SQLiteError::throw_(stmt.db, "binding argument");
     return *this;
 }
 
@@ -152,14 +162,14 @@ void SQLiteStmt::Use::exec()
     int r = step();
     assert(r != SQLITE_ROW);
     if (r != SQLITE_DONE)
-        throwSQLiteError(stmt.db, fmt("executing SQLite statement '%s'", sqlite3_expanded_sql(stmt.stmt)));
+        SQLiteError::throw_(stmt.db, fmt("executing SQLite statement '%s'", sqlite3_expanded_sql(stmt.stmt)));
 }
 
 bool SQLiteStmt::Use::next()
 {
     int r = step();
     if (r != SQLITE_DONE && r != SQLITE_ROW)
-        throwSQLiteError(stmt.db, fmt("executing SQLite query '%s'", sqlite3_expanded_sql(stmt.stmt)));
+        SQLiteError::throw_(stmt.db, fmt("executing SQLite query '%s'", sqlite3_expanded_sql(stmt.stmt)));
     return r == SQLITE_ROW;
 }
 
@@ -185,14 +195,14 @@ SQLiteTxn::SQLiteTxn(sqlite3 * db)
 {
     this->db = db;
     if (sqlite3_exec(db, "begin;", 0, 0, 0) != SQLITE_OK)
-        throwSQLiteError(db, "starting transaction");
+        SQLiteError::throw_(db, "starting transaction");
     active = true;
 }
 
 void SQLiteTxn::commit()
 {
     if (sqlite3_exec(db, "commit;", 0, 0, 0) != SQLITE_OK)
-        throwSQLiteError(db, "committing transaction");
+        SQLiteError::throw_(db, "committing transaction");
     active = false;
 }
 
@@ -200,7 +210,7 @@ SQLiteTxn::~SQLiteTxn()
 {
     try {
         if (active && sqlite3_exec(db, "rollback;", 0, 0, 0) != SQLITE_OK)
-            throwSQLiteError(db, "aborting transaction");
+            SQLiteError::throw_(db, "aborting transaction");
     } catch (...) {
         ignoreException();
     }
diff --git a/src/libstore/sqlite.hh b/src/libstore/sqlite.hh
index 99f0d56ce..1d1c553ea 100644
--- a/src/libstore/sqlite.hh
+++ b/src/libstore/sqlite.hh
@@ -96,10 +96,30 @@ struct SQLiteTxn
 };
 
 
-MakeError(SQLiteError, Error);
-MakeError(SQLiteBusy, SQLiteError);
+struct SQLiteError : Error
+{
+    const char *path;
+    int errNo, extendedErrNo;
+
+    template<typename... Args>
+    [[noreturn]] static void throw_(sqlite3 * db, const std::string & fs, const Args & ... args) {
+        throw_(db, hintfmt(fs, args...));
+    }
+
+    SQLiteError(const char *path, int errNo, int extendedErrNo, hintformat && hf);
+
+protected:
 
-[[noreturn]] void throwSQLiteError(sqlite3 * db, const FormatOrString & fs);
+    template<typename... Args>
+    SQLiteError(const char *path, int errNo, int extendedErrNo, const std::string & fs, const Args & ... args)
+      : SQLiteError(path, errNo, extendedErrNo, hintfmt(fs, args...))
+    { }
+
+    [[noreturn]] static void throw_(sqlite3 * db, hintformat && hf);
+
+};
+
+MakeError(SQLiteBusy, SQLiteError);
 
 void handleSQLiteBusy(const SQLiteBusy & e);
 
diff --git a/src/libstore/store-api.cc b/src/libstore/store-api.cc
index 59937be4d..8861274a2 100644
--- a/src/libstore/store-api.cc
+++ b/src/libstore/store-api.cc
@@ -1314,7 +1314,7 @@ static bool isNonUriPath(const std::string & spec) {
 std::shared_ptr<Store> openFromNonUri(const std::string & uri, const Store::Params & params)
 {
     if (uri == "" || uri == "auto") {
-        auto stateDir = get(params, "state").value_or(settings.nixStateDir);
+        auto stateDir = getOr(params, "state", settings.nixStateDir);
         if (access(stateDir.c_str(), R_OK | W_OK) == 0)
             return std::make_shared<LocalStore>(params);
         else if (pathExists(settings.nixDaemonSocketFile))
diff --git a/src/libstore/tests/path-with-outputs.cc b/src/libstore/tests/path-with-outputs.cc
new file mode 100644
index 000000000..350ea7ffd
--- /dev/null
+++ b/src/libstore/tests/path-with-outputs.cc
@@ -0,0 +1,46 @@
+#include "path-with-outputs.hh"
+
+#include <gtest/gtest.h>
+
+namespace nix {
+
+TEST(parseOutputsSpec, basic)
+{
+    {
+        auto [prefix, outputsSpec] = parseOutputsSpec("foo");
+        ASSERT_EQ(prefix, "foo");
+        ASSERT_TRUE(std::get_if<DefaultOutputs>(&outputsSpec));
+    }
+
+    {
+        auto [prefix, outputsSpec] = parseOutputsSpec("foo^*");
+        ASSERT_EQ(prefix, "foo");
+        ASSERT_TRUE(std::get_if<AllOutputs>(&outputsSpec));
+    }
+
+    {
+        auto [prefix, outputsSpec] = parseOutputsSpec("foo^out");
+        ASSERT_EQ(prefix, "foo");
+        ASSERT_TRUE(std::get<OutputNames>(outputsSpec) == OutputNames({"out"}));
+    }
+
+    {
+        auto [prefix, outputsSpec] = parseOutputsSpec("foo^out,bin");
+        ASSERT_EQ(prefix, "foo");
+        ASSERT_TRUE(std::get<OutputNames>(outputsSpec) == OutputNames({"out", "bin"}));
+    }
+
+    {
+        auto [prefix, outputsSpec] = parseOutputsSpec("foo^bar^out,bin");
+        ASSERT_EQ(prefix, "foo^bar");
+        ASSERT_TRUE(std::get<OutputNames>(outputsSpec) == OutputNames({"out", "bin"}));
+    }
+
+    {
+        auto [prefix, outputsSpec] = parseOutputsSpec("foo^&*()");
+        ASSERT_EQ(prefix, "foo^&*()");
+        ASSERT_TRUE(std::get_if<DefaultOutputs>(&outputsSpec));
+    }
+}
+
+}
diff --git a/src/libutil/chunked-vector.hh b/src/libutil/chunked-vector.hh
new file mode 100644
index 000000000..0a4f0b400
--- /dev/null
+++ b/src/libutil/chunked-vector.hh
@@ -0,0 +1,68 @@
+#pragma once
+
+#include <cstdint>
+#include <cstdlib>
+#include <vector>
+#include <limits>
+
+namespace nix {
+
+/* Provides an indexable container like vector<> with memory overhead
+   guarantees like list<> by allocating storage in chunks of ChunkSize
+   elements instead of using a contiguous memory allocation like vector<>
+   does. Not using a single vector that is resized reduces memory overhead
+   on large data sets by on average (growth factor)/2, mostly
+   eliminates copies within the vector during resizing, and provides stable
+   references to its elements. */
+template<typename T, size_t ChunkSize>
+class ChunkedVector {
+private:
+    uint32_t size_ = 0;
+    std::vector<std::vector<T>> chunks;
+
+    /* keep this out of the ::add hot path */
+    [[gnu::noinline]]
+    auto & addChunk()
+    {
+        if (size_ >= std::numeric_limits<uint32_t>::max() - ChunkSize)
+            abort();
+        chunks.emplace_back();
+        chunks.back().reserve(ChunkSize);
+        return chunks.back();
+    }
+
+public:
+    ChunkedVector(uint32_t reserve)
+    {
+        chunks.reserve(reserve);
+        addChunk();
+    }
+
+    uint32_t size() const { return size_; }
+
+    std::pair<T &, uint32_t> add(T value)
+    {
+        const auto idx = size_++;
+        auto & chunk = [&] () -> auto & {
+            if (auto & back = chunks.back(); back.size() < ChunkSize)
+                return back;
+            return addChunk();
+        }();
+        auto & result = chunk.emplace_back(std::move(value));
+        return {result, idx};
+    }
+
+    const T & operator[](uint32_t idx) const
+    {
+        return chunks[idx / ChunkSize][idx % ChunkSize];
+    }
+
+    template<typename Fn>
+    void forEach(Fn fn) const
+    {
+        for (const auto & c : chunks)
+            for (const auto & e : c)
+                fn(e);
+    }
+};
+}
diff --git a/src/libutil/error.hh b/src/libutil/error.hh
index 348018f57..f4706e3ed 100644
--- a/src/libutil/error.hh
+++ b/src/libutil/error.hh
@@ -87,11 +87,7 @@ struct ErrPos {
         origin = pos.origin;
         line = pos.line;
         column = pos.column;
-        // is file symbol null?
-        if (pos.file.set())
-            file = pos.file;
-        else
-            file = "";
+        file = pos.file;
         return *this;
     }
 
diff --git a/src/libutil/experimental-features.cc b/src/libutil/experimental-features.cc
index c1e574c0d..a7782237c 100644
--- a/src/libutil/experimental-features.cc
+++ b/src/libutil/experimental-features.cc
@@ -36,7 +36,9 @@ const std::optional<ExperimentalFeature> parseExperimentalFeature(const std::str
 
 std::string_view showExperimentalFeature(const ExperimentalFeature feature)
 {
-    return stringifiedXpFeatures.at(feature);
+    const auto ret = get(stringifiedXpFeatures, feature);
+    assert(ret);
+    return *ret;
 }
 
 std::set<ExperimentalFeature> parseFeatures(const std::set<std::string> & rawFeatures)
@@ -59,4 +61,20 @@ std::ostream & operator <<(std::ostream & str, const ExperimentalFeature & featu
     return str << showExperimentalFeature(feature);
 }
 
+void to_json(nlohmann::json & j, const ExperimentalFeature & feature)
+{
+    j = showExperimentalFeature(feature);
+}
+
+void from_json(const nlohmann::json & j, ExperimentalFeature & feature)
+{
+    const std::string input = j;
+    const auto parsed = parseExperimentalFeature(input);
+
+    if (parsed.has_value())
+        feature = *parsed;
+    else
+        throw Error("Unknown experimental feature '%s' in JSON input", input);
+}
+
 }
diff --git a/src/libutil/experimental-features.hh b/src/libutil/experimental-features.hh
index e6213bf86..7efda37f9 100644
--- a/src/libutil/experimental-features.hh
+++ b/src/libutil/experimental-features.hh
@@ -52,4 +52,11 @@ public:
     MissingExperimentalFeature(ExperimentalFeature);
 };
 
+/**
+ * Semi-magic conversion to and from json.
+ * See the nlohmann/json readme for more details.
+ */
+void to_json(nlohmann::json &, const ExperimentalFeature &);
+void from_json(const nlohmann::json &, ExperimentalFeature &);
+
 }
diff --git a/src/libutil/fmt.hh b/src/libutil/fmt.hh
index 0821b3b74..7664e5c04 100644
--- a/src/libutil/fmt.hh
+++ b/src/libutil/fmt.hh
@@ -2,7 +2,6 @@
 
 #include <boost/format.hpp>
 #include <string>
-#include <regex>
 #include "ansicolor.hh"
 
 
@@ -155,15 +154,4 @@ inline hintformat hintfmt(std::string plain_string)
     return hintfmt("%s", normaltxt(plain_string));
 }
 
-/* Highlight all the given matches in the given string `s` by wrapping
-   them between `prefix` and `postfix`.
-
-   If some matches overlap, then their union will be wrapped rather
-   than the individual matches. */
-std::string hiliteMatches(
-    std::string_view s,
-    std::vector<std::smatch> matches,
-    std::string_view prefix,
-    std::string_view postfix);
-
 }
diff --git a/src/libutil/git.cc b/src/libutil/git.cc
new file mode 100644
index 000000000..f35c2fdb7
--- /dev/null
+++ b/src/libutil/git.cc
@@ -0,0 +1,25 @@
+#include "git.hh"
+
+#include <regex>
+
+namespace nix {
+namespace git {
+
+std::optional<LsRemoteRefLine> parseLsRemoteLine(std::string_view line)
+{
+    const static std::regex line_regex("^(ref: *)?([^\\s]+)(?:\\t+(.*))?$");
+    std::match_results<std::string_view::const_iterator> match;
+    if (!std::regex_match(line.cbegin(), line.cend(), match, line_regex))
+        return std::nullopt;
+
+    return LsRemoteRefLine {
+        .kind = match[1].length() == 0
+            ? LsRemoteRefLine::Kind::Object
+            : LsRemoteRefLine::Kind::Symbolic,
+        .target = match[2],
+        .reference = match[3].length() == 0 ? std::nullopt : std::optional<std::string>{ match[3] }
+    };
+}
+
+}
+}
diff --git a/src/libutil/git.hh b/src/libutil/git.hh
new file mode 100644
index 000000000..cb13ef0e5
--- /dev/null
+++ b/src/libutil/git.hh
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <optional>
+
+namespace nix {
+
+namespace git {
+
+// A line from the output of `git ls-remote --symref`.
+//
+// These can be of two kinds:
+//
+// - Symbolic references of the form
+//
+//      ref: {target}	{reference}
+//
+//    where {target} is itself a reference and {reference} is optional
+//
+// - Object references of the form
+//
+//      {target}	{reference}
+//
+//    where {target} is a commit id and {reference} is mandatory
+struct LsRemoteRefLine {
+    enum struct Kind {
+        Symbolic,
+        Object
+    };
+    Kind kind;
+    std::string target;
+    std::optional<std::string> reference;
+};
+
+std::optional<LsRemoteRefLine> parseLsRemoteLine(std::string_view line);
+
+}
+
+}
diff --git a/src/libutil/fmt.cc b/src/libutil/hilite.cc
index 3dd93d73e..a5991ca39 100644
--- a/src/libutil/fmt.cc
+++ b/src/libutil/hilite.cc
@@ -1,6 +1,4 @@
-#include "fmt.hh"
-
-#include <regex>
+#include "hilite.hh"
 
 namespace nix {
 
diff --git a/src/libutil/hilite.hh b/src/libutil/hilite.hh
new file mode 100644
index 000000000..f8bdbfc55
--- /dev/null
+++ b/src/libutil/hilite.hh
@@ -0,0 +1,20 @@
+#pragma once
+
+#include <regex>
+#include <vector>
+#include <string>
+
+namespace nix {
+
+/* Highlight all the given matches in the given string `s` by wrapping
+   them between `prefix` and `postfix`.
+
+   If some matches overlap, then their union will be wrapped rather
+   than the individual matches. */
+std::string hiliteMatches(
+    std::string_view s,
+    std::vector<std::smatch> matches,
+    std::string_view prefix,
+    std::string_view postfix);
+
+}
diff --git a/src/libutil/json-utils.hh b/src/libutil/json-utils.hh
new file mode 100644
index 000000000..b8a031227
--- /dev/null
+++ b/src/libutil/json-utils.hh
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <nlohmann/json.hpp>
+
+namespace nix {
+
+const nlohmann::json * get(const nlohmann::json & map, const std::string & key)
+{
+    auto i = map.find(key);
+    if (i == map.end()) return nullptr;
+    return &*i;
+}
+
+nlohmann::json * get(nlohmann::json & map, const std::string & key)
+{
+    auto i = map.find(key);
+    if (i == map.end()) return nullptr;
+    return &*i;
+}
+
+}
diff --git a/src/libutil/ref.hh b/src/libutil/ref.hh
index 347b81f73..f9578afc7 100644
--- a/src/libutil/ref.hh
+++ b/src/libutil/ref.hh
@@ -99,47 +99,4 @@ make_ref(Args&&... args)
     return ref<T>(p);
 }
 
-
-/* A non-nullable pointer.
-   This is similar to a C++ "& reference", but mutable.
-   This is similar to ref<T> but backed by a regular pointer instead of a smart pointer.
- */
-template<typename T>
-class ptr {
-private:
-    T * p;
-
-public:
-    ptr<T>(const ptr<T> & r)
-        : p(r.p)
-    { }
-
-    explicit ptr<T>(T * p)
-        : p(p)
-    {
-        if (!p)
-            throw std::invalid_argument("null pointer cast to ptr");
-    }
-
-    T* operator ->() const
-    {
-        return &*p;
-    }
-
-    T& operator *() const
-    {
-        return *p;
-    }
-
-    bool operator == (const ptr<T> & other) const
-    {
-        return p == other.p;
-    }
-
-    bool operator != (const ptr<T> & other) const
-    {
-        return p != other.p;
-    }
-};
-
 }
diff --git a/src/libutil/tests/chunked-vector.cc b/src/libutil/tests/chunked-vector.cc
new file mode 100644
index 000000000..868d11f6f
--- /dev/null
+++ b/src/libutil/tests/chunked-vector.cc
@@ -0,0 +1,54 @@
+#include "chunked-vector.hh"
+
+#include <gtest/gtest.h>
+
+namespace nix {
+    TEST(ChunkedVector, InitEmpty) {
+        auto v = ChunkedVector<int, 2>(100);
+        ASSERT_EQ(v.size(), 0);
+    }
+
+    TEST(ChunkedVector, GrowsCorrectly) {
+        auto v = ChunkedVector<int, 2>(100);
+        for (auto i = 1; i < 20; i++) {
+            v.add(i);
+            ASSERT_EQ(v.size(), i);
+        }
+    }
+
+    TEST(ChunkedVector, AddAndGet) {
+        auto v = ChunkedVector<int, 2>(100);
+        for (auto i = 1; i < 20; i++) {
+            auto [i2, idx] = v.add(i);
+            auto & i3 = v[idx];
+            ASSERT_EQ(i, i2);
+            ASSERT_EQ(&i2, &i3);
+        }
+    }
+
+    TEST(ChunkedVector, ForEach) {
+        auto v = ChunkedVector<int, 2>(100);
+        for (auto i = 1; i < 20; i++) {
+            v.add(i);
+        }
+        int count = 0;
+        v.forEach([&count](int elt) {
+            count++;
+        });
+        ASSERT_EQ(count, v.size());
+    }
+
+    TEST(ChunkedVector, OverflowOK) {
+        // Similar to the AddAndGet, but intentionnally use a small
+        // initial ChunkedVector to force it to overflow
+        auto v = ChunkedVector<int, 2>(2);
+        for (auto i = 1; i < 20; i++) {
+            auto [i2, idx] = v.add(i);
+            auto & i3 = v[idx];
+            ASSERT_EQ(i, i2);
+            ASSERT_EQ(&i2, &i3);
+        }
+    }
+
+}
+
diff --git a/src/libutil/tests/git.cc b/src/libutil/tests/git.cc
new file mode 100644
index 000000000..5b5715fc2
--- /dev/null
+++ b/src/libutil/tests/git.cc
@@ -0,0 +1,33 @@
+#include "git.hh"
+#include <gtest/gtest.h>
+
+namespace nix {
+
+    TEST(GitLsRemote, parseSymrefLineWithReference) {
+        auto line = "ref: refs/head/main	HEAD";
+        auto res = git::parseLsRemoteLine(line);
+        ASSERT_TRUE(res.has_value());
+        ASSERT_EQ(res->kind, git::LsRemoteRefLine::Kind::Symbolic);
+        ASSERT_EQ(res->target, "refs/head/main");
+        ASSERT_EQ(res->reference, "HEAD");
+    }
+
+    TEST(GitLsRemote, parseSymrefLineWithNoReference) {
+        auto line = "ref: refs/head/main";
+        auto res = git::parseLsRemoteLine(line);
+        ASSERT_TRUE(res.has_value());
+        ASSERT_EQ(res->kind, git::LsRemoteRefLine::Kind::Symbolic);
+        ASSERT_EQ(res->target, "refs/head/main");
+        ASSERT_EQ(res->reference, std::nullopt);
+    }
+
+    TEST(GitLsRemote, parseObjectRefLine) {
+        auto line = "abc123	refs/head/main";
+        auto res = git::parseLsRemoteLine(line);
+        ASSERT_TRUE(res.has_value());
+        ASSERT_EQ(res->kind, git::LsRemoteRefLine::Kind::Object);
+        ASSERT_EQ(res->target, "abc123");
+        ASSERT_EQ(res->reference, "refs/head/main");
+    }
+}
+
diff --git a/src/libutil/tests/fmt.cc b/src/libutil/tests/hilite.cc
index 33772162c..1ff5980d5 100644
--- a/src/libutil/tests/fmt.cc
+++ b/src/libutil/tests/hilite.cc
@@ -1,9 +1,7 @@
-#include "fmt.hh"
+#include "hilite.hh"
 
 #include <gtest/gtest.h>
 
-#include <regex>
-
 namespace nix {
 /* ----------- tests for fmt.hh -------------------------------------------------*/
 
diff --git a/src/libutil/tests/tests.cc b/src/libutil/tests/tests.cc
index 92972ed14..6e325db98 100644
--- a/src/libutil/tests/tests.cc
+++ b/src/libutil/tests/tests.cc
@@ -548,7 +548,7 @@ namespace nix {
 
     TEST(get, emptyContainer) {
         StringMap s = { };
-        auto expected = std::nullopt;
+        auto expected = nullptr;
 
         ASSERT_EQ(get(s, "one"), expected);
     }
@@ -559,7 +559,23 @@ namespace nix {
         s["two"] = "er";
         auto expected = "yi";
 
-        ASSERT_EQ(get(s, "one"), expected);
+        ASSERT_EQ(*get(s, "one"), expected);
+    }
+
+    TEST(getOr, emptyContainer) {
+        StringMap s = { };
+        auto expected = "yi";
+
+        ASSERT_EQ(getOr(s, "one", "yi"), expected);
+    }
+
+    TEST(getOr, getFromContainer) {
+        StringMap s;
+        s["one"] = "yi";
+        s["two"] = "er";
+        auto expected = "yi";
+
+        ASSERT_EQ(getOr(s, "one", "nope"), expected);
     }
 
     /* ----------------------------------------------------------------------------
diff --git a/src/libutil/types.hh b/src/libutil/types.hh
index 00ba567c6..6bcbd7e1d 100644
--- a/src/libutil/types.hh
+++ b/src/libutil/types.hh
@@ -5,6 +5,7 @@
 #include <list>
 #include <set>
 #include <string>
+#include <limits>
 #include <map>
 #include <variant>
 #include <vector>
diff --git a/src/libutil/util.cc b/src/libutil/util.cc
index 656804007..d4d78329d 100644
--- a/src/libutil/util.cc
+++ b/src/libutil/util.cc
@@ -1082,7 +1082,7 @@ std::string runProgram(Path program, bool searchPath, const Strings & args,
     auto res = runProgram(RunOptions {.program = program, .searchPath = searchPath, .args = args, .input = input});
 
     if (!statusOk(res.first))
-        throw ExecError(res.first, fmt("program '%1%' %2%", program, statusToString(res.first)));
+        throw ExecError(res.first, "program '%1%' %2%", program, statusToString(res.first));
 
     return res.second;
 }
@@ -1210,7 +1210,7 @@ void runProgram2(const RunOptions & options)
     if (source) promise.get_future().get();
 
     if (status)
-        throw ExecError(status, fmt("program '%1%' %2%", options.program, statusToString(status)));
+        throw ExecError(status, "program '%1%' %2%", options.program, statusToString(status));
 }
 
 
@@ -1588,7 +1588,6 @@ std::string stripIndentation(std::string_view s)
 
 //////////////////////////////////////////////////////////////////////
 
-
 static Sync<std::pair<unsigned short, unsigned short>> windowSize{{0, 0}};
 
 
diff --git a/src/libutil/util.hh b/src/libutil/util.hh
index a1d0e0e6b..09ccfa591 100644
--- a/src/libutil/util.hh
+++ b/src/libutil/util.hh
@@ -543,13 +543,31 @@ std::string stripIndentation(std::string_view s);
 
 /* Get a value for the specified key from an associate container. */
 template <class T>
-std::optional<typename T::mapped_type> get(const T & map, const typename T::key_type & key)
+const typename T::mapped_type * get(const T & map, const typename T::key_type & key)
 {
     auto i = map.find(key);
-    if (i == map.end()) return {};
-    return std::optional<typename T::mapped_type>(i->second);
+    if (i == map.end()) return nullptr;
+    return &i->second;
 }
 
+template <class T>
+typename T::mapped_type * get(T & map, const typename T::key_type & key)
+{
+    auto i = map.find(key);
+    if (i == map.end()) return nullptr;
+    return &i->second;
+}
+
+/* Get a value for the specified key from an associate container, or a default value if the key isn't present. */
+template <class T>
+const typename T::mapped_type & getOr(T & map,
+    const typename T::key_type & key,
+    const typename T::mapped_type & defaultValue)
+{
+    auto i = map.find(key);
+    if (i == map.end()) return defaultValue;
+    return i->second;
+}
 
 /* Remove and return the first item from a container. */
 template <class T>
diff --git a/src/nix-build/nix-build.cc b/src/nix-build/nix-build.cc
index faa8c078f..426f23905 100755..100644
--- a/src/nix-build/nix-build.cc
+++ b/src/nix-build/nix-build.cc
@@ -440,7 +440,7 @@ static void main_nix_build(int argc, char * * argv)
         env["NIX_STORE"] = store->storeDir;
         env["NIX_BUILD_CORES"] = std::to_string(settings.buildCores);
 
-        auto passAsFile = tokenizeString<StringSet>(get(drv.env, "passAsFile").value_or(""));
+        auto passAsFile = tokenizeString<StringSet>(getOr(drv.env, "passAsFile", ""));
 
         bool keepTmp = false;
         int fileNr = 0;
@@ -543,8 +543,6 @@ static void main_nix_build(int argc, char * * argv)
 
         restoreProcessContext();
 
-        logger->stop();
-
         execvp(shell->c_str(), argPtrs.data());
 
         throw SysError("executing shell '%s'", *shell);
@@ -603,8 +601,6 @@ static void main_nix_build(int argc, char * * argv)
             outPaths.push_back(outputPath);
         }
 
-        logger->stop();
-
         for (auto & path : outPaths)
             std::cout << store->printStorePath(path) << '\n';
     }
diff --git a/src/nix-env/nix-env.cc b/src/nix-env/nix-env.cc
index 9a68899cd..c412bb814 100644
--- a/src/nix-env/nix-env.cc
+++ b/src/nix-env/nix-env.cc
@@ -1241,7 +1241,7 @@ static void opQuery(Globals & globals, Strings opFlags, Strings opArgs)
                                     Attr & a(*attrs.find(i.name));
                                     if(a.value->type() != nString) continue;
                                     XMLAttrs attrs3;
-                                    attrs3["type"] = i.name;
+                                    attrs3["type"] = globals.state->symbols[i.name];
                                     attrs3["value"] = a.value->string.s;
                                     xml.writeEmptyElement("string", attrs3);
                             }
@@ -1489,8 +1489,6 @@ static int main_nix_env(int argc, char * * argv)
 
         globals.state->printStats();
 
-        logger->stop();
-
         return 0;
     }
 }
diff --git a/src/nix-env/user-env.cc b/src/nix-env/user-env.cc
index 78692b9c6..4b1202be3 100644
--- a/src/nix-env/user-env.cc
+++ b/src/nix-env/user-env.cc
@@ -106,7 +106,7 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
        the store; we need it for future modifications of the
        environment. */
     std::ostringstream str;
-    manifest.print(str, true);
+    manifest.print(state.symbols, str, true);
     auto manifestFile = state.store->addTextToStore("env-manifest.nix",
         str.str(), references);
 
@@ -134,9 +134,9 @@ bool createUserEnv(EvalState & state, DrvInfos & elems,
     state.forceValue(topLevel, [&]() { return topLevel.determinePos(noPos); });
     PathSet context;
     Attr & aDrvPath(*topLevel.attrs->find(state.sDrvPath));
-    auto topLevelDrv = state.coerceToStorePath(*aDrvPath.pos, *aDrvPath.value, context);
+    auto topLevelDrv = state.coerceToStorePath(aDrvPath.pos, *aDrvPath.value, context);
     Attr & aOutPath(*topLevel.attrs->find(state.sOutPath));
-    auto topLevelOut = state.coerceToStorePath(*aOutPath.pos, *aOutPath.value, context);
+    auto topLevelOut = state.coerceToStorePath(aOutPath.pos, *aOutPath.value, context);
 
     /* Realise the resulting store expression. */
     debug("building user environment");
diff --git a/src/nix-instantiate/nix-instantiate.cc b/src/nix-instantiate/nix-instantiate.cc
index 3ec0e6e7c..d3144e131 100644
--- a/src/nix-instantiate/nix-instantiate.cc
+++ b/src/nix-instantiate/nix-instantiate.cc
@@ -31,7 +31,8 @@ void processExpr(EvalState & state, const Strings & attrPaths,
     bool evalOnly, OutputKind output, bool location, Expr * e)
 {
     if (parseOnly) {
-        std::cout << format("%1%\n") % *e;
+        e->show(state.symbols, std::cout);
+        std::cout << "\n";
         return;
     }
 
@@ -55,7 +56,8 @@ void processExpr(EvalState & state, const Strings & attrPaths,
                 printValueAsJSON(state, strict, vRes, v.determinePos(noPos), std::cout, context);
             else {
                 if (strict) state.forceValueDeep(vRes);
-                std::cout << vRes << std::endl;
+                vRes.print(state.symbols, std::cout);
+                std::cout << std::endl;
             }
         } else {
             DrvInfos drvs;
diff --git a/src/nix-store/nix-store.cc b/src/nix-store/nix-store.cc
index 153b84137..9163eefd0 100644
--- a/src/nix-store/nix-store.cc
+++ b/src/nix-store/nix-store.cc
@@ -1095,8 +1095,6 @@ static int main_nix_store(int argc, char * * argv)
 
         op(opFlags, opArgs);
 
-        logger->stop();
-
         return 0;
     }
 }
diff --git a/src/nix/app.cc b/src/nix/app.cc
index df7303e15..821964f86 100644
--- a/src/nix/app.cc
+++ b/src/nix/app.cc
@@ -66,7 +66,7 @@ UnresolvedApp Installable::toApp(EvalState & state)
 
     auto type = cursor->getAttr("type")->getString();
 
-    std::string expected = !attrPath.empty() && attrPath[0] == "apps" ? "app" : "derivation";
+    std::string expected = !attrPath.empty() && state.symbols[attrPath[0]] == "apps" ? "app" : "derivation";
     if (type != expected)
         throw Error("attribute '%s' should have type '%s'", cursor->getAttrPathStr(), expected);
 
@@ -89,7 +89,7 @@ UnresolvedApp Installable::toApp(EvalState & state)
         auto outputName = cursor->getAttr(state.sOutputName)->getString();
         auto name = cursor->getAttr(state.sName)->getString();
         auto aPname = cursor->maybeGetAttr("pname");
-        auto aMeta = cursor->maybeGetAttr("meta");
+        auto aMeta = cursor->maybeGetAttr(state.sMeta);
         auto aMainProgram = aMeta ? aMeta->maybeGetAttr("mainProgram") : nullptr;
         auto mainProgram =
             aMainProgram
diff --git a/src/nix/build.cc b/src/nix/build.cc
index 840c7ca38..9c648d28e 100644
--- a/src/nix/build.cc
+++ b/src/nix/build.cc
@@ -4,6 +4,7 @@
 #include "shared.hh"
 #include "store-api.hh"
 #include "local-fs-store.hh"
+#include "progress-bar.hh"
 
 #include <nlohmann/json.hpp>
 
@@ -12,6 +13,7 @@ using namespace nix;
 struct CmdBuild : InstallablesCommand, MixDryRun, MixJSON, MixProfile
 {
     Path outLink = "result";
+    bool printOutputPaths = false;
     BuildMode buildMode = bmNormal;
 
     CmdBuild()
@@ -32,6 +34,12 @@ struct CmdBuild : InstallablesCommand, MixDryRun, MixJSON, MixProfile
         });
 
         addFlag({
+            .longName = "print-out-paths",
+            .description = "Print the resulting output paths",
+            .handler = {&printOutputPaths, true},
+        });
+
+        addFlag({
             .longName = "rebuild",
             .description = "Rebuild an already built package and compare the result to the existing store paths.",
             .handler = {&buildMode, bmCheck},
@@ -93,6 +101,22 @@ struct CmdBuild : InstallablesCommand, MixDryRun, MixJSON, MixProfile
                     }, buildable.raw());
                 }
 
+        if (printOutputPaths) {
+            stopProgressBar();
+            for (auto & buildable : buildables) {
+                std::visit(overloaded {
+                    [&](const BuiltPath::Opaque & bo) {
+                        std::cout << store->printStorePath(bo.path) << std::endl;
+                    },
+                    [&](const BuiltPath::Built & bfd) {
+                        for (auto & output : bfd.outputs) {
+                            std::cout << store->printStorePath(output.second) << std::endl;
+                        }
+                    },
+                }, buildable.raw());
+            }
+        }
+
         updateProfile(buildables);
     }
 };
diff --git a/src/nix/build.md b/src/nix/build.md
index 20138b7e0..6a79f308c 100644
--- a/src/nix/build.md
+++ b/src/nix/build.md
@@ -25,6 +25,13 @@ R""(
   lrwxrwxrwx 1 … result-1 -> /nix/store/rkfrm0z6x6jmi7d3gsmma4j53h15mg33-cowsay-3.03+dfsg2
   ```
 
+* Build GNU Hello and print the resulting store path.
+
+  ```console
+  # nix build nixpkgs#hello --print-out-paths
+  /nix/store/v5sv61sszx301i0x6xysaqzla09nksnd-hello-2.10
+  ```
+
 * Build a specific output:
 
   ```console
diff --git a/src/nix/bundle.cc b/src/nix/bundle.cc
index 81fb8464a..2e48e4c74 100644
--- a/src/nix/bundle.cc
+++ b/src/nix/bundle.cc
@@ -75,10 +75,10 @@ struct CmdBundle : InstallableCommand
 
         auto val = installable->toValue(*evalState).first;
 
-        auto [bundlerFlakeRef, bundlerName] = parseFlakeRefWithFragment(bundler, absPath("."));
+        auto [bundlerFlakeRef, bundlerName, outputsSpec] = parseFlakeRefWithFragmentAndOutputsSpec(bundler, absPath("."));
         const flake::LockFlags lockFlags{ .writeLockFile = false };
         InstallableFlake bundler{this,
-            evalState, std::move(bundlerFlakeRef), bundlerName,
+            evalState, std::move(bundlerFlakeRef), bundlerName, outputsSpec,
             {"bundlers." + settings.thisSystem.get() + ".default",
              "defaultBundler." + settings.thisSystem.get()
             },
@@ -97,21 +97,23 @@ struct CmdBundle : InstallableCommand
             throw Error("the bundler '%s' does not produce a derivation", bundler.what());
 
         PathSet context2;
-        auto drvPath = evalState->coerceToStorePath(*attr1->pos, *attr1->value, context2);
+        auto drvPath = evalState->coerceToStorePath(attr1->pos, *attr1->value, context2);
 
         auto attr2 = vRes->attrs->get(evalState->sOutPath);
         if (!attr2)
             throw Error("the bundler '%s' does not produce a derivation", bundler.what());
 
-        auto outPath = evalState->coerceToStorePath(*attr2->pos, *attr2->value, context2);
+        auto outPath = evalState->coerceToStorePath(attr2->pos, *attr2->value, context2);
 
         store->buildPaths({ DerivedPath::Built { drvPath } });
 
         auto outPathS = store->printStorePath(outPath);
 
         if (!outLink) {
-            auto &attr = vRes->attrs->need(evalState->sName);
-            outLink = evalState->forceStringNoCtx(*attr.value,*attr.pos);
+            auto * attr = vRes->attrs->get(evalState->sName);
+            if (!attr)
+                throw Error("attribute 'name' missing");
+            outLink = evalState->forceStringNoCtx(*attr->value, attr->pos);
         }
 
         // TODO: will crash if not a localFSStore?
diff --git a/src/nix/develop.cc b/src/nix/develop.cc
index 7fc74d34e..3a99fff6f 100644
--- a/src/nix/develop.cc
+++ b/src/nix/develop.cc
@@ -507,13 +507,25 @@ struct CmdDevelop : Common, MixEnvironment
                 state,
                 installable->nixpkgsFlakeRef(),
                 "bashInteractive",
+                DefaultOutputs(),
                 Strings{},
                 Strings{"legacyPackages." + settings.thisSystem.get() + "."},
                 nixpkgsLockFlags);
 
-            shell = store->printStorePath(
-                Installable::toStorePath(getEvalStore(), store, Realise::Outputs, OperateOn::Output, bashInstallable))
-                + "/bin/bash";
+            bool found = false;
+
+            for (auto & path : Installable::toStorePaths(getEvalStore(), store, Realise::Outputs, OperateOn::Output, {bashInstallable})) {
+                auto s = store->printStorePath(path) + "/bin/bash";
+                if (pathExists(s)) {
+                    shell = s;
+                    found = true;
+                    break;
+                }
+            }
+
+            if (!found)
+                throw Error("package 'nixpkgs#bashInteractive' does not provide a 'bin/bash'");
+
         } catch (Error &) {
             ignoreException();
         }
diff --git a/src/nix/edit.cc b/src/nix/edit.cc
index fc48db0d7..76a134b1f 100644
--- a/src/nix/edit.cc
+++ b/src/nix/edit.cc
@@ -28,19 +28,19 @@ struct CmdEdit : InstallableCommand
     {
         auto state = getEvalState();
 
-        auto [v, pos] = installable->toValue(*state);
+        const auto [file, line] = [&] {
+            auto [v, pos] = installable->toValue(*state);
 
-        try {
-            pos = findPackageFilename(*state, *v, installable->what());
-        } catch (NoPositionInfo &) {
-        }
-
-        if (pos == noPos)
-            throw Error("cannot find position information for '%s", installable->what());
+            try {
+                return findPackageFilename(*state, *v, installable->what());
+            } catch (NoPositionInfo &) {
+                throw Error("cannot find position information for '%s", installable->what());
+            }
+        }();
 
         stopProgressBar();
 
-        auto args = editorFor(pos);
+        auto args = editorFor(file, line);
 
         restoreProcessContext();
 
diff --git a/src/nix/eval.cc b/src/nix/eval.cc
index 733b93661..967dc8519 100644
--- a/src/nix/eval.cc
+++ b/src/nix/eval.cc
@@ -77,9 +77,9 @@ struct CmdEval : MixJSON, InstallableCommand
             if (pathExists(*writeTo))
                 throw Error("path '%s' already exists", *writeTo);
 
-            std::function<void(Value & v, const Pos & pos, const Path & path)> recurse;
+            std::function<void(Value & v, const PosIdx pos, const Path & path)> recurse;
 
-            recurse = [&](Value & v, const Pos & pos, const Path & path)
+            recurse = [&](Value & v, const PosIdx pos, const Path & path)
             {
                 state->forceValue(v, pos);
                 if (v.type() == nString)
@@ -88,18 +88,22 @@ struct CmdEval : MixJSON, InstallableCommand
                 else if (v.type() == nAttrs) {
                     if (mkdir(path.c_str(), 0777) == -1)
                         throw SysError("creating directory '%s'", path);
-                    for (auto & attr : *v.attrs)
+                    for (auto & attr : *v.attrs) {
+                        std::string_view name = state->symbols[attr.name];
                         try {
-                            if (attr.name == "." || attr.name == "..")
-                                throw Error("invalid file name '%s'", attr.name);
-                            recurse(*attr.value, *attr.pos, path + "/" + std::string(attr.name));
+                            if (name == "." || name == "..")
+                                throw Error("invalid file name '%s'", name);
+                            recurse(*attr.value, attr.pos, concatStrings(path, "/", name));
                         } catch (Error & e) {
-                            e.addTrace(*attr.pos, hintfmt("while evaluating the attribute '%s'", attr.name));
+                            e.addTrace(
+                                state->positions[attr.pos],
+                                hintfmt("while evaluating the attribute '%s'", name));
                             throw;
                         }
+                    }
                 }
                 else
-                    throw TypeError("value at '%s' is not a string or an attribute set", pos);
+                    throw TypeError("value at '%s' is not a string or an attribute set", state->positions[pos]);
             };
 
             recurse(*v, pos, *writeTo);
@@ -117,7 +121,7 @@ struct CmdEval : MixJSON, InstallableCommand
 
         else {
             state->forceValueDeep(*v);
-            logger->cout("%s", *v);
+            logger->cout("%s", printValue(*state, *v));
         }
     }
 };
diff --git a/src/nix/flake.cc b/src/nix/flake.cc
index 04b23ed0f..1938ce4e6 100644
--- a/src/nix/flake.cc
+++ b/src/nix/flake.cc
@@ -123,7 +123,7 @@ struct CmdFlakeLock : FlakeCommand
 };
 
 static void enumerateOutputs(EvalState & state, Value & vFlake,
-    std::function<void(const std::string & name, Value & vProvide, const Pos & pos)> callback)
+    std::function<void(const std::string & name, Value & vProvide, const PosIdx pos)> callback)
 {
     auto pos = vFlake.determinePos(noPos);
     state.forceAttrs(vFlake, pos);
@@ -139,11 +139,11 @@ static void enumerateOutputs(EvalState & state, Value & vFlake,
        else. This way we can disable IFD for hydraJobs and then enable
        it for other outputs. */
     if (auto attr = aOutputs->value->attrs->get(sHydraJobs))
-        callback(attr->name, *attr->value, *attr->pos);
+        callback(state.symbols[attr->name], *attr->value, attr->pos);
 
     for (auto & attr : *aOutputs->value->attrs) {
         if (attr.name != sHydraJobs)
-            callback(attr.name, *attr.value, *attr.pos);
+            callback(state.symbols[attr.name], *attr.value, attr.pos);
     }
 }
 
@@ -254,14 +254,6 @@ struct CmdFlakeInfo : CmdFlakeMetadata
     }
 };
 
-static bool argHasName(std::string_view arg, std::string_view expected)
-{
-    return
-        arg == expected
-        || arg == "_"
-        || (hasPrefix(arg, "_") && arg.substr(1) == expected);
-}
-
 struct CmdFlakeCheck : FlakeCommand
 {
     bool build = true;
@@ -315,13 +307,25 @@ struct CmdFlakeCheck : FlakeCommand
 
         // FIXME: rewrite to use EvalCache.
 
-        auto checkSystemName = [&](const std::string & system, const Pos & pos) {
+        auto resolve = [&] (PosIdx p) {
+            return state->positions[p];
+        };
+
+        auto argHasName = [&] (Symbol arg, std::string_view expected) {
+            std::string_view name = state->symbols[arg];
+            return
+                name == expected
+                || name == "_"
+                || (hasPrefix(name, "_") && name.substr(1) == expected);
+        };
+
+        auto checkSystemName = [&](const std::string & system, const PosIdx pos) {
             // FIXME: what's the format of "system"?
             if (system.find('-') == std::string::npos)
-                reportError(Error("'%s' is not a valid system type, at %s", system, pos));
+                reportError(Error("'%s' is not a valid system type, at %s", system, resolve(pos)));
         };
 
-        auto checkDerivation = [&](const std::string & attrPath, Value & v, const Pos & pos) -> std::optional<StorePath> {
+        auto checkDerivation = [&](const std::string & attrPath, Value & v, const PosIdx pos) -> std::optional<StorePath> {
             try {
                 auto drvInfo = getDerivation(*state, v, false);
                 if (!drvInfo)
@@ -329,7 +333,7 @@ struct CmdFlakeCheck : FlakeCommand
                 // FIXME: check meta attributes
                 return drvInfo->queryDrvPath();
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the derivation '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the derivation '%s'", attrPath));
                 reportError(e);
             }
             return std::nullopt;
@@ -337,7 +341,7 @@ struct CmdFlakeCheck : FlakeCommand
 
         std::vector<DerivedPath> drvPaths;
 
-        auto checkApp = [&](const std::string & attrPath, Value & v, const Pos & pos) {
+        auto checkApp = [&](const std::string & attrPath, Value & v, const PosIdx pos) {
             try {
                 #if 0
                 // FIXME
@@ -348,12 +352,12 @@ struct CmdFlakeCheck : FlakeCommand
                 }
                 #endif
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the app definition '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the app definition '%s'", attrPath));
                 reportError(e);
             }
         };
 
-        auto checkOverlay = [&](const std::string & attrPath, Value & v, const Pos & pos) {
+        auto checkOverlay = [&](const std::string & attrPath, Value & v, const PosIdx pos) {
             try {
                 state->forceValue(v, pos);
                 if (!v.isLambda()
@@ -368,12 +372,12 @@ struct CmdFlakeCheck : FlakeCommand
                 // FIXME: if we have a 'nixpkgs' input, use it to
                 // evaluate the overlay.
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the overlay '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the overlay '%s'", attrPath));
                 reportError(e);
             }
         };
 
-        auto checkModule = [&](const std::string & attrPath, Value & v, const Pos & pos) {
+        auto checkModule = [&](const std::string & attrPath, Value & v, const PosIdx pos) {
             try {
                 state->forceValue(v, pos);
                 if (v.isLambda()) {
@@ -382,9 +386,11 @@ struct CmdFlakeCheck : FlakeCommand
                 } else if (v.type() == nAttrs) {
                     for (auto & attr : *v.attrs)
                         try {
-                            state->forceValue(*attr.value, *attr.pos);
+                            state->forceValue(*attr.value, attr.pos);
                         } catch (Error & e) {
-                            e.addTrace(*attr.pos, hintfmt("while evaluating the option '%s'", attr.name));
+                            e.addTrace(
+                                state->positions[attr.pos],
+                                hintfmt("while evaluating the option '%s'", state->symbols[attr.name]));
                             throw;
                         }
                 } else
@@ -392,14 +398,14 @@ struct CmdFlakeCheck : FlakeCommand
                 // FIXME: if we have a 'nixpkgs' input, use it to
                 // check the module.
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the NixOS module '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the NixOS module '%s'", attrPath));
                 reportError(e);
             }
         };
 
-        std::function<void(const std::string & attrPath, Value & v, const Pos & pos)> checkHydraJobs;
+        std::function<void(const std::string & attrPath, Value & v, const PosIdx pos)> checkHydraJobs;
 
-        checkHydraJobs = [&](const std::string & attrPath, Value & v, const Pos & pos) {
+        checkHydraJobs = [&](const std::string & attrPath, Value & v, const PosIdx pos) {
             try {
                 state->forceAttrs(v, pos);
 
@@ -407,23 +413,23 @@ struct CmdFlakeCheck : FlakeCommand
                     throw Error("jobset should not be a derivation at top-level");
 
                 for (auto & attr : *v.attrs) {
-                    state->forceAttrs(*attr.value, *attr.pos);
-                    auto attrPath2 = attrPath + "." + (std::string) attr.name;
+                    state->forceAttrs(*attr.value, attr.pos);
+                    auto attrPath2 = concatStrings(attrPath, ".", state->symbols[attr.name]);
                     if (state->isDerivation(*attr.value)) {
                         Activity act(*logger, lvlChatty, actUnknown,
                             fmt("checking Hydra job '%s'", attrPath2));
-                        checkDerivation(attrPath2, *attr.value, *attr.pos);
+                        checkDerivation(attrPath2, *attr.value, attr.pos);
                     } else
-                        checkHydraJobs(attrPath2, *attr.value, *attr.pos);
+                        checkHydraJobs(attrPath2, *attr.value, attr.pos);
                 }
 
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the Hydra jobset '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the Hydra jobset '%s'", attrPath));
                 reportError(e);
             }
         };
 
-        auto checkNixOSConfiguration = [&](const std::string & attrPath, Value & v, const Pos & pos) {
+        auto checkNixOSConfiguration = [&](const std::string & attrPath, Value & v, const PosIdx pos) {
             try {
                 Activity act(*logger, lvlChatty, actUnknown,
                     fmt("checking NixOS configuration '%s'", attrPath));
@@ -433,12 +439,12 @@ struct CmdFlakeCheck : FlakeCommand
                 if (!state->isDerivation(*vToplevel))
                     throw Error("attribute 'config.system.build.toplevel' is not a derivation");
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the NixOS configuration '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the NixOS configuration '%s'", attrPath));
                 reportError(e);
             }
         };
 
-        auto checkTemplate = [&](const std::string & attrPath, Value & v, const Pos & pos) {
+        auto checkTemplate = [&](const std::string & attrPath, Value & v, const PosIdx pos) {
             try {
                 Activity act(*logger, lvlChatty, actUnknown,
                     fmt("checking template '%s'", attrPath));
@@ -448,7 +454,7 @@ struct CmdFlakeCheck : FlakeCommand
                 if (auto attr = v.attrs->get(state->symbols.create("path"))) {
                     if (attr->name == state->symbols.create("path")) {
                         PathSet context;
-                        auto path = state->coerceToPath(*attr->pos, *attr->value, context);
+                        auto path = state->coerceToPath(attr->pos, *attr->value, context);
                         if (!store->isInStore(path))
                             throw Error("template '%s' has a bad 'path' attribute");
                         // TODO: recursively check the flake in 'path'.
@@ -457,29 +463,29 @@ struct CmdFlakeCheck : FlakeCommand
                     throw Error("template '%s' lacks attribute 'path'", attrPath);
 
                 if (auto attr = v.attrs->get(state->symbols.create("description")))
-                    state->forceStringNoCtx(*attr->value, *attr->pos);
+                    state->forceStringNoCtx(*attr->value, attr->pos);
                 else
                     throw Error("template '%s' lacks attribute 'description'", attrPath);
 
                 for (auto & attr : *v.attrs) {
-                    std::string name(attr.name);
+                    std::string_view name(state->symbols[attr.name]);
                     if (name != "path" && name != "description" && name != "welcomeText")
                         throw Error("template '%s' has unsupported attribute '%s'", attrPath, name);
                 }
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the template '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the template '%s'", attrPath));
                 reportError(e);
             }
         };
 
-        auto checkBundler = [&](const std::string & attrPath, Value & v, const Pos & pos) {
+        auto checkBundler = [&](const std::string & attrPath, Value & v, const PosIdx pos) {
             try {
                 state->forceValue(v, pos);
                 if (!v.isLambda())
                     throw Error("bundler must be a function");
                 // TODO: check types of inputs/outputs?
             } catch (Error & e) {
-                e.addTrace(pos, hintfmt("while checking the template '%s'", attrPath));
+                e.addTrace(resolve(pos), hintfmt("while checking the template '%s'", attrPath));
                 reportError(e);
             }
         };
@@ -492,7 +498,7 @@ struct CmdFlakeCheck : FlakeCommand
 
             enumerateOutputs(*state,
                 *vFlake,
-                [&](const std::string & name, Value & vOutput, const Pos & pos) {
+                [&](const std::string & name, Value & vOutput, const PosIdx pos) {
                     Activity act(*logger, lvlChatty, actUnknown,
                         fmt("checking flake output '%s'", name));
 
@@ -516,13 +522,14 @@ struct CmdFlakeCheck : FlakeCommand
                         if (name == "checks") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
-                                state->forceAttrs(*attr.value, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
+                                state->forceAttrs(*attr.value, attr.pos);
                                 for (auto & attr2 : *attr.value->attrs) {
                                     auto drvPath = checkDerivation(
-                                        fmt("%s.%s.%s", name, attr.name, attr2.name),
-                                        *attr2.value, *attr2.pos);
-                                    if (drvPath && (std::string) attr.name == settings.thisSystem.get())
+                                        fmt("%s.%s.%s", name, attr_name, state->symbols[attr2.name]),
+                                        *attr2.value, attr2.pos);
+                                    if (drvPath && attr_name == settings.thisSystem.get())
                                         drvPaths.push_back(DerivedPath::Built{*drvPath});
                                 }
                             }
@@ -531,61 +538,66 @@ struct CmdFlakeCheck : FlakeCommand
                         else if (name == "formatter") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
                                 checkApp(
-                                    fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                    fmt("%s.%s", name, attr_name),
+                                    *attr.value, attr.pos);
                             }
                         }
 
                         else if (name == "packages" || name == "devShells") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
-                                state->forceAttrs(*attr.value, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
+                                state->forceAttrs(*attr.value, attr.pos);
                                 for (auto & attr2 : *attr.value->attrs)
                                     checkDerivation(
-                                        fmt("%s.%s.%s", name, attr.name, attr2.name),
-                                        *attr2.value, *attr2.pos);
+                                        fmt("%s.%s.%s", name, attr_name, state->symbols[attr2.name]),
+                                        *attr2.value, attr2.pos);
                             }
                         }
 
                         else if (name == "apps") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
-                                state->forceAttrs(*attr.value, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
+                                state->forceAttrs(*attr.value, attr.pos);
                                 for (auto & attr2 : *attr.value->attrs)
                                     checkApp(
-                                        fmt("%s.%s.%s", name, attr.name, attr2.name),
-                                        *attr2.value, *attr2.pos);
+                                        fmt("%s.%s.%s", name, attr_name, state->symbols[attr2.name]),
+                                        *attr2.value, attr2.pos);
                             }
                         }
 
                         else if (name == "defaultPackage" || name == "devShell") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
                                 checkDerivation(
-                                    fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                    fmt("%s.%s", name, attr_name),
+                                    *attr.value, attr.pos);
                             }
                         }
 
                         else if (name == "defaultApp") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
                                 checkApp(
-                                    fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                    fmt("%s.%s", name, attr_name),
+                                    *attr.value, attr.pos);
                             }
                         }
 
                         else if (name == "legacyPackages") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
+                                checkSystemName(state->symbols[attr.name], attr.pos);
                                 // FIXME: do getDerivations?
                             }
                         }
@@ -596,8 +608,8 @@ struct CmdFlakeCheck : FlakeCommand
                         else if (name == "overlays") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs)
-                                checkOverlay(fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                checkOverlay(fmt("%s.%s", name, state->symbols[attr.name]),
+                                    *attr.value, attr.pos);
                         }
 
                         else if (name == "nixosModule")
@@ -606,15 +618,15 @@ struct CmdFlakeCheck : FlakeCommand
                         else if (name == "nixosModules") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs)
-                                checkModule(fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                checkModule(fmt("%s.%s", name, state->symbols[attr.name]),
+                                    *attr.value, attr.pos);
                         }
 
                         else if (name == "nixosConfigurations") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs)
-                                checkNixOSConfiguration(fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                checkNixOSConfiguration(fmt("%s.%s", name, state->symbols[attr.name]),
+                                    *attr.value, attr.pos);
                         }
 
                         else if (name == "hydraJobs")
@@ -626,29 +638,31 @@ struct CmdFlakeCheck : FlakeCommand
                         else if (name == "templates") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs)
-                                checkTemplate(fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                checkTemplate(fmt("%s.%s", name, state->symbols[attr.name]),
+                                    *attr.value, attr.pos);
                         }
 
                         else if (name == "defaultBundler") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
                                 checkBundler(
-                                    fmt("%s.%s", name, attr.name),
-                                    *attr.value, *attr.pos);
+                                    fmt("%s.%s", name, attr_name),
+                                    *attr.value, attr.pos);
                             }
                         }
 
                         else if (name == "bundlers") {
                             state->forceAttrs(vOutput, pos);
                             for (auto & attr : *vOutput.attrs) {
-                                checkSystemName(attr.name, *attr.pos);
-                                state->forceAttrs(*attr.value, *attr.pos);
+                                const auto & attr_name = state->symbols[attr.name];
+                                checkSystemName(attr_name, attr.pos);
+                                state->forceAttrs(*attr.value, attr.pos);
                                 for (auto & attr2 : *attr.value->attrs) {
                                     checkBundler(
-                                        fmt("%s.%s.%s", name, attr.name, attr2.name),
-                                        *attr2.value, *attr2.pos);
+                                        fmt("%s.%s.%s", name, attr_name, state->symbols[attr2.name]),
+                                        *attr2.value, attr2.pos);
                                 }
                             }
                         }
@@ -657,7 +671,7 @@ struct CmdFlakeCheck : FlakeCommand
                             warn("unknown flake output '%s'", name);
 
                     } catch (Error & e) {
-                        e.addTrace(pos, hintfmt("while checking flake output '%s'", name));
+                        e.addTrace(resolve(pos), hintfmt("while checking flake output '%s'", name));
                         reportError(e);
                     }
                 });
@@ -710,7 +724,7 @@ struct CmdFlakeInitCommon : virtual Args, EvalCommand
         auto [templateFlakeRef, templateName] = parseFlakeRefWithFragment(templateUrl, absPath("."));
 
         auto installable = InstallableFlake(nullptr,
-            evalState, std::move(templateFlakeRef), templateName,
+            evalState, std::move(templateFlakeRef), templateName, DefaultOutputs(),
             defaultTemplateAttrPaths,
             defaultTemplateAttrPathsPrefixes,
             lockFlags);
@@ -972,8 +986,11 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
         {
             auto j = nlohmann::json::object();
 
+            auto attrPathS = state->symbols.resolve(attrPath);
+
             Activity act(*logger, lvlInfo, actUnknown,
-                fmt("evaluating '%s'", concatStringsSep(".", attrPath)));
+                fmt("evaluating '%s'", concatStringsSep(".", attrPathS)));
+
             try {
                 auto recurse = [&]()
                 {
@@ -981,14 +998,15 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                         logger->cout("%s", headerPrefix);
                     auto attrs = visitor.getAttrs();
                     for (const auto & [i, attr] : enumerate(attrs)) {
+                        const auto & attrName = state->symbols[attr];
                         bool last = i + 1 == attrs.size();
-                        auto visitor2 = visitor.getAttr(attr);
+                        auto visitor2 = visitor.getAttr(attrName);
                         auto attrPath2(attrPath);
                         attrPath2.push_back(attr);
                         auto j2 = visit(*visitor2, attrPath2,
-                            fmt(ANSI_GREEN "%s%s" ANSI_NORMAL ANSI_BOLD "%s" ANSI_NORMAL, nextPrefix, last ? treeLast : treeConn, attr),
+                            fmt(ANSI_GREEN "%s%s" ANSI_NORMAL ANSI_BOLD "%s" ANSI_NORMAL, nextPrefix, last ? treeLast : treeConn, attrName),
                             nextPrefix + (last ? treeNull : treeLine));
-                        if (json) j.emplace(attr, std::move(j2));
+                        if (json) j.emplace(attrName, std::move(j2));
                     }
                 };
 
@@ -997,8 +1015,8 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                     auto name = visitor.getAttr(state->sName)->getString();
                     if (json) {
                         std::optional<std::string> description;
-                        if (auto aMeta = visitor.maybeGetAttr("meta")) {
-                            if (auto aDescription = aMeta->maybeGetAttr("description"))
+                        if (auto aMeta = visitor.maybeGetAttr(state->sMeta)) {
+                            if (auto aDescription = aMeta->maybeGetAttr(state->sDescription))
                                 description = aDescription->getString();
                         }
                         j.emplace("type", "derivation");
@@ -1008,10 +1026,10 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                     } else {
                         logger->cout("%s: %s '%s'",
                             headerPrefix,
-                            attrPath.size() == 2 && attrPath[0] == "devShell" ? "development environment" :
-                            attrPath.size() >= 2 && attrPath[0] == "devShells" ? "development environment" :
-                            attrPath.size() == 3 && attrPath[0] == "checks" ? "derivation" :
-                            attrPath.size() >= 1 && attrPath[0] == "hydraJobs" ? "derivation" :
+                            attrPath.size() == 2 && attrPathS[0] == "devShell" ? "development environment" :
+                            attrPath.size() >= 2 && attrPathS[0] == "devShells" ? "development environment" :
+                            attrPath.size() == 3 && attrPathS[0] == "checks" ? "derivation" :
+                            attrPath.size() >= 1 && attrPathS[0] == "hydraJobs" ? "derivation" :
                             "package",
                             name);
                     }
@@ -1019,27 +1037,27 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
 
                 if (attrPath.size() == 0
                     || (attrPath.size() == 1 && (
-                            attrPath[0] == "defaultPackage"
-                            || attrPath[0] == "devShell"
-                            || attrPath[0] == "formatter"
-                            || attrPath[0] == "nixosConfigurations"
-                            || attrPath[0] == "nixosModules"
-                            || attrPath[0] == "defaultApp"
-                            || attrPath[0] == "templates"
-                            || attrPath[0] == "overlays"))
+                            attrPathS[0] == "defaultPackage"
+                            || attrPathS[0] == "devShell"
+                            || attrPathS[0] == "formatter"
+                            || attrPathS[0] == "nixosConfigurations"
+                            || attrPathS[0] == "nixosModules"
+                            || attrPathS[0] == "defaultApp"
+                            || attrPathS[0] == "templates"
+                            || attrPathS[0] == "overlays"))
                     || ((attrPath.size() == 1 || attrPath.size() == 2)
-                        && (attrPath[0] == "checks"
-                            || attrPath[0] == "packages"
-                            || attrPath[0] == "devShells"
-                            || attrPath[0] == "apps"))
+                        && (attrPathS[0] == "checks"
+                            || attrPathS[0] == "packages"
+                            || attrPathS[0] == "devShells"
+                            || attrPathS[0] == "apps"))
                     )
                 {
                     recurse();
                 }
 
                 else if (
-                    (attrPath.size() == 2 && (attrPath[0] == "defaultPackage" || attrPath[0] == "devShell" || attrPath[0] == "formatter"))
-                    || (attrPath.size() == 3 && (attrPath[0] == "checks" || attrPath[0] == "packages" || attrPath[0] == "devShells"))
+                    (attrPath.size() == 2 && (attrPathS[0] == "defaultPackage" || attrPathS[0] == "devShell" || attrPathS[0] == "formatter"))
+                    || (attrPath.size() == 3 && (attrPathS[0] == "checks" || attrPathS[0] == "packages" || attrPathS[0] == "devShells"))
                     )
                 {
                     if (visitor.isDerivation())
@@ -1048,14 +1066,14 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                         throw Error("expected a derivation");
                 }
 
-                else if (attrPath.size() > 0 && attrPath[0] == "hydraJobs") {
+                else if (attrPath.size() > 0 && attrPathS[0] == "hydraJobs") {
                     if (visitor.isDerivation())
                         showDerivation();
                     else
                         recurse();
                 }
 
-                else if (attrPath.size() > 0 && attrPath[0] == "legacyPackages") {
+                else if (attrPath.size() > 0 && attrPathS[0] == "legacyPackages") {
                     if (attrPath.size() == 1)
                         recurse();
                     else if (!showLegacy)
@@ -1070,8 +1088,8 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                 }
 
                 else if (
-                    (attrPath.size() == 2 && attrPath[0] == "defaultApp") ||
-                    (attrPath.size() == 3 && attrPath[0] == "apps"))
+                    (attrPath.size() == 2 && attrPathS[0] == "defaultApp") ||
+                    (attrPath.size() == 3 && attrPathS[0] == "apps"))
                 {
                     auto aType = visitor.maybeGetAttr("type");
                     if (!aType || aType->getString() != "app")
@@ -1084,8 +1102,8 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                 }
 
                 else if (
-                    (attrPath.size() == 1 && attrPath[0] == "defaultTemplate") ||
-                    (attrPath.size() == 2 && attrPath[0] == "templates"))
+                    (attrPath.size() == 1 && attrPathS[0] == "defaultTemplate") ||
+                    (attrPath.size() == 2 && attrPathS[0] == "templates"))
                 {
                     auto description = visitor.getAttr("description")->getString();
                     if (json) {
@@ -1098,11 +1116,11 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
 
                 else {
                     auto [type, description] =
-                        (attrPath.size() == 1 && attrPath[0] == "overlay")
-                        || (attrPath.size() == 2 && attrPath[0] == "overlays") ? std::make_pair("nixpkgs-overlay", "Nixpkgs overlay") :
-                        attrPath.size() == 2 && attrPath[0] == "nixosConfigurations" ? std::make_pair("nixos-configuration", "NixOS configuration") :
-                        (attrPath.size() == 1 && attrPath[0] == "nixosModule")
-                        || (attrPath.size() == 2 && attrPath[0] == "nixosModules") ? std::make_pair("nixos-module", "NixOS module") :
+                        (attrPath.size() == 1 && attrPathS[0] == "overlay")
+                        || (attrPath.size() == 2 && attrPathS[0] == "overlays") ? std::make_pair("nixpkgs-overlay", "Nixpkgs overlay") :
+                        attrPath.size() == 2 && attrPathS[0] == "nixosConfigurations" ? std::make_pair("nixos-configuration", "NixOS configuration") :
+                        (attrPath.size() == 1 && attrPathS[0] == "nixosModule")
+                        || (attrPath.size() == 2 && attrPathS[0] == "nixosModules") ? std::make_pair("nixos-module", "NixOS module") :
                         std::make_pair("unknown", "unknown");
                     if (json) {
                         j.emplace("type", type);
@@ -1111,7 +1129,7 @@ struct CmdFlakeShow : FlakeCommand, MixJSON
                     }
                 }
             } catch (EvalError & e) {
-                if (!(attrPath.size() > 0 && attrPath[0] == "legacyPackages"))
+                if (!(attrPath.size() > 0 && attrPathS[0] == "legacyPackages"))
                     throw;
             }
 
diff --git a/src/nix/flake.md b/src/nix/flake.md
index 7d179a6c4..c8251eb74 100644
--- a/src/nix/flake.md
+++ b/src/nix/flake.md
@@ -153,7 +153,7 @@ Currently the `type` attribute can be one of the following:
   git(+http|+https|+ssh|+git|+file|):(//<server>)?<path>(\?<params>)?
   ```
 
-  The `ref` attribute defaults to `master`.
+  The `ref` attribute defaults to resolving the `HEAD` reference.
 
   The `rev` attribute must denote a commit that exists in the branch
   or tag specified by the `ref` attribute, since Nix doesn't do a full
@@ -161,6 +161,11 @@ Currently the `type` attribute can be one of the following:
   doesn't allow fetching a `rev` without a known `ref`). The default
   is the commit currently pointed to by `ref`.
 
+  When `git+file` is used without specifying `ref` or `rev`, files are
+  fetched directly from the local `path` as long as they have been added
+  to the Git repository. If there are uncommitted changes, the reference
+  is treated as dirty and a warning is printed.
+
   For example, the following are valid Git flake references:
 
   * `git+https://example.org/my/repo`
diff --git a/src/nix/fmt.cc b/src/nix/fmt.cc
index e5d44bd38..6f6a4a632 100644
--- a/src/nix/fmt.cc
+++ b/src/nix/fmt.cc
@@ -26,7 +26,8 @@ struct CmdFmt : SourceExprCommand {
 
     Strings getDefaultFlakeAttrPathPrefixes() override { return Strings{}; }
 
-    void run(ref<Store> store) {
+    void run(ref<Store> store) override
+    {
         auto evalState = getEvalState();
         auto evalStore = getEvalStore();
 
diff --git a/src/nix/main.cc b/src/nix/main.cc
index 6198681e7..dadb54306 100644
--- a/src/nix/main.cc
+++ b/src/nix/main.cc
@@ -261,6 +261,8 @@ void mainWrapped(int argc, char * * argv)
     }
     #endif
 
+    Finally f([] { logger->stop(); });
+
     programPath = argv[0];
     auto programName = std::string(baseNameOf(programPath));
 
@@ -279,8 +281,6 @@ void mainWrapped(int argc, char * * argv)
         verbosity = lvlInfo;
     }
 
-    Finally f([] { logger->stop(); });
-
     NixArgs args;
 
     if (argc == 2 && std::string(argv[1]) == "__dump-args") {
@@ -302,7 +302,7 @@ void mainWrapped(int argc, char * * argv)
             b["arity"] = primOp->arity;
             b["args"] = primOp->args;
             b["doc"] = trim(stripIndentation(primOp->doc));
-            res[(std::string) builtin.name] = std::move(b);
+            res[state.symbols[builtin.name]] = std::move(b);
         }
         std::cout << res.dump() << "\n";
         return;
diff --git a/src/nix/nix.md b/src/nix/nix.md
index 691aa137b..34c763c69 100644
--- a/src/nix/nix.md
+++ b/src/nix/nix.md
@@ -158,6 +158,51 @@ For most commands, if no installable is specified, the default is `.`,
 i.e. Nix will operate on the default flake output attribute of the
 flake in the current directory.
 
+## Derivation output selection
+
+Derivations can have multiple outputs, each corresponding to a
+different store path. For instance, a package can have a `bin` output
+that contains programs, and a `dev` output that provides development
+artifacts like C/C++ header files. The outputs on which `nix` commands
+operate are determined as follows:
+
+* You can explicitly specify the desired outputs using the syntax
+  *installable*`^`*output1*`,`*...*`,`*outputN*. For example, you can
+  obtain the `dev` and `static` outputs of the `glibc` package:
+
+  ```console
+  # nix build 'nixpkgs#glibc^dev,static'
+  # ls ./result-dev/include/ ./result-static/lib/
+  …
+  ```
+
+* You can also specify that *all* outputs should be used using the
+  syntax *installable*`^*`. For example, the following shows the size
+  of all outputs of the `glibc` package in the binary cache:
+
+  ```console
+  # nix path-info -S --eval-store auto --store https://cache.nixos.org 'nixpkgs#glibc^*'
+  /nix/store/g02b1lpbddhymmcjb923kf0l7s9nww58-glibc-2.33-123                 33208200
+  /nix/store/851dp95qqiisjifi639r0zzg5l465ny4-glibc-2.33-123-bin             36142896
+  /nix/store/kdgs3q6r7xdff1p7a9hnjr43xw2404z7-glibc-2.33-123-debug          155787312
+  /nix/store/n4xa8h6pbmqmwnq0mmsz08l38abb06zc-glibc-2.33-123-static          42488328
+  /nix/store/q6580lr01jpcsqs4r5arlh4ki2c1m9rv-glibc-2.33-123-dev             44200560
+  ```
+
+* If you didn't specify the desired outputs, but the derivation has an
+  attribute `meta.outputsToInstall`, Nix will use those outputs. For
+  example, since the package `nixpkgs#libxml2` has this attribute:
+
+  ```console
+  # nix eval 'nixpkgs#libxml2.meta.outputsToInstall'
+  [ "bin" "man" ]
+  ```
+
+  a command like `nix shell nixpkgs#libxml2` will provide only those
+  two outputs by default.
+
+* Otherwise, Nix will use all outputs of the derivation.
+
 # Nix stores
 
 Most `nix` subcommands operate on a *Nix store*.
diff --git a/src/nix/prefetch.cc b/src/nix/prefetch.cc
index f2dd44ba4..ce3288dc1 100644
--- a/src/nix/prefetch.cc
+++ b/src/nix/prefetch.cc
@@ -199,11 +199,13 @@ static int main_nix_prefetch_url(int argc, char * * argv)
             state->forceAttrs(v, noPos);
 
             /* Extract the URL. */
-            auto & attr = v.attrs->need(state->symbols.create("urls"));
-            state->forceList(*attr.value, noPos);
-            if (attr.value->listSize() < 1)
+            auto * attr = v.attrs->get(state->symbols.create("urls"));
+            if (!attr)
+                throw Error("attribute 'urls' missing");
+            state->forceList(*attr->value, noPos);
+            if (attr->value->listSize() < 1)
                 throw Error("'urls' list is empty");
-            url = state->forceString(*attr.value->listElems()[0]);
+            url = state->forceString(*attr->value->listElems()[0]);
 
             /* Extract the hash mode. */
             auto attr2 = v.attrs->get(state->symbols.create("outputHashMode"));
diff --git a/src/nix/profile-install.md b/src/nix/profile-install.md
index e3009491e..aed414963 100644
--- a/src/nix/profile-install.md
+++ b/src/nix/profile-install.md
@@ -20,6 +20,13 @@ R""(
   # nix profile install nixpkgs/d73407e8e6002646acfdef0e39ace088bacc83da#hello
   ```
 
+* Install a specific output of a package:
+
+  ```console
+  # nix profile install nixpkgs#bash^man
+  ```
+
+
 # Description
 
 This command adds *installables* to a Nix profile.
diff --git a/src/nix/profile.cc b/src/nix/profile.cc
index b151e48d6..685776bec 100644
--- a/src/nix/profile.cc
+++ b/src/nix/profile.cc
@@ -22,13 +22,13 @@ struct ProfileElementSource
     // FIXME: record original attrpath.
     FlakeRef resolvedRef;
     std::string attrPath;
-    // FIXME: output names
+    OutputsSpec outputs;
 
     bool operator < (const ProfileElementSource & other) const
     {
         return
-            std::pair(originalRef.to_string(), attrPath) <
-            std::pair(other.originalRef.to_string(), other.attrPath);
+            std::tuple(originalRef.to_string(), attrPath, outputs) <
+            std::tuple(other.originalRef.to_string(), other.attrPath, other.outputs);
     }
 };
 
@@ -42,7 +42,7 @@ struct ProfileElement
     std::string describe() const
     {
         if (source)
-            return fmt("%s#%s", source->originalRef, source->attrPath);
+            return fmt("%s#%s%s", source->originalRef, source->attrPath, printOutputsSpec(source->outputs));
         StringSet names;
         for (auto & path : storePaths)
             names.insert(DrvName(path.name()).name);
@@ -67,7 +67,6 @@ struct ProfileElement
         ref<Store> store,
         const BuiltPaths & builtPaths)
     {
-        // FIXME: respect meta.outputsToInstall
         storePaths.clear();
         for (auto & buildable : builtPaths) {
             std::visit(overloaded {
@@ -99,7 +98,7 @@ struct ProfileManifest
             auto version = json.value("version", 0);
             std::string sUrl;
             std::string sOriginalUrl;
-            switch(version){
+            switch (version) {
                 case 1:
                     sUrl = "uri";
                     sOriginalUrl = "originalUri";
@@ -117,11 +116,12 @@ struct ProfileManifest
                 for (auto & p : e["storePaths"])
                     element.storePaths.insert(state.store->parseStorePath((std::string) p));
                 element.active = e["active"];
-                if (e.value(sUrl,"") != "") {
-                    element.source = ProfileElementSource{
+                if (e.value(sUrl, "") != "") {
+                    element.source = ProfileElementSource {
                         parseFlakeRef(e[sOriginalUrl]),
                         parseFlakeRef(e[sUrl]),
-                        e["attrPath"]
+                        e["attrPath"],
+                        e["outputs"].get<OutputsSpec>()
                     };
                 }
                 elements.emplace_back(std::move(element));
@@ -157,6 +157,7 @@ struct ProfileManifest
                 obj["originalUrl"] = element.source->originalRef.to_string();
                 obj["url"] = element.source->resolvedRef.to_string();
                 obj["attrPath"] = element.source->attrPath;
+                obj["outputs"] = element.source->outputs;
             }
             array.push_back(obj);
         }
@@ -284,10 +285,11 @@ struct CmdProfileInstall : InstallablesCommand, MixDefaultProfile
             if (auto installable2 = std::dynamic_pointer_cast<InstallableFlake>(installable)) {
                 // FIXME: make build() return this?
                 auto [attrPath, resolvedRef, drv] = installable2->toDerivation();
-                element.source = ProfileElementSource{
+                element.source = ProfileElementSource {
                     installable2->flakeRef,
                     resolvedRef,
                     attrPath,
+                    installable2->outputsSpec
                 };
             }
 
@@ -444,6 +446,7 @@ struct CmdProfileUpgrade : virtual SourceExprCommand, MixDefaultProfile, MixProf
                     getEvalState(),
                     FlakeRef(element.source->originalRef),
                     "",
+                    element.source->outputs,
                     Strings{element.source->attrPath},
                     Strings{},
                     lockFlags);
@@ -455,10 +458,11 @@ struct CmdProfileUpgrade : virtual SourceExprCommand, MixDefaultProfile, MixProf
                 printInfo("upgrading '%s' from flake '%s' to '%s'",
                     element.source->attrPath, element.source->resolvedRef, resolvedRef);
 
-                element.source = ProfileElementSource{
+                element.source = ProfileElementSource {
                     installable->flakeRef,
                     resolvedRef,
                     attrPath,
+                    installable->outputsSpec
                 };
 
                 installables.push_back(installable);
@@ -514,8 +518,8 @@ struct CmdProfileList : virtual EvalCommand, virtual StoreCommand, MixDefaultPro
         for (size_t i = 0; i < manifest.elements.size(); ++i) {
             auto & element(manifest.elements[i]);
             logger->cout("%d %s %s %s", i,
-                element.source ? element.source->originalRef.to_string() + "#" + element.source->attrPath : "-",
-                element.source ? element.source->resolvedRef.to_string() + "#" + element.source->attrPath : "-",
+                element.source ? element.source->originalRef.to_string() + "#" + element.source->attrPath + printOutputsSpec(element.source->outputs) : "-",
+                element.source ? element.source->resolvedRef.to_string() + "#" + element.source->attrPath + printOutputsSpec(element.source->outputs) : "-",
                 concatStringsSep(" ", store->printStorePathSet(element.storePaths)));
         }
     }
diff --git a/src/nix/repl.cc b/src/nix/repl.cc
index 1f9d4fb4e..2967632ed 100644
--- a/src/nix/repl.cc
+++ b/src/nix/repl.cc
@@ -33,6 +33,7 @@ extern "C" {
 #include "command.hh"
 #include "finally.hh"
 #include "markdown.hh"
+#include "local-fs-store.hh"
 
 #if HAVE_BOEHMGC
 #define GC_INCLUDE_NEW
@@ -72,7 +73,7 @@ struct NixRepl
     void initEnv();
     void reloadFiles();
     void addAttrsToScope(Value & attrs);
-    void addVarToScope(const Symbol & name, Value & v);
+    void addVarToScope(const Symbol name, Value & v);
     Expr * parseString(std::string s);
     void evalString(std::string s, Value & v);
 
@@ -119,7 +120,7 @@ std::string runNix(Path program, const Strings & args,
     });
 
     if (!statusOk(res.first))
-        throw ExecError(res.first, fmt("program '%1%' %2%", program, statusToString(res.first)));
+        throw ExecError(res.first, "program '%1%' %2%", program, statusToString(res.first));
 
     return res.second;
 }
@@ -346,9 +347,9 @@ StringSet NixRepl::completePrefix(const std::string & prefix)
             state->forceAttrs(v, noPos);
 
             for (auto & i : *v.attrs) {
-                std::string name = i.name;
+                std::string_view name = state->symbols[i.name];
                 if (name.substr(0, cur2.size()) != cur2) continue;
-                completions.insert(prev + expr + "." + name);
+                completions.insert(concatStrings(prev, expr, ".", name));
             }
 
         } catch (ParseError & e) {
@@ -419,7 +420,8 @@ bool NixRepl::processLine(std::string line)
              << "  <expr>        Evaluate and print expression\n"
              << "  <x> = <expr>  Bind expression to variable\n"
              << "  :a <expr>     Add attributes from resulting set to scope\n"
-             << "  :b <expr>     Build derivation\n"
+             << "  :b <expr>     Build a derivation\n"
+             << "  :bl <expr>    Build a derivation, creating GC roots in the working directory\n"
              << "  :e <expr>     Open package or function in $EDITOR\n"
              << "  :i <expr>     Build derivation, then install result into current profile\n"
              << "  :l <path>     Load Nix expression and add it to scope\n"
@@ -459,21 +461,23 @@ bool NixRepl::processLine(std::string line)
         Value v;
         evalString(arg, v);
 
-        Pos pos;
-
-        if (v.type() == nPath || v.type() == nString) {
-            PathSet context;
-            auto filename = state->coerceToString(noPos, v, context);
-            pos.file = state->symbols.create(*filename);
-        } else if (v.isLambda()) {
-            pos = v.lambda.fun->pos;
-        } else {
-            // assume it's a derivation
-            pos = findPackageFilename(*state, v, arg);
-        }
+        const auto [file, line] = [&] () -> std::pair<std::string, uint32_t> {
+            if (v.type() == nPath || v.type() == nString) {
+                PathSet context;
+                auto filename = state->coerceToString(noPos, v, context).toOwned();
+                state->symbols.create(filename);
+                return {filename, 0};
+            } else if (v.isLambda()) {
+                auto pos = state->positions[v.lambda.fun->pos];
+                return {pos.file, pos.line};
+            } else {
+                // assume it's a derivation
+                return findPackageFilename(*state, v, arg);
+            }
+        }();
 
         // Open in EDITOR
-        auto args = editorFor(pos);
+        auto args = editorFor(file, line);
         auto editor = args.front();
         args.pop_front();
 
@@ -496,24 +500,32 @@ bool NixRepl::processLine(std::string line)
         Value v, f, result;
         evalString(arg, v);
         evalString("drv: (import <nixpkgs> {}).runCommand \"shell\" { buildInputs = [ drv ]; } \"\"", f);
-        state->callFunction(f, v, result, Pos());
+        state->callFunction(f, v, result, PosIdx());
 
         StorePath drvPath = getDerivationPath(result);
         runNix("nix-shell", {state->store->printStorePath(drvPath)});
     }
 
-    else if (command == ":b" || command == ":i" || command == ":s" || command == ":log") {
+    else if (command == ":b" || command == ":bl" || command == ":i" || command == ":s" || command == ":log") {
         Value v;
         evalString(arg, v);
         StorePath drvPath = getDerivationPath(v);
         Path drvPathRaw = state->store->printStorePath(drvPath);
 
-        if (command == ":b") {
+        if (command == ":b" || command == ":bl") {
             state->store->buildPaths({DerivedPath::Built{drvPath}});
             auto drv = state->store->readDerivation(drvPath);
             logger->cout("\nThis derivation produced the following outputs:");
-            for (auto & [outputName, outputPath] : state->store->queryDerivationOutputMap(drvPath))
-                logger->cout("  %s -> %s", outputName, state->store->printStorePath(outputPath));
+            for (auto & [outputName, outputPath] : state->store->queryDerivationOutputMap(drvPath)) {
+                auto localStore = state->store.dynamic_pointer_cast<LocalFSStore>();
+                if (localStore && command == ":bl") {
+                    std::string symlink = "repl-result-" + outputName;
+                    localStore->addPermRoot(outputPath, absPath(symlink));
+                    logger->cout("  ./%s -> %s", symlink, state->store->printStorePath(outputPath));
+                } else {
+                    logger->cout("  %s -> %s", outputName, state->store->printStorePath(outputPath));
+                }
+            }
         } else if (command == ":i") {
             runNix("nix-env", {"-i", drvPathRaw});
         } else if (command == ":log") {
@@ -661,7 +673,7 @@ void NixRepl::initEnv()
 
     varNames.clear();
     for (auto & i : state->staticBaseEnv.vars)
-        varNames.insert(i.first);
+        varNames.emplace(state->symbols[i.first]);
 }
 
 
@@ -691,7 +703,7 @@ void NixRepl::addAttrsToScope(Value & attrs)
     for (auto & i : *attrs.attrs) {
         staticEnv.vars.emplace_back(i.name, displ);
         env->values[displ++] = i.value;
-        varNames.insert((std::string) i.name);
+        varNames.emplace(state->symbols[i.name]);
     }
     staticEnv.sort();
     staticEnv.deduplicate();
@@ -699,7 +711,7 @@ void NixRepl::addAttrsToScope(Value & attrs)
 }
 
 
-void NixRepl::addVarToScope(const Symbol & name, Value & v)
+void NixRepl::addVarToScope(const Symbol name, Value & v)
 {
     if (displ >= envSize)
         throw Error("environment full; cannot add more variables");
@@ -708,7 +720,7 @@ void NixRepl::addVarToScope(const Symbol & name, Value & v)
     staticEnv.vars.emplace_back(name, displ);
     staticEnv.sort();
     env->values[displ++] = &v;
-    varNames.insert((std::string) name);
+    varNames.emplace(state->symbols[name]);
 }
 
 
@@ -789,7 +801,7 @@ std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int m
             Bindings::iterator i = v.attrs->find(state->sDrvPath);
             PathSet context;
             if (i != v.attrs->end())
-                str << state->store->printStorePath(state->coerceToStorePath(*i->pos, *i->value, context));
+                str << state->store->printStorePath(state->coerceToStorePath(i->pos, *i->value, context));
             else
                 str << "???";
             str << "»";
@@ -801,7 +813,7 @@ std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int m
             typedef std::map<std::string, Value *> Sorted;
             Sorted sorted;
             for (auto & i : *v.attrs)
-                sorted[i.name] = i.value;
+                sorted.emplace(state->symbols[i.name], i.value);
 
             for (auto & i : sorted) {
                 if (isVarName(i.first))
@@ -851,7 +863,7 @@ std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int m
     case nFunction:
         if (v.isLambda()) {
             std::ostringstream s;
-            s << v.lambda.fun->pos;
+            s << state->positions[v.lambda.fun->pos];
             str << ANSI_BLUE "«lambda @ " << filterANSIEscapes(s.str()) << "»" ANSI_NORMAL;
         } else if (v.isPrimOp()) {
             str << ANSI_MAGENTA "«primop»" ANSI_NORMAL;
diff --git a/src/nix/search.cc b/src/nix/search.cc
index e96a85ea2..87dc1c0de 100644
--- a/src/nix/search.cc
+++ b/src/nix/search.cc
@@ -9,7 +9,7 @@
 #include "shared.hh"
 #include "eval-cache.hh"
 #include "attr-path.hh"
-#include "fmt.hh"
+#include "hilite.hh"
 
 #include <regex>
 #include <fstream>
@@ -77,13 +77,15 @@ struct CmdSearch : InstallableCommand, MixJSON
 
         visit = [&](eval_cache::AttrCursor & cursor, const std::vector<Symbol> & attrPath, bool initialRecurse)
         {
+            auto attrPathS = state->symbols.resolve(attrPath);
+
             Activity act(*logger, lvlInfo, actUnknown,
-                fmt("evaluating '%s'", concatStringsSep(".", attrPath)));
+                fmt("evaluating '%s'", concatStringsSep(".", attrPathS)));
             try {
                 auto recurse = [&]()
                 {
                     for (const auto & attr : cursor.getAttrs()) {
-                        auto cursor2 = cursor.getAttr(attr);
+                        auto cursor2 = cursor.getAttr(state->symbols[attr]);
                         auto attrPath2(attrPath);
                         attrPath2.push_back(attr);
                         visit(*cursor2, attrPath2, false);
@@ -91,13 +93,13 @@ struct CmdSearch : InstallableCommand, MixJSON
                 };
 
                 if (cursor.isDerivation()) {
-                    DrvName name(cursor.getAttr("name")->getString());
+                    DrvName name(cursor.getAttr(state->sName)->getString());
 
-                    auto aMeta = cursor.maybeGetAttr("meta");
-                    auto aDescription = aMeta ? aMeta->maybeGetAttr("description") : nullptr;
+                    auto aMeta = cursor.maybeGetAttr(state->sMeta);
+                    auto aDescription = aMeta ? aMeta->maybeGetAttr(state->sDescription) : nullptr;
                     auto description = aDescription ? aDescription->getString() : "";
                     std::replace(description.begin(), description.end(), '\n', ' ');
-                    auto attrPath2 = concatStringsSep(".", attrPath);
+                    auto attrPath2 = concatStringsSep(".", attrPathS);
 
                     std::vector<std::smatch> attrPathMatches;
                     std::vector<std::smatch> descriptionMatches;
@@ -146,21 +148,21 @@ struct CmdSearch : InstallableCommand, MixJSON
 
                 else if (
                     attrPath.size() == 0
-                    || (attrPath[0] == "legacyPackages" && attrPath.size() <= 2)
-                    || (attrPath[0] == "packages" && attrPath.size() <= 2))
+                    || (attrPathS[0] == "legacyPackages" && attrPath.size() <= 2)
+                    || (attrPathS[0] == "packages" && attrPath.size() <= 2))
                     recurse();
 
                 else if (initialRecurse)
                     recurse();
 
-                else if (attrPath[0] == "legacyPackages" && attrPath.size() > 2) {
+                else if (attrPathS[0] == "legacyPackages" && attrPath.size() > 2) {
                     auto attr = cursor.maybeGetAttr(state->sRecurseForDerivations);
                     if (attr && attr->getBool())
                         recurse();
                 }
 
             } catch (EvalError & e) {
-                if (!(attrPath.size() > 0 && attrPath[0] == "legacyPackages"))
+                if (!(attrPath.size() > 0 && attrPathS[0] == "legacyPackages"))
                     throw;
             }
         };
diff --git a/src/resolve-system-dependencies/resolve-system-dependencies.cc b/src/resolve-system-dependencies/resolve-system-dependencies.cc
index 4dd691981..c6023eb03 100644
--- a/src/resolve-system-dependencies/resolve-system-dependencies.cc
+++ b/src/resolve-system-dependencies/resolve-system-dependencies.cc
@@ -176,7 +176,7 @@ int main(int argc, char ** argv)
             impurePaths.insert(argv[2]);
         else {
             auto drv = store->derivationFromPath(store->parseStorePath(argv[1]));
-            impurePaths = tokenizeString<StringSet>(get(drv.env, "__impureHostDeps").value_or(""));
+            impurePaths = tokenizeString<StringSet>(getOr(drv.env, "__impureHostDeps", ""));
             impurePaths.insert("/usr/lib/libSystem.dylib");
         }