15 files changed, 1154 insertions, 229 deletions

diff --git a/src/libcmd/command.cc b/src/libcmd/command.cc
index f28cfe5de..56d529461 100644
--- a/src/libcmd/command.cc
+++ b/src/libcmd/command.cc
@@ -86,6 +86,11 @@ ref<Store> CopyCommand::getDstStore()
 
 EvalCommand::EvalCommand()
 {
+    addFlag({
+        .longName = "debugger",
+        .description = "start an interactive environment if evaluation fails",
+        .handler = {&startReplOnEvalErrors, true},
+    });
 }
 
 EvalCommand::~EvalCommand()
@@ -103,7 +108,7 @@ ref<Store> EvalCommand::getEvalStore()
 
 ref<EvalState> EvalCommand::getEvalState()
 {
-    if (!evalState)
+    if (!evalState) {
         evalState =
             #if HAVE_BOEHMGC
             std::allocate_shared<EvalState>(traceable_allocator<EvalState>(),
@@ -113,6 +118,32 @@ ref<EvalState> EvalCommand::getEvalState()
                 searchPath, getEvalStore(), getStore())
             #endif
             ;
+        if (startReplOnEvalErrors)
+            debuggerHook = [evalState{ref<EvalState>(evalState)}](const Error * error, const Env & env, const Expr & expr) {
+                auto dts =
+                    error && expr.getPos() ?
+                          std::unique_ptr<DebugTraceStacker>(
+                              new DebugTraceStacker(
+                                  *evalState,
+                                  DebugTrace
+                                        {.pos = (error->info().errPos ? *error->info().errPos : evalState->positions[expr.getPos()]),
+                                         .expr = expr,
+                                         .env = env,
+                                         .hint = error->info().msg,
+                                         .is_error = true
+                                        }))
+                          : nullptr;
+
+                if (error)
+                    printError("%s\n\n" ANSI_BOLD "Starting REPL to allow you to inspect the current state of the evaluator.\n" ANSI_NORMAL, error->what());
+
+                if (expr.staticenv)
+                {
+                    std::unique_ptr<valmap> vm(mapStaticEnvBindings(evalState->symbols, *expr.staticenv.get(), env));
+                    runRepl(evalState, expr, *vm);
+                }
+            };
+    }
     return ref<EvalState>(evalState);
 }
 
diff --git a/src/libcmd/command.hh b/src/libcmd/command.hh
index 078e2a2ce..db4d4c023 100644
--- a/src/libcmd/command.hh
+++ b/src/libcmd/command.hh
@@ -57,6 +57,8 @@ struct CopyCommand : virtual StoreCommand
 
 struct EvalCommand : virtual StoreCommand, MixEvalArgs
 {
+    bool startReplOnEvalErrors = false;
+
     EvalCommand();
 
     ~EvalCommand();
@@ -270,4 +272,9 @@ void printClosureDiff(
     const StorePath & afterPath,
     std::string_view indent);
 
+
+void runRepl(
+    ref<EvalState> evalState,
+    const Expr &expr,
+    const std::map<std::string, Value *> & extraEnv);
 }
diff --git a/src/libcmd/local.mk b/src/libcmd/local.mk
index 7a2f83cc7..3a4de6bcb 100644
--- a/src/libcmd/local.mk
+++ b/src/libcmd/local.mk
@@ -6,9 +6,9 @@ libcmd_DIR := $(d)
 
 libcmd_SOURCES := $(wildcard $(d)/*.cc)
 
-libcmd_CXXFLAGS += -I src/libutil -I src/libstore -I src/libexpr -I src/libmain -I src/libfetchers
+libcmd_CXXFLAGS += -I src/libutil -I src/libstore -I src/libexpr -I src/libmain -I src/libfetchers -I src/nix
 
-libcmd_LDFLAGS += $(LOWDOWN_LIBS) -pthread
+libcmd_LDFLAGS = $(EDITLINE_LIBS) -llowdown -pthread
 
 libcmd_LIBS = libstore libutil libexpr libmain libfetchers
 
diff --git a/src/nix/repl.cc b/src/libcmd/repl.cc
index 2967632ed..b94831064 100644
--- a/src/nix/repl.cc
+++ b/src/libcmd/repl.cc
@@ -48,20 +48,22 @@ struct NixRepl
     #endif
 {
     std::string curDir;
-    std::unique_ptr<EvalState> state;
+    ref<EvalState> state;
     Bindings * autoArgs;
 
+    int debugTraceIndex;
+
     Strings loadedFiles;
 
     const static int envSize = 32768;
-    StaticEnv staticEnv;
+    std::shared_ptr<StaticEnv> staticEnv;
     Env * env;
     int displ;
     StringSet varNames;
 
     const Path historyFile;
 
-    NixRepl(const Strings & searchPath, nix::ref<Store> store);
+    NixRepl(ref<EvalState> state);
     ~NixRepl();
     void mainLoop(const std::vector<std::string> & files);
     StringSet completePrefix(const std::string & prefix);
@@ -71,15 +73,17 @@ struct NixRepl
     void loadFile(const Path & path);
     void loadFlake(const std::string & flakeRef);
     void initEnv();
+    void loadFiles();
     void reloadFiles();
     void addAttrsToScope(Value & attrs);
     void addVarToScope(const Symbol name, Value & v);
     Expr * parseString(std::string s);
     void evalString(std::string s, Value & v);
+    void loadDebugTraceEnv(DebugTrace &dt);
 
     typedef std::set<Value *> ValuesSeen;
-    std::ostream &  printValue(std::ostream & str, Value & v, unsigned int maxDepth);
-    std::ostream &  printValue(std::ostream & str, Value & v, unsigned int maxDepth, ValuesSeen & seen);
+    std::ostream & printValue(std::ostream & str, Value & v, unsigned int maxDepth);
+    std::ostream & printValue(std::ostream & str, Value & v, unsigned int maxDepth, ValuesSeen & seen);
 };
 
 
@@ -92,9 +96,10 @@ std::string removeWhitespace(std::string s)
 }
 
 
-NixRepl::NixRepl(const Strings & searchPath, nix::ref<Store> store)
-    : state(std::make_unique<EvalState>(searchPath, store))
-    , staticEnv(false, &state->staticBaseEnv)
+NixRepl::NixRepl(ref<EvalState> state)
+    : state(state)
+    , debugTraceIndex(0)
+    , staticEnv(new StaticEnv(false, state->staticBaseEnv.get()))
     , historyFile(getDataDir() + "/nix/repl-history")
 {
     curDir = absPath(".");
@@ -198,15 +203,41 @@ namespace {
     }
 }
 
+std::ostream& showDebugTrace(std::ostream &out, const PosTable &positions, const DebugTrace &dt)
+{
+    if (dt.is_error)
+        out << ANSI_RED "error: " << ANSI_NORMAL;
+    out << dt.hint.str() << "\n";
+
+    // prefer direct pos, but if noPos then try the expr.
+    auto pos = (*dt.pos ? *dt.pos :
+       positions[(dt.expr.getPos() ? dt.expr.getPos() : noPos)]);
+
+    if (pos) {
+        printAtPos(pos, out);
+
+        auto loc = getCodeLines(pos);
+        if (loc.has_value()) {
+            out << "\n";
+            printCodeLines(out, "", pos, *loc);
+            out << "\n";
+        }
+    }
+
+    return out;
+}
+
 void NixRepl::mainLoop(const std::vector<std::string> & files)
 {
     std::string error = ANSI_RED "error:" ANSI_NORMAL " ";
     notice("Welcome to Nix " + nixVersion + ". Type :? for help.\n");
 
-    for (auto & i : files)
-        loadedFiles.push_back(i);
+    if (!files.empty()) {
+        for (auto & i : files)
+            loadedFiles.push_back(i);
+    }
 
-    reloadFiles();
+    loadFiles();
     if (!loadedFiles.empty()) notice("");
 
     // Allow nix-repl specific settings in .inputrc
@@ -228,8 +259,12 @@ void NixRepl::mainLoop(const std::vector<std::string> & files)
         // When continuing input from previous lines, don't print a prompt, just align to the same
         // number of chars as the prompt.
         if (!getLine(input, input.empty() ? "nix-repl> " : "          "))
+        {
+            // ctrl-D should exit the debugger.
+            state->debugStop = false;
+            state->debugQuit = true;
             break;
-
+        }
         try {
             if (!removeWhitespace(input).empty() && !processLine(input)) return;
         } catch (ParseError & e) {
@@ -240,6 +275,14 @@ void NixRepl::mainLoop(const std::vector<std::string> & files)
             } else {
               printMsg(lvlError, e.msg());
             }
+        } catch (EvalError & e) {
+            // in debugger mode, an EvalError should trigger another repl session.
+            // when that session returns the exception will land here.  No need to show it again;
+            // show the error for this repl session instead.
+            if (debuggerHook && !this->state->debugTraces.empty())
+                showDebugTrace(std::cout, this->state->positions, this->state->debugTraces.front());
+            else
+                printMsg(lvlError, e.msg());
         } catch (Error & e) {
             printMsg(lvlError, e.msg());
         } catch (Interrupted & e) {
@@ -394,6 +437,24 @@ StorePath NixRepl::getDerivationPath(Value & v) {
     return *drvPath;
 }
 
+void NixRepl::loadDebugTraceEnv(DebugTrace &dt)
+{
+    if (dt.expr.staticenv)
+    {
+        initEnv();
+
+        auto vm = std::make_unique<valmap>(*(mapStaticEnvBindings(this->state->symbols, *dt.expr.staticenv.get(), dt.env)));
+
+        // add staticenv vars.
+        for (auto & [name, value] : *(vm.get())) {
+            this->addVarToScope(this->state->symbols.create(name), *value);
+        }
+    }
+    else
+    {
+        initEnv();
+    }
+}
 
 bool NixRepl::processLine(std::string line)
 {
@@ -434,7 +495,73 @@ bool NixRepl::processLine(std::string line)
              << "  :u <expr>     Build derivation, then start nix-shell\n"
              << "  :doc <expr>   Show documentation of a builtin function\n"
              << "  :log <expr>   Show logs for a derivation\n"
-             << "  :st [bool]    Enable, disable or toggle showing traces for errors\n";
+             << "  :st [bool]    Enable, disable or toggle showing traces for errors\n"
+             << "  :d <cmd>      Debug mode commands\n"
+             << "  :d stack      Show trace stack\n"
+             << "  :d env        Show env stack\n"
+             << "  :d show       Show current trace\n"
+             << "  :d show <idx> Change to another trace in the stack\n"
+             << "  :d go         Go until end of program, exception, or builtins.break().\n"
+             << "  :d step       Go one step\n"
+             ;
+
+    }
+
+    else if (command == ":d" || command == ":debug") {
+        if (arg == "stack") {
+            int idx = 0;
+            for (auto iter = this->state->debugTraces.begin();
+                 iter !=  this->state->debugTraces.end();
+                 ++iter, ++idx) {
+                 std::cout << "\n" << ANSI_BLUE << idx << ANSI_NORMAL << ": ";
+                 showDebugTrace(std::cout, this->state->positions, *iter);
+            }
+        } else if (arg == "env") {
+            int idx = 0;
+            for (auto iter = this->state->debugTraces.begin();
+                 iter !=  this->state->debugTraces.end();
+                 ++iter, ++idx) {
+                 if (idx == this->debugTraceIndex)
+                 {
+                     printEnvBindings(state->symbols,iter->expr, iter->env);
+                     break;
+                 }
+            }
+        }
+        else if (arg.compare(0,4,"show") == 0) {
+            try {
+                // change the DebugTrace index.
+                debugTraceIndex = stoi(arg.substr(4));
+            }
+            catch (...)
+            {
+            }
+
+            int idx = 0;
+            for (auto iter = this->state->debugTraces.begin();
+                 iter !=  this->state->debugTraces.end();
+                 ++iter, ++idx) {
+                 if (idx == this->debugTraceIndex)
+                 {
+                     std::cout << "\n" << ANSI_BLUE << idx << ANSI_NORMAL << ": ";
+                     showDebugTrace(std::cout, this->state->positions, *iter);
+                     std::cout << std::endl;
+                     printEnvBindings(state->symbols,iter->expr, iter->env);
+                     loadDebugTraceEnv(*iter);
+                     break;
+                 }
+            }
+        }
+        else if (arg == "step") {
+            // set flag to stop at next DebugTrace; exit repl.
+            state->debugStop = true;
+            return false;
+        }
+        else if (arg == "go") {
+            // set flag to run to next breakpoint or end of program; exit repl.
+            state->debugStop = false;
+            return false;
+        }
     }
 
     else if (command == ":a" || command == ":add") {
@@ -567,8 +694,11 @@ bool NixRepl::processLine(std::string line)
         printValue(std::cout, v, 1000000000) << std::endl;
     }
 
-    else if (command == ":q" || command == ":quit")
+    else if (command == ":q" || command == ":quit") {
+        state->debugStop = false;
+        state->debugQuit = true;
         return false;
+    }
 
     else if (command == ":doc") {
         Value v;
@@ -669,10 +799,10 @@ void NixRepl::initEnv()
     env = &state->allocEnv(envSize);
     env->up = &state->baseEnv;
     displ = 0;
-    staticEnv.vars.clear();
+    staticEnv->vars.clear();
 
     varNames.clear();
-    for (auto & i : state->staticBaseEnv.vars)
+    for (auto & i : state->staticBaseEnv->vars)
         varNames.emplace(state->symbols[i.first]);
 }
 
@@ -681,6 +811,12 @@ void NixRepl::reloadFiles()
 {
     initEnv();
 
+    loadFiles();
+}
+
+
+void NixRepl::loadFiles()
+{
     Strings old = loadedFiles;
     loadedFiles.clear();
 
@@ -701,12 +837,12 @@ void NixRepl::addAttrsToScope(Value & attrs)
         throw Error("environment full; cannot add more variables");
 
     for (auto & i : *attrs.attrs) {
-        staticEnv.vars.emplace_back(i.name, displ);
+        staticEnv->vars.emplace_back(i.name, displ);
         env->values[displ++] = i.value;
         varNames.emplace(state->symbols[i.name]);
     }
-    staticEnv.sort();
-    staticEnv.deduplicate();
+    staticEnv->sort();
+    staticEnv->deduplicate();
     notice("Added %1% variables.", attrs.attrs->size());
 }
 
@@ -715,10 +851,10 @@ void NixRepl::addVarToScope(const Symbol name, Value & v)
 {
     if (displ >= envSize)
         throw Error("environment full; cannot add more variables");
-    if (auto oldVar = staticEnv.find(name); oldVar != staticEnv.vars.end())
-        staticEnv.vars.erase(oldVar);
-    staticEnv.vars.emplace_back(name, displ);
-    staticEnv.sort();
+    if (auto oldVar = staticEnv->find(name); oldVar != staticEnv->vars.end())
+        staticEnv->vars.erase(oldVar);
+    staticEnv->vars.emplace_back(name, displ);
+    staticEnv->sort();
     env->values[displ++] = &v;
     varNames.emplace(state->symbols[name]);
 }
@@ -886,6 +1022,23 @@ std::ostream & NixRepl::printValue(std::ostream & str, Value & v, unsigned int m
     return str;
 }
 
+void runRepl(
+    ref<EvalState> evalState,
+    const Expr &expr,
+    const std::map<std::string, Value *> & extraEnv)
+{
+    auto repl = std::make_unique<NixRepl>(evalState);
+
+    repl->initEnv();
+
+    // add 'extra' vars.
+    for (auto & [name, value] : extraEnv) {
+        repl->addVarToScope(repl->state->symbols.create(name), *value);
+    }
+
+    repl->mainLoop({});
+}
+
 struct CmdRepl : StoreCommand, MixEvalArgs
 {
     std::vector<std::string> files;
@@ -914,8 +1067,12 @@ struct CmdRepl : StoreCommand, MixEvalArgs
     void run(ref<Store> store) override
     {
         evalSettings.pureEval = false;
-        auto repl = std::make_unique<NixRepl>(searchPath, openStore());
+
+        auto evalState = make_ref<EvalState>(searchPath, store);
+
+        auto repl = std::make_unique<NixRepl>(evalState);
         repl->autoArgs = getAutoArgs(*repl->state);
+        repl->initEnv();
         repl->mainLoop(files);
     }
 };
diff --git a/src/libexpr/eval-cache.cc b/src/libexpr/eval-cache.cc
index a1cb162ee..ed9af78b3 100644
--- a/src/libexpr/eval-cache.cc
+++ b/src/libexpr/eval-cache.cc
@@ -554,14 +554,22 @@ std::string AttrCursor::getString()
                 debug("using cached string attribute '%s'", getAttrPathStr());
                 return s->first;
             } else
-                throw TypeError("'%s' is not a string", getAttrPathStr());
+            {
+                auto e = TypeError("'%s' is not a string", getAttrPathStr());
+                root->state.debugLastTrace(e);
+                throw e;
+            }
         }
     }
 
     auto & v = forceValue();
 
     if (v.type() != nString && v.type() != nPath)
-        throw TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type()));
+    {
+        auto e = TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type()));
+        root->state.debugLastTrace(e);
+        throw e;
+    }
 
     return v.type() == nString ? v.string.s : v.path;
 }
@@ -585,7 +593,11 @@ string_t AttrCursor::getStringWithContext()
                     return *s;
                 }
             } else
-                throw TypeError("'%s' is not a string", getAttrPathStr());
+            {
+                auto e = TypeError("'%s' is not a string", getAttrPathStr());
+                root->state.debugLastTrace(e);
+                throw e;
+            }
         }
     }
 
@@ -596,7 +608,12 @@ string_t AttrCursor::getStringWithContext()
     else if (v.type() == nPath)
         return {v.path, {}};
     else
-        throw TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type()));
+    {
+        auto e = TypeError("'%s' is not a string but %s", getAttrPathStr(), showType(v.type()));
+        root->state.debugLastTrace(e);
+        throw e;
+        return {v.path, {}}; // should never execute
+    }
 }
 
 bool AttrCursor::getBool()
@@ -609,14 +626,22 @@ bool AttrCursor::getBool()
                 debug("using cached Boolean attribute '%s'", getAttrPathStr());
                 return *b;
             } else
-                throw TypeError("'%s' is not a Boolean", getAttrPathStr());
+            {
+                auto e = TypeError("'%s' is not a Boolean", getAttrPathStr());
+                root->state.debugLastTrace(e);
+                throw e;
+            }
         }
     }
 
     auto & v = forceValue();
 
     if (v.type() != nBool)
-        throw TypeError("'%s' is not a Boolean", getAttrPathStr());
+    {
+        auto e = TypeError("'%s' is not a Boolean", getAttrPathStr());
+        root->state.debugLastTrace(e);
+        throw e;
+    }
 
     return v.boolean;
 }
@@ -663,14 +688,22 @@ std::vector<Symbol> AttrCursor::getAttrs()
                 debug("using cached attrset attribute '%s'", getAttrPathStr());
                 return *attrs;
             } else
-                throw TypeError("'%s' is not an attribute set", getAttrPathStr());
+            {
+                auto e = TypeError("'%s' is not an attribute set", getAttrPathStr());
+                root->state.debugLastTrace(e);
+                throw e;
+            }
         }
     }
 
     auto & v = forceValue();
 
     if (v.type() != nAttrs)
-        throw TypeError("'%s' is not an attribute set", getAttrPathStr());
+    {
+        auto e = TypeError("'%s' is not an attribute set", getAttrPathStr());
+        root->state.debugLastTrace(e);
+        throw e;
+    }
 
     std::vector<Symbol> attrs;
     for (auto & attr : *getValue().attrs)
diff --git a/src/libexpr/eval-inline.hh b/src/libexpr/eval-inline.hh
index 7f01d08e3..f2f4ba725 100644
--- a/src/libexpr/eval-inline.hh
+++ b/src/libexpr/eval-inline.hh
@@ -4,7 +4,6 @@
 
 namespace nix {
 
-
 /* Note: Various places expect the allocated memory to be zeroed. */
 [[gnu::always_inline]]
 inline void * allocBytes(size_t n)
diff --git a/src/libexpr/eval.cc b/src/libexpr/eval.cc
index ef167087b..10dba69e7 100644
--- a/src/libexpr/eval.cc
+++ b/src/libexpr/eval.cc
@@ -18,6 +18,7 @@
 #include <sys/resource.h>
 #include <iostream>
 #include <fstream>
+#include <functional>
 
 #include <sys/resource.h>
 
@@ -36,7 +37,6 @@
 
 namespace nix {
 
-
 static char * allocString(size_t size)
 {
     char * t;
@@ -455,6 +455,8 @@ EvalState::EvalState(
     , emptyBindings(0)
     , store(store)
     , buildStore(buildStore ? buildStore : store)
+    , debugStop(false)
+    , debugQuit(false)
     , regexCache(makeRegexCache())
 #if HAVE_BOEHMGC
     , valueAllocCache(std::allocate_shared<void *>(traceable_allocator<void *>(), nullptr))
@@ -464,7 +466,7 @@ EvalState::EvalState(
     , env1AllocCache(std::make_shared<void *>(nullptr))
 #endif
     , baseEnv(allocEnv(128))
-    , staticBaseEnv(false, 0)
+    , staticBaseEnv(new StaticEnv(false, 0))
 {
     countCalls = getEnv("NIX_COUNT_CALLS").value_or("0") != "0";
 
@@ -630,7 +632,7 @@ Value * EvalState::addConstant(const std::string & name, Value & v)
 
 void EvalState::addConstant(const std::string & name, Value * v)
 {
-    staticBaseEnv.vars.emplace_back(symbols.create(name), baseEnvDispl);
+    staticBaseEnv->vars.emplace_back(symbols.create(name), baseEnvDispl);
     baseEnv.values[baseEnvDispl++] = v;
     auto name2 = name.substr(0, 2) == "__" ? name.substr(2) : name;
     baseEnv.values[0]->attrs->push_back(Attr(symbols.create(name2), v));
@@ -655,7 +657,7 @@ Value * EvalState::addPrimOp(const std::string & name,
 
     Value * v = allocValue();
     v->mkPrimOp(new PrimOp { .fun = primOp, .arity = arity, .name = name2 });
-    staticBaseEnv.vars.emplace_back(symbols.create(name), baseEnvDispl);
+    staticBaseEnv->vars.emplace_back(symbols.create(name), baseEnvDispl);
     baseEnv.values[baseEnvDispl++] = v;
     baseEnv.values[0]->attrs->push_back(Attr(sym, v));
     return v;
@@ -681,7 +683,7 @@ Value * EvalState::addPrimOp(PrimOp && primOp)
 
     Value * v = allocValue();
     v->mkPrimOp(new PrimOp(primOp));
-    staticBaseEnv.vars.emplace_back(envName, baseEnvDispl);
+    staticBaseEnv->vars.emplace_back(envName, baseEnvDispl);
     baseEnv.values[baseEnvDispl++] = v;
     baseEnv.values[0]->attrs->push_back(Attr(symbols.create(primOp.name), v));
     return v;
@@ -711,128 +713,367 @@ std::optional<EvalState::Doc> EvalState::getDoc(Value & v)
 }
 
 
+// just for the current level of StaticEnv, not the whole chain.
+void printStaticEnvBindings(const SymbolTable &st, const StaticEnv &se)
+{
+    std::cout << ANSI_MAGENTA;
+    for (auto i = se.vars.begin(); i != se.vars.end(); ++i)
+    {
+      std::cout << st[i->first] << " ";
+    }
+    std::cout << ANSI_NORMAL;
+    std::cout << std::endl;
+}
+
+// just for the current level of Env, not the whole chain.
+void printWithBindings(const SymbolTable &st, const Env &env)
+{
+    if (env.type == Env::HasWithAttrs)
+    {
+        std::cout << "with: ";
+        std::cout << ANSI_MAGENTA;
+        Bindings::iterator j = env.values[0]->attrs->begin();
+        while (j != env.values[0]->attrs->end()) {
+            std::cout << st[j->name] << " ";
+            ++j;
+        }
+        std::cout << ANSI_NORMAL;
+        std::cout << std::endl;
+    }
+}
+
+void printEnvBindings(const SymbolTable &st, const StaticEnv &se, const Env &env, int lvl)
+{
+    std::cout << "Env level " << lvl << std::endl;
+
+    if (se.up && env.up) {
+        std::cout << "static: ";
+        printStaticEnvBindings(st, se);
+        printWithBindings(st, env);
+        std::cout << std::endl;
+        printEnvBindings(st, *se.up, *env.up, ++lvl);
+    }
+    else
+    {
+        std::cout << ANSI_MAGENTA;
+        // for the top level, don't print the double underscore ones; they are in builtins.
+        for (auto i = se.vars.begin(); i != se.vars.end(); ++i)
+        {
+            if (((std::string)st[i->first]).substr(0,2) != "__")
+                std::cout << st[i->first] << " ";
+        }
+        std::cout << ANSI_NORMAL;
+        std::cout << std::endl;
+        printWithBindings(st, env);  // probably nothing there for the top level.
+        std::cout << std::endl;
+
+    }
+}
+
+// TODO: add accompanying env for With stuff.
+void printEnvBindings(const SymbolTable &st, const Expr &expr, const Env &env)
+{
+    // just print the names for now
+    if (expr.staticenv)
+    {
+      printEnvBindings(st, *expr.staticenv.get(), env, 0);
+    }
+}
+
+void mapStaticEnvBindings(const SymbolTable &st, const StaticEnv &se, const Env &env, valmap & vm)
+{
+  // add bindings for the next level up first, so that the bindings for this level
+  // override the higher levels.
+  // The top level bindings (builtins) are skipped since they are added for us by initEnv()
+  if (env.up && se.up) {
+      mapStaticEnvBindings(st, *se.up, *env.up, vm);
+
+      if (env.type == Env::HasWithAttrs)
+      {
+          // add 'with' bindings.
+          Bindings::iterator j = env.values[0]->attrs->begin();
+          while (j != env.values[0]->attrs->end()) {
+              vm[st[j->name]] = j->value;
+              ++j;
+          }
+      }
+      else
+      {
+          // iterate through staticenv bindings and add them.
+          for (auto iter = se.vars.begin(); iter != se.vars.end(); ++iter)
+          {
+              vm[st[iter->first]] = env.values[iter->second];
+          }
+      }
+  }
+}
+
+valmap * mapStaticEnvBindings(const SymbolTable &st,const StaticEnv &se, const Env &env)
+{
+    auto vm = new valmap();
+    mapStaticEnvBindings(st, se, env, *vm);
+    return vm;
+}
+
+
+void EvalState::debugLastTrace(Error & e) const {
+    // call this in the situation where Expr and Env are inaccessible.  The debugger will start in the last context
+    // that's in the DebugTrace stack.
+    if (debuggerHook && !debugTraces.empty()) {
+        const DebugTrace &last = debugTraces.front();
+        debuggerHook(&e, last.env, last.expr);
+    }
+}
+
 /* Every "format" object (even temporary) takes up a few hundred bytes
    of stack space, which is a real killer in the recursive
    evaluator.  So here are some helper functions for throwing
    exceptions. */
-
-void EvalState::throwEvalError(const PosIdx pos, const char * s) const
+void EvalState::throwEvalError(const PosIdx pos, const char * s, Env & env, Expr &expr) const
 {
-    throw EvalError({
+    auto error = EvalError({
         .msg = hintfmt(s),
         .errPos = positions[pos]
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
-void EvalState::throwTypeError(const PosIdx pos, const char * s, const Value & v) const
+void EvalState::throwEvalError(const PosIdx pos, const char * s) const
 {
-    throw TypeError({
-        .msg = hintfmt(s, showType(v)),
+    auto error = EvalError({
+        .msg = hintfmt(s),
         .errPos = positions[pos]
     });
+
+    debugLastTrace(error);
+
+    throw error;
 }
 
 void EvalState::throwEvalError(const char * s, const std::string & s2) const
 {
-    throw EvalError(s, s2);
+    auto error = EvalError(s, s2);
+
+    debugLastTrace(error);
+
+    throw error;
 }
 
 void EvalState::throwEvalError(const PosIdx pos, const Suggestions & suggestions, const char * s,
-    const std::string & s2) const
+    const std::string & s2, Env & env, Expr &expr) const
 {
-    throw EvalError(ErrorInfo {
+    auto error = EvalError(ErrorInfo{
         .msg = hintfmt(s, s2),
         .errPos = positions[pos],
         .suggestions = suggestions,
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
 void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2) const
 {
-    throw EvalError(ErrorInfo {
+    auto error = EvalError({
         .msg = hintfmt(s, s2),
         .errPos = positions[pos]
     });
+
+    debugLastTrace(error);
+
+    throw error;
 }
 
-void EvalState::throwEvalError(const char * s, const std::string & s2, const std::string & s3) const
+void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2, Env & env, Expr &expr) const
 {
-    throw EvalError(s, s2, s3);
+    auto error = EvalError({
+        .msg = hintfmt(s, s2),
+        .errPos = positions[pos]
+    });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+
+    throw error;
+}
+
+void EvalState::throwEvalError(const char * s, const std::string & s2,
+    const std::string & s3) const
+{
+    auto error = EvalError({
+        .msg = hintfmt(s, s2),
+        .errPos = positions[noPos]
+    });
+
+    debugLastTrace(error);
+
+    throw error;
 }
 
 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),
+    auto error = EvalError({
+        .msg = hintfmt(s, s2),
+        .errPos = positions[pos]
+    });
+
+    debugLastTrace(error);
+
+    throw error;
+}
+
+void EvalState::throwEvalError(const PosIdx pos, const char * s, const std::string & s2,
+    const std::string & s3, Env & env, Expr &expr) const
+{
+    auto error = EvalError({
+        .msg = hintfmt(s, s2),
         .errPos = positions[pos]
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
-void EvalState::throwEvalError(const PosIdx p1, const char * s, const Symbol sym, const PosIdx p2) const
+void EvalState::throwEvalError(const PosIdx p1, const char * s, const Symbol sym, const PosIdx p2, Env & env, Expr &expr) const
 {
     // p1 is where the error occurred; p2 is a position mentioned in the message.
-    throw EvalError({
+    auto error = EvalError({
         .msg = hintfmt(s, symbols[sym], positions[p2]),
         .errPos = positions[p1]
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
+}
+
+void EvalState::throwTypeError(const PosIdx pos, const char * s, const Value & v) const
+{
+    auto error = TypeError({
+        .msg = hintfmt(s, showType(v)),
+        .errPos = positions[pos]
+    });
+
+    debugLastTrace(error);
+
+    throw error;
+}
+
+void EvalState::throwTypeError(const PosIdx pos, const char * s, const Value & v, Env & env, Expr &expr) const
+{
+    auto error = TypeError({
+        .msg = hintfmt(s, showType(v)),
+        .errPos = positions[pos]
+    });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
 void EvalState::throwTypeError(const PosIdx pos, const char * s) const
 {
-    throw TypeError({
+    auto error = TypeError({
         .msg = hintfmt(s),
         .errPos = positions[pos]
     });
+
+    debugLastTrace(error);
+
+    throw error;
 }
 
 void EvalState::throwTypeError(const PosIdx pos, const char * s, const ExprLambda & fun,
-    const Symbol s2) const
+    const Symbol s2, Env & env, Expr &expr) const
 {
-    throw TypeError({
+    auto error = TypeError({
         .msg = hintfmt(s, fun.showNamePos(*this), symbols[s2]),
         .errPos = positions[pos]
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
 void EvalState::throwTypeError(const PosIdx pos, const Suggestions & suggestions, const char * s,
-    const ExprLambda & fun, const Symbol s2) const
+    const ExprLambda & fun, const Symbol s2, Env & env, Expr &expr) const
 {
-    throw TypeError(ErrorInfo {
+    auto error = TypeError(ErrorInfo {
         .msg = hintfmt(s, fun.showNamePos(*this), symbols[s2]),
         .errPos = positions[pos],
         .suggestions = suggestions,
     });
-}
 
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
 
-void EvalState::throwTypeError(const char * s, const Value & v) const
+    throw error;
+}
+
+void EvalState::throwTypeError(const char * s, const Value & v, Env & env, Expr &expr) const
 {
-    throw TypeError(s, showType(v));
+    auto error = TypeError({
+        .msg = hintfmt(s, showType(v)),
+        .errPos = positions[expr.getPos()],
+    });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
-void EvalState::throwAssertionError(const PosIdx pos, const char * s, const std::string & s1) const
+void EvalState::throwAssertionError(const PosIdx pos, const char * s, const std::string & s1, Env & env, Expr &expr) const
 {
-    throw AssertionError({
+    auto error = AssertionError({
         .msg = hintfmt(s, s1),
         .errPos = positions[pos]
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
-void EvalState::throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1) const
+void EvalState::throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1, Env & env, Expr &expr) const
 {
-    throw UndefinedVarError({
+    auto error = UndefinedVarError({
         .msg = hintfmt(s, s1),
         .errPos = positions[pos]
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
-void EvalState::throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1) const
+void EvalState::throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1, Env & env, Expr &expr) const
 {
-    throw MissingArgumentError({
+    auto error = MissingArgumentError({
         .msg = hintfmt(s, s1),
         .errPos = positions[pos]
     });
+
+    if (debuggerHook)
+        debuggerHook(&error, env, expr);
+
+    throw error;
 }
 
 void EvalState::addErrorTrace(Error & e, const char * s, const std::string & s2) const
@@ -845,6 +1086,28 @@ void EvalState::addErrorTrace(Error & e, const PosIdx pos, const char * s, const
     e.addTrace(positions[pos], s, s2);
 }
 
+std::unique_ptr<DebugTraceStacker> makeDebugTraceStacker(EvalState &state, Expr &expr, Env &env,
+    std::optional<ErrPos> pos, const char * s, const std::string & s2)
+{
+  return std::unique_ptr<DebugTraceStacker>(
+      new DebugTraceStacker(
+          state,
+          DebugTrace
+                {.pos = pos,
+                 .expr = expr,
+                 .env = env,
+                 .hint = hintfmt(s, s2),
+                 .is_error = false
+                }));
+}
+
+DebugTraceStacker::DebugTraceStacker(EvalState &evalState, DebugTrace t)
+:evalState(evalState), trace(t)
+{
+    evalState.debugTraces.push_front(t);
+    if (evalState.debugStop && debuggerHook)
+        debuggerHook(0, t.env, t.expr);
+}
 
 void Value::mkString(std::string_view s)
 {
@@ -903,12 +1166,11 @@ inline Value * EvalState::lookupVar(Env * env, const ExprVar & var, bool noEval)
             return j->value;
         }
         if (!env->prevWith)
-            throwUndefinedVarError(var.pos, "undefined variable '%1%'", symbols[var.name]);
+            throwUndefinedVarError(var.pos, "undefined variable '%1%'", symbols[var.name], *env, const_cast<ExprVar&>(var));
         for (size_t l = env->prevWith; l; --l, env = env->up) ;
     }
 }
 
-
 void EvalState::mkList(Value & v, size_t size)
 {
     v.mkList(size);
@@ -1041,6 +1303,16 @@ void EvalState::cacheFile(
     fileParseCache[resolvedPath] = e;
 
     try {
+        auto dts =
+            debuggerHook ?
+                makeDebugTraceStacker(
+                    *this,
+                    *e,
+                    this->baseEnv,
+                    (e->getPos() ? std::optional(ErrPos(positions[e->getPos()])) : std::nullopt),
+                    "while evaluating the file '%1%':", resolvedPath)
+                : nullptr;
+
         // Enforce that 'flake.nix' is a direct attrset, not a
         // computation.
         if (mustBeTrivial &&
@@ -1068,7 +1340,7 @@ inline bool EvalState::evalBool(Env & env, Expr * e)
     Value v;
     e->eval(*this, env, v);
     if (v.type() != nBool)
-        throwTypeError("value is %1% while a Boolean was expected", v);
+        throwTypeError(noPos, "value is %1% while a Boolean was expected", v, env, *e);
     return v.boolean;
 }
 
@@ -1078,7 +1350,7 @@ inline bool EvalState::evalBool(Env & env, Expr * e, const PosIdx pos)
     Value v;
     e->eval(*this, env, v);
     if (v.type() != nBool)
-        throwTypeError(pos, "value is %1% while a Boolean was expected", v);
+        throwTypeError(pos, "value is %1% while a Boolean was expected", v, env, *e);
     return v.boolean;
 }
 
@@ -1087,7 +1359,7 @@ inline void EvalState::evalAttrs(Env & env, Expr * e, Value & v)
 {
     e->eval(*this, env, v);
     if (v.type() != nAttrs)
-        throwTypeError("value is %1% while a set was expected", v);
+        throwTypeError(noPos, "value is %1% while a set was expected", v, env, *e);
 }
 
 
@@ -1192,7 +1464,7 @@ void ExprAttrs::eval(EvalState & state, Env & env, Value & v)
         auto nameSym = state.symbols.create(nameVal.string.s);
         Bindings::iterator j = v.attrs->find(nameSym);
         if (j != v.attrs->end())
-            state.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, env, *this);
 
         i.valueExpr->setName(nameSym);
         /* Keep sorted order so find can catch duplicates */
@@ -1266,6 +1538,16 @@ void ExprSelect::eval(EvalState & state, Env & env, Value & v)
     e->eval(state, env, vTmp);
 
     try {
+        auto dts =
+            debuggerHook ?
+                makeDebugTraceStacker(
+                    state,
+                    *this,
+                    env,
+                    state.positions[pos2],
+                    "while evaluating the attribute '%1%'",
+                    showAttrPath(state, env, attrPath))
+            : nullptr;
 
         for (auto & i : attrPath) {
             state.nrLookups++;
@@ -1288,7 +1570,7 @@ void ExprSelect::eval(EvalState & state, Env & env, Value & v)
                     state.throwEvalError(
                         pos,
                         Suggestions::bestMatches(allAttrNames, state.symbols[name]),
-                        "attribute '%1%' missing", state.symbols[name]);
+                        "attribute '%1%' missing", state.symbols[name], env, *this);
                 }
             }
             vAttrs = j->value;
@@ -1379,7 +1661,6 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
 
             if (!lambda.hasFormals())
                 env2.values[displ++] = args[0];
-
             else {
                 forceAttrs(*args[0], pos);
 
@@ -1394,7 +1675,7 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
                     auto j = args[0]->attrs->get(i.name);
                     if (!j) {
                         if (!i.def) throwTypeError(pos, "%1% called without required argument '%2%'",
-                            lambda, i.name);
+                            lambda, i.name, *fun.lambda.env, lambda);
                         env2.values[displ++] = i.def->maybeThunk(*this, env2);
                     } else {
                         attrsUsed++;
@@ -1416,8 +1697,7 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
                                 pos,
                                 Suggestions::bestMatches(formalNames, symbols[i.name]),
                                 "%1% called with unexpected argument '%2%'",
-                                lambda,
-                                i.name);
+                                lambda, i.name, *fun.lambda.env, lambda);
                         }
                     abort(); // can't happen
                 }
@@ -1428,6 +1708,15 @@ void EvalState::callFunction(Value & fun, size_t nrArgs, Value * * args, Value &
 
             /* Evaluate the body. */
             try {
+                auto dts =
+                    debuggerHook ?
+                        makeDebugTraceStacker(*this, *lambda.body, env2, positions[lambda.pos],
+                                           "while evaluating %s",
+                                           (lambda.name
+                                               ? concatStrings("'", symbols[lambda.name], "'")
+                                               : "anonymous lambda"))
+                        : nullptr;
+
                 lambda.body->eval(*this, env2, vCur);
             } catch (Error & e) {
                 if (loggerSettings.showTrace.get()) {
@@ -1582,8 +1871,8 @@ 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.)", symbols[i.name]);
-
+https://nixos.org/manual/nix/stable/#ss-functions.)", symbols[i.name],
+                *fun.lambda.env, *fun.lambda.fun);
             }
         }
     }
@@ -1615,7 +1904,7 @@ void ExprAssert::eval(EvalState & state, Env & env, Value & v)
     if (!state.evalBool(env, cond, pos)) {
         std::ostringstream out;
         cond->show(state.symbols, out);
-        state.throwAssertionError(pos, "assertion '%1%' failed", out.str());
+        state.throwAssertionError(pos, "assertion '%1%' failed", out.str(), env, *this);
     }
     body->eval(state, env, v);
 }
@@ -1792,14 +2081,14 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
                 nf = n;
                 nf += vTmp.fpoint;
             } else
-                state.throwEvalError(i_pos, "cannot add %1% to an integer", showType(vTmp));
+                state.throwEvalError(i_pos, "cannot add %1% to an integer", showType(vTmp), env, *this);
         } else if (firstType == nFloat) {
             if (vTmp.type() == nInt) {
                 nf += vTmp.integer;
             } else if (vTmp.type() == nFloat) {
                 nf += vTmp.fpoint;
             } else
-                state.throwEvalError(i_pos, "cannot add %1% to a float", showType(vTmp));
+                state.throwEvalError(i_pos, "cannot add %1% to a float", showType(vTmp), env, *this);
         } else {
             if (s.empty()) s.reserve(es->size());
             /* skip canonization of first path, which would only be not
@@ -1819,7 +2108,7 @@ void ExprConcatStrings::eval(EvalState & state, Env & env, Value & v)
         v.mkFloat(nf);
     else if (firstType == nPath) {
         if (!context.empty())
-            state.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", env, *this);
         v.mkPath(canonPath(str()));
     } else
         v.mkStringMove(c_str(), context);
@@ -1846,6 +2135,16 @@ void EvalState::forceValueDeep(Value & v)
         if (v.type() == nAttrs) {
             for (auto & i : *v.attrs)
                 try {
+
+                    auto dts =
+                        debuggerHook ?
+                            // if the value is a thunk, we're evaling.  otherwise no trace necessary.
+                            (i.value->isThunk() ?
+                                makeDebugTraceStacker(*this, *v.thunk.expr, *v.thunk.env, positions[i.pos],
+                                                  "while evaluating the attribute '%1%'", symbols[i.name])
+                                : nullptr)
+                        : nullptr;
+
                     recurse(*i.value);
                 } catch (Error & e) {
                     addErrorTrace(e, i.pos, "while evaluating the attribute '%1%'", symbols[i.name]);
@@ -1868,6 +2167,7 @@ NixInt EvalState::forceInt(Value & v, const PosIdx pos)
     forceValue(v, pos);
     if (v.type() != nInt)
         throwTypeError(pos, "value is %1% while an integer was expected", v);
+
     return v.integer;
 }
 
@@ -1910,10 +2210,7 @@ std::string_view EvalState::forceString(Value & v, const PosIdx pos)
 {
     forceValue(v, pos);
     if (v.type() != nString) {
-        if (pos)
-            throwTypeError(pos, "value is %1% while a string was expected", v);
-        else
-            throwTypeError("value is %1% while a string was expected", v);
+        throwTypeError(pos, "value is %1% while a string was expected", v);
     }
     return v.string.s;
 }
@@ -2030,7 +2327,8 @@ BackedStringView EvalState::coerceToString(const PosIdx pos, Value & v, PathSet
         if (maybeString)
             return std::move(*maybeString);
         auto i = v.attrs->find(sOutPath);
-        if (i == v.attrs->end()) throwTypeError(pos, "cannot coerce a set to a string");
+        if (i == v.attrs->end())
+            throwTypeError(pos, "cannot coerce a set to a string");
         return coerceToString(pos, *i->value, context, coerceMore, copyToStore);
     }
 
@@ -2038,7 +2336,6 @@ BackedStringView EvalState::coerceToString(const PosIdx pos, Value & v, PathSet
         return v.external->coerceToString(positions[pos], context, coerceMore, copyToStore);
 
     if (coerceMore) {
-
         /* Note that `false' is represented as an empty string for
            shell scripting convenience, just like `null'. */
         if (v.type() == nBool && v.boolean) return "1";
@@ -2183,7 +2480,9 @@ bool EvalState::eqValues(Value & v1, Value & v2)
             return v1.fpoint == v2.fpoint;
 
         default:
-            throwEvalError("cannot compare %1% with %2%", showType(v1), showType(v2));
+            throwEvalError("cannot compare %1% with %2%",
+                showType(v1),
+                showType(v2));
     }
 }
 
diff --git a/src/libexpr/eval.hh b/src/libexpr/eval.hh
index 6c418f2ae..2e7df13fc 100644
--- a/src/libexpr/eval.hh
+++ b/src/libexpr/eval.hh
@@ -25,6 +25,8 @@ enum RepairFlag : bool;
 
 typedef void (* PrimOpFun) (EvalState & state, const PosIdx pos, Value * * args, Value & v);
 
+void printEnvBindings(const SymbolTable &st, const Expr &expr, const Env &env);
+void printEnvBindings(const SymbolTable &st, const StaticEnv &se, const Env &env, int lvl = 0);
 
 struct PrimOp
 {
@@ -35,6 +37,7 @@ struct PrimOp
     const char * doc = nullptr;
 };
 
+typedef std::map<std::string, Value *> valmap;
 
 struct Env
 {
@@ -44,6 +47,7 @@ struct Env
     Value * values[0];
 };
 
+valmap * mapStaticEnvBindings(const SymbolTable &st, const StaticEnv &se, const Env &env);
 
 void copyContext(const Value & v, PathSet & context);
 
@@ -69,6 +73,13 @@ struct RegexCache;
 
 std::shared_ptr<RegexCache> makeRegexCache();
 
+struct DebugTrace {
+    std::optional<ErrPos> pos;
+    const Expr &expr;
+    const Env &env;
+    hintformat hint;
+    bool is_error;
+};
 
 class EvalState
 {
@@ -108,6 +119,12 @@ public:
     RootValue vCallFlake = nullptr;
     RootValue vImportedDrvToDerivation = nullptr;
 
+    /* Debugger */
+    bool debugStop;
+    bool debugQuit;
+    std::list<DebugTrace> debugTraces;
+    void debugLastTrace(Error & e) const;
+
 private:
     SrcToStore srcToStore;
 
@@ -184,10 +201,10 @@ public:
 
     /* Parse a Nix expression from the specified file. */
     Expr * parseExprFromFile(const Path & path);
-    Expr * parseExprFromFile(const Path & path, StaticEnv & staticEnv);
+    Expr * parseExprFromFile(const Path & path, std::shared_ptr<StaticEnv> & staticEnv);
 
     /* Parse a Nix expression from the specified string. */
-    Expr * parseExprFromString(std::string s, const Path & basePath, StaticEnv & staticEnv);
+    Expr * parseExprFromString(std::string s, const Path & basePath, std::shared_ptr<StaticEnv> & staticEnv);
     Expr * parseExprFromString(std::string s, const Path & basePath);
 
     Expr * parseStdin();
@@ -197,7 +214,7 @@ public:
        trivial (i.e. doesn't require arbitrary computation). */
     void evalFile(const Path & path, Value & v, bool mustBeTrivial = false);
 
-    /* Like `cacheFile`, but with an already parsed expression. */
+    /* Like `evalFile`, but with an already parsed expression. */
     void cacheFile(
         const Path & path,
         const Path & resolvedPath,
@@ -256,35 +273,66 @@ public:
     [[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;
+    void throwEvalError(const PosIdx pos, const char * s,
+        Env & env, Expr & expr) 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;
+    void throwEvalError(const char * s, const std::string & s2,
+        Env & env, Expr & expr) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2,
+        Env & env, Expr & expr) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const char * s, const std::string & s2, const std::string & s3,
+        Env & env, Expr & expr) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx pos, const char * s, const std::string & s2, const std::string & s3,
+        Env & env, Expr & expr) 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;
+    void throwEvalError(const char * s, const std::string & s2, const std::string & s3) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx pos, const Suggestions & suggestions, const char * s, const std::string & s2,
+        Env & env, Expr &expr) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwEvalError(const PosIdx p1, const char * s, const Symbol sym, const PosIdx p2,
+        Env & env, Expr & expr) const;
+
+    [[gnu::noinline, gnu::noreturn]]
+    void throwTypeError(const PosIdx pos, const char * s, const Value & v) const;
+    [[gnu::noinline, gnu::noreturn]]
+    void throwTypeError(const PosIdx pos, const char * s, const Value & v,
+        Env & env, Expr & expr) 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;
+    void throwTypeError(const PosIdx pos, const char * s,
+        Env & env, Expr & expr) const;
     [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const PosIdx pos, const Suggestions & suggestions, const char * s,
-        const ExprLambda & fun, const Symbol s2) const;
+    void throwTypeError(const PosIdx pos, const char * s, const ExprLambda & fun, const Symbol s2,
+        Env & env, Expr & expr) const;
     [[gnu::noinline, gnu::noreturn]]
-    void throwTypeError(const char * s, const Value & v) const;
+    void throwTypeError(const PosIdx pos, const Suggestions & suggestions, const char * s, const ExprLambda & fun, const Symbol s2,
+        Env & env, Expr & expr) const;
     [[gnu::noinline, gnu::noreturn]]
-    void throwAssertionError(const PosIdx pos, const char * s, const std::string & s1) const;
+    void throwTypeError(const char * s, const Value & v,
+        Env & env, Expr & expr) const;
+
     [[gnu::noinline, gnu::noreturn]]
-    void throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1) const;
+    void throwAssertionError(const PosIdx pos, const char * s, const std::string & s1,
+        Env & env, Expr & expr) const;
+
     [[gnu::noinline, gnu::noreturn]]
-    void throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1) const;
+    void throwUndefinedVarError(const PosIdx pos, const char * s, const std::string & s1,
+        Env & env, Expr & expr) const;
+
+    [[gnu::noinline, gnu::noreturn]]
+    void throwMissingArgumentError(const PosIdx pos, const char * s, const std::string & s1,
+        Env & env, Expr & expr) const;
 
     [[gnu::noinline]]
     void addErrorTrace(Error & e, const char * s, const std::string & s2) const;
@@ -324,7 +372,7 @@ public:
     Env & baseEnv;
 
     /* The same, but used during parsing to resolve variables. */
-    StaticEnv staticBaseEnv; // !!! should be private
+    std::shared_ptr<StaticEnv> staticBaseEnv; // !!! should be private
 
 private:
 
@@ -365,7 +413,7 @@ private:
     friend struct ExprLet;
 
     Expr * parse(char * text, size_t length, FileOrigin origin, const PathView path,
-        const PathView basePath, StaticEnv & staticEnv);
+        const PathView basePath, std::shared_ptr<StaticEnv> & staticEnv);
 
 public:
 
@@ -460,6 +508,17 @@ private:
     friend struct Value;
 };
 
+class DebugTraceStacker {
+    public:
+        DebugTraceStacker(EvalState &evalState, DebugTrace t);
+        ~DebugTraceStacker()
+        {
+            // assert(evalState.debugTraces.front() == trace);
+            evalState.debugTraces.pop_front();
+        }
+        EvalState &evalState;
+        DebugTrace trace;
+};
 
 /* Return a string representing the type of the value `v'. */
 std::string_view showType(ValueType type);
diff --git a/src/libexpr/nixexpr.cc b/src/libexpr/nixexpr.cc
index c529fdc89..5624c4780 100644
--- a/src/libexpr/nixexpr.cc
+++ b/src/libexpr/nixexpr.cc
@@ -6,9 +6,11 @@
 
 #include <cstdlib>
 
-
 namespace nix {
 
+/* Launch the nix debugger */
+
+std::function<void(const Error * error, const Env & env, const Expr & expr)> debuggerHook;
 
 /* Displaying abstract syntax trees. */
 
@@ -294,35 +296,46 @@ std::string showAttrPath(const SymbolTable & symbols, const AttrPath & attrPath)
 
 /* Computing levels/displacements for variables. */
 
-void Expr::bindVars(const EvalState & es, const StaticEnv & env)
+void Expr::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
     abort();
 }
 
-void ExprInt::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprInt::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
 }
 
-void ExprFloat::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprFloat::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
 }
 
-void ExprString::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprString::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
 }
 
-void ExprPath::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprPath::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
 }
 
-void ExprVar::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprVar::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     /* Check whether the variable appears in the environment.  If so,
        set its level and displacement. */
     const StaticEnv * curEnv;
     Level level;
     int withLevel = -1;
-    for (curEnv = &env, level = 0; curEnv; curEnv = curEnv->up, level++) {
+    for (curEnv = env.get(), level = 0; curEnv; curEnv = curEnv->up, level++) {
         if (curEnv->isWith) {
             if (withLevel == -1) withLevel = level;
         } else {
@@ -340,16 +353,21 @@ void ExprVar::bindVars(const EvalState & es, const StaticEnv & env)
        enclosing `with'.  If there is no `with', then we can issue an
        "undefined variable" error now. */
     if (withLevel == -1)
+    {
         throw UndefinedVarError({
             .msg = hintfmt("undefined variable '%1%'", es.symbols[name]),
             .errPos = es.positions[pos]
         });
+    }
     fromWith = true;
     this->level = withLevel;
 }
 
-void ExprSelect::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprSelect::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     e->bindVars(es, env);
     if (def) def->bindVars(es, env);
     for (auto & i : attrPath)
@@ -357,64 +375,79 @@ void ExprSelect::bindVars(const EvalState & es, const StaticEnv & env)
             i.expr->bindVars(es, env);
 }
 
-void ExprOpHasAttr::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprOpHasAttr::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     e->bindVars(es, env);
     for (auto & i : attrPath)
         if (!i.symbol)
             i.expr->bindVars(es, env);
 }
 
-void ExprAttrs::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprAttrs::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
-    const StaticEnv * dynamicEnv = &env;
-    StaticEnv newEnv(false, &env, recursive ? attrs.size() : 0);
+    if (debuggerHook)
+        staticenv = env;
 
     if (recursive) {
-        dynamicEnv = &newEnv;
+        auto newEnv = std::shared_ptr<StaticEnv>(new StaticEnv(false, env.get(), recursive ? attrs.size() : 0));
 
         Displacement displ = 0;
         for (auto & i : attrs)
-            newEnv.vars.emplace_back(i.first, i.second.displ = displ++);
+            newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
 
         // No need to sort newEnv since attrs is in sorted order.
 
         for (auto & i : attrs)
             i.second.e->bindVars(es, i.second.inherited ? env : newEnv);
-    }
 
-    else
+        for (auto & i : dynamicAttrs) {
+            i.nameExpr->bindVars(es, newEnv);
+            i.valueExpr->bindVars(es, newEnv);
+        }
+    }
+    else {
         for (auto & i : attrs)
             i.second.e->bindVars(es, env);
 
-    for (auto & i : dynamicAttrs) {
-        i.nameExpr->bindVars(es, *dynamicEnv);
-        i.valueExpr->bindVars(es, *dynamicEnv);
+        for (auto & i : dynamicAttrs) {
+            i.nameExpr->bindVars(es, env);
+            i.valueExpr->bindVars(es, env);
+        }
     }
 }
 
-void ExprList::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprList::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     for (auto & i : elems)
         i->bindVars(es, env);
 }
 
-void ExprLambda::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprLambda::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
-    StaticEnv newEnv(
-        false, &env,
-        (hasFormals() ? formals->formals.size() : 0) +
-        (!arg ? 0 : 1));
+    if (debuggerHook)
+        staticenv = env;
+
+    auto newEnv = std::shared_ptr<StaticEnv>(
+        new StaticEnv(
+                false, env.get(),
+                (hasFormals() ? formals->formals.size() : 0) +
+                (!arg ? 0 : 1)));
 
     Displacement displ = 0;
 
-    if (arg) newEnv.vars.emplace_back(arg, displ++);
+    if (arg) newEnv->vars.emplace_back(arg, displ++);
 
     if (hasFormals()) {
         for (auto & i : formals->formals)
-            newEnv.vars.emplace_back(i.name, displ++);
+            newEnv->vars.emplace_back(i.name, displ++);
 
-        newEnv.sort();
+        newEnv->sort();
 
         for (auto & i : formals->formals)
             if (i.def) i.def->bindVars(es, newEnv);
@@ -423,20 +456,26 @@ void ExprLambda::bindVars(const EvalState & es, const StaticEnv & env)
     body->bindVars(es, newEnv);
 }
 
-void ExprCall::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprCall::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     fun->bindVars(es, env);
     for (auto e : args)
         e->bindVars(es, env);
 }
 
-void ExprLet::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprLet::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
-    StaticEnv newEnv(false, &env, attrs->attrs.size());
+    if (debuggerHook)
+        staticenv = env;
+
+    auto newEnv = std::shared_ptr<StaticEnv>(new StaticEnv(false, env.get(), attrs->attrs.size()));
 
     Displacement displ = 0;
     for (auto & i : attrs->attrs)
-        newEnv.vars.emplace_back(i.first, i.second.displ = displ++);
+        newEnv->vars.emplace_back(i.first, i.second.displ = displ++);
 
     // No need to sort newEnv since attrs->attrs is in sorted order.
 
@@ -446,51 +485,72 @@ void ExprLet::bindVars(const EvalState & es, const StaticEnv & env)
     body->bindVars(es, newEnv);
 }
 
-void ExprWith::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprWith::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     /* Does this `with' have an enclosing `with'?  If so, record its
        level so that `lookupVar' can look up variables in the previous
        `with' if this one doesn't contain the desired attribute. */
     const StaticEnv * curEnv;
     Level level;
     prevWith = 0;
-    for (curEnv = &env, level = 1; curEnv; curEnv = curEnv->up, level++)
+    for (curEnv = env.get(), level = 1; curEnv; curEnv = curEnv->up, level++)
         if (curEnv->isWith) {
             prevWith = level;
             break;
         }
 
+    if (debuggerHook)
+        staticenv = env;
+
     attrs->bindVars(es, env);
-    StaticEnv newEnv(true, &env);
+    auto newEnv = std::shared_ptr<StaticEnv>(new StaticEnv(true, env.get()));
     body->bindVars(es, newEnv);
 }
 
-void ExprIf::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprIf::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     cond->bindVars(es, env);
     then->bindVars(es, env);
     else_->bindVars(es, env);
 }
 
-void ExprAssert::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprAssert::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     cond->bindVars(es, env);
     body->bindVars(es, env);
 }
 
-void ExprOpNot::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprOpNot::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     e->bindVars(es, env);
 }
 
-void ExprConcatStrings::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprConcatStrings::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
     for (auto & i : *this->es)
         i.second->bindVars(es, env);
 }
 
-void ExprPos::bindVars(const EvalState & es, const StaticEnv & env)
+void ExprPos::bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> &env)
 {
+    if (debuggerHook)
+        staticenv = env;
+
 }
 
 
diff --git a/src/libexpr/nixexpr.hh b/src/libexpr/nixexpr.hh
index 5df69e000..82fff6dcf 100644
--- a/src/libexpr/nixexpr.hh
+++ b/src/libexpr/nixexpr.hh
@@ -22,6 +22,7 @@ MakeError(UndefinedVarError, Error);
 MakeError(MissingArgumentError, EvalError);
 MakeError(RestrictedPathError, Error);
 
+extern std::function<void(const Error * error, const Env & env, const Expr & expr)> debuggerHook;
 
 /* Position objects. */
 
@@ -143,24 +144,27 @@ struct Expr
 {
     virtual ~Expr() { };
     virtual void show(const SymbolTable & symbols, std::ostream & str) const;
-    virtual void bindVars(const EvalState & es, const StaticEnv & env);
+    virtual void bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> & env);
     virtual void eval(EvalState & state, Env & env, Value & v);
     virtual Value * maybeThunk(EvalState & state, Env & env);
     virtual void setName(Symbol name);
+    std::shared_ptr<const StaticEnv> staticenv;
+    virtual const PosIdx getPos() const = 0;
 };
 
 #define COMMON_METHODS \
     void show(const SymbolTable & symbols, std::ostream & str) const;    \
     void eval(EvalState & state, Env & env, Value & v); \
-    void bindVars(const EvalState & es, const StaticEnv & env);
+    void bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> & env);
 
 struct ExprInt : Expr
 {
     NixInt n;
     Value v;
     ExprInt(NixInt n) : n(n) { v.mkInt(n); };
-    COMMON_METHODS
     Value * maybeThunk(EvalState & state, Env & env);
+    const PosIdx getPos() const { return noPos; }
+    COMMON_METHODS
 };
 
 struct ExprFloat : Expr
@@ -168,8 +172,9 @@ struct ExprFloat : Expr
     NixFloat nf;
     Value v;
     ExprFloat(NixFloat nf) : nf(nf) { v.mkFloat(nf); };
-    COMMON_METHODS
     Value * maybeThunk(EvalState & state, Env & env);
+    const PosIdx getPos() const { return noPos; }
+    COMMON_METHODS
 };
 
 struct ExprString : Expr
@@ -177,8 +182,9 @@ struct ExprString : Expr
     std::string s;
     Value v;
     ExprString(std::string s) : s(std::move(s)) { v.mkString(this->s.data()); };
-    COMMON_METHODS
     Value * maybeThunk(EvalState & state, Env & env);
+    const PosIdx getPos() const { return noPos; }
+    COMMON_METHODS
 };
 
 struct ExprPath : Expr
@@ -186,8 +192,9 @@ struct ExprPath : Expr
     std::string s;
     Value v;
     ExprPath(std::string s) : s(std::move(s)) { v.mkPath(this->s.c_str()); };
-    COMMON_METHODS
     Value * maybeThunk(EvalState & state, Env & env);
+    const PosIdx getPos() const { return noPos; }
+    COMMON_METHODS
 };
 
 typedef uint32_t Level;
@@ -213,8 +220,9 @@ struct ExprVar : Expr
 
     ExprVar(Symbol name) : name(name) { };
     ExprVar(const PosIdx & pos, Symbol name) : pos(pos), name(name) { };
-    COMMON_METHODS
     Value * maybeThunk(EvalState & state, Env & env);
+    const PosIdx getPos() const { return pos; }
+    COMMON_METHODS
 };
 
 struct ExprSelect : Expr
@@ -224,6 +232,7 @@ struct ExprSelect : Expr
     AttrPath attrPath;
     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)); };
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -232,6 +241,7 @@ struct ExprOpHasAttr : Expr
     Expr * e;
     AttrPath attrPath;
     ExprOpHasAttr(Expr * e, const AttrPath & attrPath) : e(e), attrPath(attrPath) { };
+    const PosIdx getPos() const { return e->getPos(); }
     COMMON_METHODS
 };
 
@@ -260,6 +270,7 @@ struct ExprAttrs : Expr
     DynamicAttrDefs dynamicAttrs;
     ExprAttrs(const PosIdx &pos) : recursive(false), pos(pos) { };
     ExprAttrs() : recursive(false) { };
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -267,6 +278,12 @@ struct ExprList : Expr
 {
     std::vector<Expr *> elems;
     ExprList() { };
+    const PosIdx getPos() const
+      { if (elems.empty())
+            return noPos;
+        else
+            return elems.front()->getPos();
+      }
     COMMON_METHODS
 };
 
@@ -320,6 +337,7 @@ struct ExprLambda : Expr
     void setName(Symbol name);
     std::string showNamePos(const EvalState & state) const;
     inline bool hasFormals() const { return formals != nullptr; }
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -331,6 +349,7 @@ struct ExprCall : Expr
     ExprCall(const PosIdx & pos, Expr * fun, std::vector<Expr *> && args)
         : fun(fun), args(args), pos(pos)
     { }
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -339,6 +358,7 @@ struct ExprLet : Expr
     ExprAttrs * attrs;
     Expr * body;
     ExprLet(ExprAttrs * attrs, Expr * body) : attrs(attrs), body(body) { };
+    const PosIdx getPos() const { return noPos; }
     COMMON_METHODS
 };
 
@@ -348,6 +368,7 @@ struct ExprWith : Expr
     Expr * attrs, * body;
     size_t prevWith;
     ExprWith(const PosIdx & pos, Expr * attrs, Expr * body) : pos(pos), attrs(attrs), body(body) { };
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -356,6 +377,7 @@ struct ExprIf : Expr
     PosIdx pos;
     Expr * cond, * then, * else_;
     ExprIf(const PosIdx & pos, Expr * cond, Expr * then, Expr * else_) : pos(pos), cond(cond), then(then), else_(else_) { };
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -364,6 +386,7 @@ struct ExprAssert : Expr
     PosIdx pos;
     Expr * cond, * body;
     ExprAssert(const PosIdx & pos, Expr * cond, Expr * body) : pos(pos), cond(cond), body(body) { };
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -371,6 +394,7 @@ struct ExprOpNot : Expr
 {
     Expr * e;
     ExprOpNot(Expr * e) : e(e) { };
+    const PosIdx getPos() const { return noPos; }
     COMMON_METHODS
 };
 
@@ -385,11 +409,12 @@ struct ExprOpNot : Expr
         { \
             str << "("; e1->show(symbols, str); str << " " s " "; e2->show(symbols, str); str << ")"; \
         } \
-        void bindVars(const EvalState & es, const StaticEnv & env)    \
+        void bindVars(const EvalState & es, const std::shared_ptr<const StaticEnv> & env)    \
         { \
             e1->bindVars(es, env); e2->bindVars(es, env);    \
         } \
         void eval(EvalState & state, Env & env, Value & v); \
+        const PosIdx getPos() const { return pos; } \
     };
 
 MakeBinOp(ExprOpEq, "==")
@@ -407,6 +432,7 @@ struct ExprConcatStrings : Expr
     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) { };
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
@@ -414,6 +440,7 @@ struct ExprPos : Expr
 {
     PosIdx pos;
     ExprPos(const PosIdx & pos) : pos(pos) { };
+    const PosIdx getPos() const { return pos; }
     COMMON_METHODS
 };
 
diff --git a/src/libexpr/parser.y b/src/libexpr/parser.y
index be0598b75..8edafdd57 100644
--- a/src/libexpr/parser.y
+++ b/src/libexpr/parser.y
@@ -643,7 +643,7 @@ namespace nix {
 
 
 Expr * EvalState::parse(char * text, size_t length, FileOrigin origin,
-    const PathView path, const PathView basePath, StaticEnv & staticEnv)
+    const PathView path, const PathView basePath, std::shared_ptr<StaticEnv> & staticEnv)
 {
     yyscan_t scanner;
     std::string file;
@@ -706,7 +706,7 @@ Expr * EvalState::parseExprFromFile(const Path & path)
 }
 
 
-Expr * EvalState::parseExprFromFile(const Path & path, StaticEnv & staticEnv)
+Expr * EvalState::parseExprFromFile(const Path & path, std::shared_ptr<StaticEnv> & staticEnv)
 {
     auto buffer = readFile(path);
     // readFile should have left some extra space for terminators
@@ -715,7 +715,7 @@ Expr * EvalState::parseExprFromFile(const Path & path, StaticEnv & staticEnv)
 }
 
 
-Expr * EvalState::parseExprFromString(std::string s, const Path & basePath, StaticEnv & staticEnv)
+Expr * EvalState::parseExprFromString(std::string s, const Path & basePath, std::shared_ptr<StaticEnv> & staticEnv)
 {
     s.append("\0\0", 2);
     return parse(s.data(), s.size(), foString, "", basePath, staticEnv);
@@ -782,13 +782,15 @@ Path EvalState::findFile(SearchPath & searchPath, const std::string_view path, c
     if (hasPrefix(path, "nix/"))
         return concatStrings(corepkgsPrefix, path.substr(4));
 
-    throw ThrownError({
+    auto e = ThrownError({
         .msg = hintfmt(evalSettings.pureEval
             ? "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 = positions[pos]
     });
+    debugLastTrace(e);
+    throw e;
 }
 
 
diff --git a/src/libexpr/primops.cc b/src/libexpr/primops.cc
index a62d11e4e..41476abe3 100644
--- a/src/libexpr/primops.cc
+++ b/src/libexpr/primops.cc
@@ -46,7 +46,11 @@ StringMap EvalState::realiseContext(const PathSet & context)
         auto [ctx, outputName] = decodeContext(*store, i);
         auto ctxS = store->printStorePath(ctx);
         if (!store->isValidPath(ctx))
-            throw InvalidPathError(store->printStorePath(ctx));
+        {
+            auto e = InvalidPathError(store->printStorePath(ctx));
+            debugLastTrace(e);
+            throw e;
+        }
         if (!outputName.empty() && ctx.isDerivation()) {
             drvs.push_back({ctx, {outputName}});
         } else {
@@ -57,9 +61,13 @@ StringMap EvalState::realiseContext(const PathSet & context)
     if (drvs.empty()) return {};
 
     if (!evalSettings.enableImportFromDerivation)
-        throw Error(
+    {
+        auto e = Error(
             "cannot build '%1%' during evaluation because the option 'allow-import-from-derivation' is disabled",
             store->printStorePath(drvs.begin()->drvPath));
+        debugLastTrace(e);
+        throw e;
+    }
 
     /* Build/substitute the context. */
     std::vector<DerivedPath> buildReqs;
@@ -71,9 +79,12 @@ StringMap EvalState::realiseContext(const PathSet & context)
         const auto outputPaths = store->queryDerivationOutputMap(drvPath);
         for (auto & outputName : outputs) {
             auto outputPath = get(outputPaths, outputName);
-            if (!outputPath)
-                throw Error("derivation '%s' does not have an output named '%s'",
-                        store->printStorePath(drvPath), outputName);
+            if (!outputPath) {
+                auto e = Error("derivation '%s' does not have an output named '%s'",
+                    store->printStorePath(drvPath), outputName);
+                debugLastTrace(e);
+                throw e;
+            }
             res.insert_or_assign(
                 downstreamPlaceholder(*store, drvPath, outputName),
                 store->printStorePath(*outputPath)
@@ -216,11 +227,11 @@ static void import(EvalState & state, const PosIdx pos, Value & vPath, Value * v
             Env * env = &state.allocEnv(vScope->attrs->size());
             env->up = &state.baseEnv;
 
-            StaticEnv staticEnv(false, &state.staticBaseEnv, vScope->attrs->size());
+            auto staticEnv = std::shared_ptr<StaticEnv>(new StaticEnv(false, state.staticBaseEnv.get(), vScope->attrs->size()));
 
             unsigned int displ = 0;
             for (auto & attr : *vScope->attrs) {
-                staticEnv.vars.emplace_back(attr.name, displ);
+                staticEnv->vars.emplace_back(attr.name, displ);
                 env->values[displ++] = attr.value;
             }
 
@@ -319,17 +330,29 @@ void prim_importNative(EvalState & state, const PosIdx pos, Value * * args, Valu
 
     void *handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);
     if (!handle)
-        throw EvalError("could not open '%1%': %2%", path, dlerror());
+    {
+        auto e = EvalError("could not open '%1%': %2%", path, dlerror());
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     dlerror();
     ValueInitializer func = (ValueInitializer) dlsym(handle, sym.c_str());
     if(!func) {
         char *message = dlerror();
         if (message)
-            throw EvalError("could not load symbol '%1%' from '%2%': %3%", sym, path, message);
+        {
+            auto e = EvalError("could not load symbol '%1%' from '%2%': %3%", sym, path, message);
+            state.debugLastTrace(e);
+            throw e;
+        }
         else
-            throw EvalError("symbol '%1%' from '%2%' resolved to NULL when a function pointer was expected",
+        {
+            auto e = EvalError("symbol '%1%' from '%2%' resolved to NULL when a function pointer was expected",
                 sym, path);
+            state.debugLastTrace(e);
+            throw e;
+        }
     }
 
     (func)(state, v);
@@ -345,10 +368,12 @@ void prim_exec(EvalState & state, const PosIdx pos, Value * * args, Value & v)
     auto elems = args[0]->listElems();
     auto count = args[0]->listSize();
     if (count == 0) {
-        throw EvalError({
+        auto e = EvalError({
             .msg = hintfmt("at least one argument to 'exec' required"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
     }
     PathSet context;
     auto program = state.coerceToString(pos, *elems[0], context, false, false).toOwned();
@@ -359,11 +384,13 @@ void prim_exec(EvalState & state, const PosIdx pos, Value * * args, Value & v)
     try {
         auto _ = state.realiseContext(context); // FIXME: Handle CA derivations
     } catch (InvalidPathError & e) {
-        throw EvalError({
+        auto ee = EvalError({
             .msg = hintfmt("cannot execute '%1%', since path '%2%' is not valid",
                 program, e.path),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(ee);
+        throw ee;
     }
 
     auto output = runProgram(program, true, commandArgs);
@@ -547,7 +574,11 @@ struct CompareValues
         if (v1->type() == nInt && v2->type() == nFloat)
             return v1->integer < v2->fpoint;
         if (v1->type() != v2->type())
-            throw EvalError("cannot compare %1% with %2%", showType(*v1), showType(*v2));
+        {
+            auto e = EvalError("cannot compare %1% with %2%", showType(*v1), showType(*v2));
+            state.debugLastTrace(e);
+            throw e;
+        }
         switch (v1->type()) {
             case nInt:
                 return v1->integer < v2->integer;
@@ -569,7 +600,11 @@ struct CompareValues
                     }
                 }
             default:
-                throw EvalError("cannot compare %1% with %2%", showType(*v1), showType(*v2));
+                {
+                    auto e = EvalError("cannot compare %1% with %2%", showType(*v1), showType(*v2));
+                    state.debugLastTrace(e);
+                    throw e;
+                }
         }
     }
 };
@@ -599,10 +634,12 @@ static Bindings::iterator getAttr(
 
         auto aPos = attrSet->pos;
         if (!aPos) {
-            throw TypeError({
+            auto e = TypeError({
                 .msg = errorMsg,
                 .errPos = state.positions[pos],
             });
+            state.debugLastTrace(e);
+            throw e;
         } else {
             auto e = TypeError({
                 .msg = errorMsg,
@@ -612,6 +649,7 @@ static Bindings::iterator getAttr(
             // Adding another trace for the function name to make it clear
             // which call received wrong arguments.
             e.addTrace(state.positions[pos], hintfmt("while invoking '%s'", funcName));
+            state.debugLastTrace(e);
             throw e;
         }
     }
@@ -666,10 +704,14 @@ static void prim_genericClosure(EvalState & state, const PosIdx pos, Value * * a
         Bindings::iterator key =
             e->attrs->find(state.sKey);
         if (key == e->attrs->end())
-            throw EvalError({
+        {
+            auto e = EvalError({
                 .msg = hintfmt("attribute 'key' required"),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
+        }
         state.forceValue(*key->value, pos);
 
         if (!doneKeys.insert(key->value).second) continue;
@@ -725,6 +767,42 @@ static RegisterPrimOp primop_genericClosure(RegisterPrimOp::Info {
     .fun = prim_genericClosure,
 });
 
+
+static RegisterPrimOp primop_break({
+    .name = "break",
+    .args = {"v"},
+    .doc = R"(
+      In debug mode, pause Nix expression evaluation and enter the repl.
+    )",
+    .fun = [](EvalState & state, const PosIdx pos, Value * * args, Value & v)
+    {
+        PathSet context;
+        auto s = state.coerceToString(pos, *args[0], context).toOwned();
+        auto error = Error(ErrorInfo{
+            .level = lvlInfo,
+            .msg = hintfmt("breakpoint reached; value was %1%", s),
+            .errPos = state.positions[pos],
+        });
+        if (debuggerHook && !state.debugTraces.empty())
+        {
+            auto &dt = state.debugTraces.front();
+            debuggerHook(&error, dt.env, dt.expr);
+
+            if (state.debugQuit) {
+                // if the user elects to quit the repl, throw an exception.
+                throw Error(ErrorInfo{
+                    .level = lvlInfo,
+                    .msg = hintfmt("quit from debugger"),
+                    .errPos = state.positions[noPos],
+                });
+            }
+
+            // returning the value we were passed.
+            v = *args[0];
+        }
+    }
+});
+
 static RegisterPrimOp primop_abort({
     .name = "abort",
     .args = {"s"},
@@ -735,7 +813,11 @@ static RegisterPrimOp primop_abort({
     {
         PathSet context;
         auto s = state.coerceToString(pos, *args[0], context).toOwned();
-        throw Abort("evaluation aborted with the following error message: '%1%'", s);
+        {
+            auto e = Abort("evaluation aborted with the following error message: '%1%'", s);
+            state.debugLastTrace(e);
+            throw e;
+        }
     }
 });
 
@@ -753,7 +835,9 @@ static RegisterPrimOp primop_throw({
     {
       PathSet context;
       auto s = state.coerceToString(pos, *args[0], context).toOwned();
-      throw ThrownError(s);
+      auto e = ThrownError(s);
+      state.debugLastTrace(e);
+      throw e;
     }
 });
 
@@ -818,6 +902,8 @@ static RegisterPrimOp primop_floor({
 static void prim_tryEval(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     auto attrs = state.buildBindings(2);
+    auto saveDebuggerHook = debuggerHook;
+    debuggerHook = 0;
     try {
         state.forceValue(*args[0], pos);
         attrs.insert(state.sValue, args[0]);
@@ -826,6 +912,7 @@ static void prim_tryEval(EvalState & state, const PosIdx pos, Value * * args, Va
         attrs.alloc(state.sValue).mkBool(false);
         attrs.alloc("success").mkBool(false);
     }
+    debuggerHook = saveDebuggerHook;
     v.mkAttrs(attrs);
 }
 
@@ -1008,37 +1095,53 @@ static void prim_derivationStrict(EvalState & state, const PosIdx pos, Value * *
             if (s == "recursive") ingestionMethod = FileIngestionMethod::Recursive;
             else if (s == "flat") ingestionMethod = FileIngestionMethod::Flat;
             else
-                throw EvalError({
+            {
+                auto e = EvalError({
                     .msg = hintfmt("invalid value '%s' for 'outputHashMode' attribute", s),
                     .errPos = state.positions[posDrvName]
                 });
+                state.debugLastTrace(e);
+                throw e;
+            }
         };
 
         auto handleOutputs = [&](const Strings & ss) {
             outputs.clear();
             for (auto & j : ss) {
                 if (outputs.find(j) != outputs.end())
-                    throw EvalError({
+                {
+                    auto e = EvalError({
                         .msg = hintfmt("duplicate derivation output '%1%'", j),
                         .errPos = state.positions[posDrvName]
                     });
+                    state.debugLastTrace(e);
+                    throw e;
+                }
                 /* !!! Check whether j is a valid attribute
                    name. */
                 /* Derivations cannot be named ‘drv’, because
                    then we'd have an attribute ‘drvPath’ in
                    the resulting set. */
                 if (j == "drv")
-                    throw EvalError({
+                {
+                    auto e = EvalError({
                         .msg = hintfmt("invalid derivation output name 'drv'" ),
                         .errPos = state.positions[posDrvName]
                     });
+                    state.debugLastTrace(e);
+                    throw e;
+                }
                 outputs.insert(j);
             }
             if (outputs.empty())
-                throw EvalError({
+            {
+                auto e = EvalError({
                     .msg = hintfmt("derivation cannot have an empty set of outputs"),
                     .errPos = state.positions[posDrvName]
                 });
+                state.debugLastTrace(e);
+                throw e;
+            }
         };
 
         try {
@@ -1163,23 +1266,35 @@ static void prim_derivationStrict(EvalState & state, const PosIdx pos, Value * *
 
     /* Do we have all required attributes? */
     if (drv.builder == "")
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("required attribute 'builder' missing"),
             .errPos = state.positions[posDrvName]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     if (drv.platform == "")
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("required attribute 'system' missing"),
             .errPos = state.positions[posDrvName]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     /* Check whether the derivation name is valid. */
     if (isDerivation(drvName))
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("derivation names are not allowed to end in '%s'", drvExtension),
             .errPos = state.positions[posDrvName]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     if (outputHash) {
         /* Handle fixed-output derivations.
@@ -1187,10 +1302,14 @@ static void prim_derivationStrict(EvalState & state, const PosIdx pos, Value * *
            Ignore `__contentAddressed` because fixed output derivations are
            already content addressed. */
         if (outputs.size() != 1 || *(outputs.begin()) != "out")
-            throw Error({
+        {
+            auto e = Error({
                 .msg = hintfmt("multiple outputs are not supported in fixed-output derivations"),
                 .errPos = state.positions[posDrvName]
             });
+            state.debugLastTrace(e);
+            throw e;
+        }
 
         auto h = newHashAllowEmpty(*outputHash, parseHashTypeOpt(outputHashAlgo));
 
@@ -1358,10 +1477,14 @@ static RegisterPrimOp primop_toPath({
 static void prim_storePath(EvalState & state, const PosIdx pos, Value * * args, Value & v)
 {
     if (evalSettings.pureEval)
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("'%s' is not allowed in pure evaluation mode", "builtins.storePath"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     PathSet context;
     Path path = state.checkSourcePath(state.coerceToPath(pos, *args[0], context));
@@ -1370,10 +1493,14 @@ static void prim_storePath(EvalState & state, const PosIdx pos, Value * * args,
        e.g. nix-push does the right thing. */
     if (!state.store->isStorePath(path)) path = canonPath(path, true);
     if (!state.store->isInStore(path))
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("path '%1%' is not in the Nix store", path),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
     auto path2 = state.store->toStorePath(path).first;
     if (!settings.readOnlyMode)
         state.store->ensurePath(path2);
@@ -1476,7 +1603,11 @@ static void prim_readFile(EvalState & state, const PosIdx pos, Value * * args, V
     auto path = realisePath(state, pos, *args[0]);
     auto s = readFile(path);
     if (s.find((char) 0) != std::string::npos)
-        throw Error("the contents of the file '%1%' cannot be represented as a Nix string", path);
+    {
+        auto e = Error("the contents of the file '%1%' cannot be represented as a Nix string", path);
+        state.debugLastTrace(e);
+        throw e;
+    }
     StorePathSet refs;
     if (state.store->isInStore(path)) {
         try {
@@ -1528,10 +1659,12 @@ static void prim_findFile(EvalState & state, const PosIdx pos, Value * * args, V
             auto rewrites = state.realiseContext(context);
             path = rewriteStrings(path, rewrites);
         } catch (InvalidPathError & e) {
-            throw EvalError({
+            auto ee = EvalError({
                 .msg = hintfmt("cannot find '%1%', since path '%2%' is not valid", path, e.path),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(ee);
+            throw ee;
         }
 
 
@@ -1555,10 +1688,14 @@ static void prim_hashFile(EvalState & state, const PosIdx pos, Value * * args, V
     auto type = state.forceStringNoCtx(*args[0], pos);
     std::optional<HashType> ht = parseHashType(type);
     if (!ht)
-        throw Error({
+    {
+        auto e = Error({
             .msg = hintfmt("unknown hash type '%1%'", type),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     auto path = realisePath(state, pos, *args[1]);
 
@@ -1795,13 +1932,17 @@ static void prim_toFile(EvalState & state, const PosIdx pos, Value * * args, Val
 
     for (auto path : context) {
         if (path.at(0) != '/')
-            throw EvalError( {
+        {
+            auto e = EvalError( {
                 .msg = hintfmt(
                     "in 'toFile': the file named '%1%' must not contain a reference "
                     "to a derivation but contains (%2%)",
                     name, path),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
+        }
         refs.insert(state.store->parseStorePath(path));
     }
 
@@ -1959,7 +2100,11 @@ static void addPath(
                 ? state.store->computeStorePathForPath(name, path, method, htSHA256, filter).first
                 : state.store->addToStore(name, path, method, htSHA256, filter, state.repair, refs);
             if (expectedHash && expectedStorePath != dstPath)
-                throw Error("store path mismatch in (possibly filtered) path added from '%s'", path);
+            {
+                auto e = Error("store path mismatch in (possibly filtered) path added from '%s'", path);
+                state.debugLastTrace(e);
+                throw e;
+            }
             state.allowAndSetStorePathString(dstPath, v);
         } else
             state.allowAndSetStorePathString(*expectedStorePath, v);
@@ -1977,12 +2122,16 @@ static void prim_filterSource(EvalState & state, const PosIdx pos, Value * * arg
 
     state.forceValue(*args[0], pos);
     if (args[0]->type() != nFunction)
-        throw TypeError({
+    {
+        auto e = TypeError({
             .msg = hintfmt(
                 "first argument in call to 'filterSource' is not a function but %1%",
                 showType(*args[0])),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     addPath(state, pos, std::string(baseNameOf(path)), path, args[0], FileIngestionMethod::Recursive, std::nullopt, v, context);
 }
@@ -2066,16 +2215,24 @@ static void prim_path(EvalState & state, const PosIdx pos, Value * * args, Value
         else if (n == "sha256")
             expectedHash = newHashAllowEmpty(state.forceStringNoCtx(*attr.value, attr.pos), htSHA256);
         else
-            throw EvalError({
+        {
+            auto e = EvalError({
                 .msg = hintfmt("unsupported argument '%1%' to 'addPath'", state.symbols[attr.name]),
                 .errPos = state.positions[attr.pos]
             });
+            state.debugLastTrace(e);
+            throw e;
+        }
     }
     if (path.empty())
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("'path' required"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
     if (name.empty())
         name = baseNameOf(path);
 
@@ -2447,10 +2604,14 @@ static void prim_functionArgs(EvalState & state, const PosIdx pos, Value * * arg
         return;
     }
     if (!args[0]->isLambda())
-        throw TypeError({
+    {
+        auto e = TypeError({
             .msg = hintfmt("'functionArgs' requires a function"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     if (!args[0]->lambda.fun->hasFormals()) {
         v.mkAttrs(&state.emptyBindings);
@@ -2538,7 +2699,8 @@ static void prim_zipAttrsWith(EvalState & state, const PosIdx pos, Value * * arg
                 attrsSeen[attr.name].first++;
         } catch (TypeError & e) {
             e.addTrace(state.positions[pos], hintfmt("while invoking '%s'", "zipAttrsWith"));
-            throw;
+            state.debugLastTrace(e);
+            throw e;
         }
     }
 
@@ -2625,10 +2787,14 @@ static void elemAt(EvalState & state, const PosIdx pos, Value & list, int n, Val
 {
     state.forceList(list, pos);
     if (n < 0 || (unsigned int) n >= list.listSize())
-        throw Error({
+    {
+        auto e = Error({
             .msg = hintfmt("list index %1% is out of bounds", n),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
     state.forceValue(*list.listElems()[n], pos);
     v = *list.listElems()[n];
 }
@@ -2673,10 +2839,14 @@ static void prim_tail(EvalState & state, const PosIdx pos, Value * * args, Value
 {
     state.forceList(*args[0], pos);
     if (args[0]->listSize() == 0)
-        throw Error({
+    {
+        auto e = Error({
             .msg = hintfmt("'tail' called on an empty list"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     state.mkList(v, args[0]->listSize() - 1);
     for (unsigned int n = 0; n < v.listSize(); ++n)
@@ -2911,10 +3081,14 @@ static void prim_genList(EvalState & state, const PosIdx pos, Value * * args, Va
     auto len = state.forceInt(*args[1], pos);
 
     if (len < 0)
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("cannot create list of size %1%", len),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     state.mkList(v, len);
 
@@ -3123,7 +3297,8 @@ static void prim_concatMap(EvalState & state, const PosIdx pos, Value * * args,
             state.forceList(lists[n], lists[n].determinePos(args[0]->determinePos(pos)));
         } catch (TypeError &e) {
             e.addTrace(state.positions[pos], hintfmt("while invoking '%s'", "concatMap"));
-            throw;
+            state.debugLastTrace(e);
+            throw e;
         }
         len += lists[n].listSize();
     }
@@ -3218,10 +3393,14 @@ static void prim_div(EvalState & state, const PosIdx pos, Value * * args, Value
 
     NixFloat f2 = state.forceFloat(*args[1], pos);
     if (f2 == 0)
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("division by zero"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     if (args[0]->type() == nFloat || args[1]->type() == nFloat) {
         v.mkFloat(state.forceFloat(*args[0], pos) / state.forceFloat(*args[1], pos));
@@ -3230,10 +3409,14 @@ static void prim_div(EvalState & state, const PosIdx pos, Value * * args, Value
         NixInt i2 = state.forceInt(*args[1], pos);
         /* Avoid division overflow as it might raise SIGFPE. */
         if (i1 == std::numeric_limits<NixInt>::min() && i2 == -1)
-            throw EvalError({
+        {
+            auto e = EvalError({
                 .msg = hintfmt("overflow in integer division"),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
+        }
 
         v.mkInt(i1 / i2);
     }
@@ -3361,10 +3544,14 @@ static void prim_substring(EvalState & state, const PosIdx pos, Value * * args,
     auto s = state.coerceToString(pos, *args[2], context);
 
     if (start < 0)
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("negative start position in 'substring'"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     v.mkString((unsigned int) start >= s->size() ? "" : s->substr(start, len), context);
 }
@@ -3412,10 +3599,14 @@ static void prim_hashString(EvalState & state, const PosIdx pos, Value * * args,
     auto type = state.forceStringNoCtx(*args[0], pos);
     std::optional<HashType> ht = parseHashType(type);
     if (!ht)
-        throw Error({
+    {
+        auto e = Error({
             .msg = hintfmt("unknown hash type '%1%'", type),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     PathSet context; // discarded
     auto s = state.forceString(*args[1], context, pos);
@@ -3485,15 +3676,19 @@ void prim_match(EvalState & state, const PosIdx pos, Value * * args, Value & v)
     } catch (std::regex_error &e) {
         if (e.code() == std::regex_constants::error_space) {
             // limit is _GLIBCXX_REGEX_STATE_LIMIT for libstdc++
-            throw EvalError({
+            auto e = EvalError({
                 .msg = hintfmt("memory limit exceeded by regular expression '%s'", re),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
         } else {
-            throw EvalError({
+            auto e = EvalError({
                 .msg = hintfmt("invalid regular expression '%s'", re),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
         }
     }
 }
@@ -3590,15 +3785,19 @@ void prim_split(EvalState & state, const PosIdx pos, Value * * args, Value & v)
     } catch (std::regex_error &e) {
         if (e.code() == std::regex_constants::error_space) {
             // limit is _GLIBCXX_REGEX_STATE_LIMIT for libstdc++
-            throw EvalError({
+            auto e = EvalError({
                 .msg = hintfmt("memory limit exceeded by regular expression '%s'", re),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
         } else {
-            throw EvalError({
+            auto e = EvalError({
                 .msg = hintfmt("invalid regular expression '%s'", re),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
         }
     }
 }
@@ -3675,10 +3874,14 @@ static void prim_replaceStrings(EvalState & state, const PosIdx pos, Value * * a
     state.forceList(*args[0], pos);
     state.forceList(*args[1], pos);
     if (args[0]->listSize() != args[1]->listSize())
-        throw EvalError({
+    {
+        auto e = EvalError({
             .msg = hintfmt("'from' and 'to' arguments to 'replaceStrings' have different lengths"),
             .errPos = state.positions[pos]
         });
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     std::vector<std::string> from;
     from.reserve(args[0]->listSize());
@@ -3931,7 +4134,7 @@ void EvalState::createBaseEnv()
        because attribute lookups expect it to be sorted. */
     baseEnv.values[0]->attrs->sort();
 
-    staticBaseEnv.sort();
+    staticBaseEnv->sort();
 
     /* Note: we have to initialize the 'derivation' constant *after*
        building baseEnv/staticBaseEnv because it uses 'builtins'. */
diff --git a/src/libexpr/primops/fetchTree.cc b/src/libexpr/primops/fetchTree.cc
index d7c3c9918..55fe7da24 100644
--- a/src/libexpr/primops/fetchTree.cc
+++ b/src/libexpr/primops/fetchTree.cc
@@ -108,16 +108,24 @@ static void fetchTree(
 
         if (auto aType = args[0]->attrs->get(state.sType)) {
             if (type)
-                throw Error({
+            {
+                auto e = EvalError({
                     .msg = hintfmt("unexpected attribute 'type'"),
                     .errPos = state.positions[pos]
                 });
+                state.debugLastTrace(e);
+                throw e;
+            }
             type = state.forceStringNoCtx(*aType->value, aType->pos);
         } else if (!type)
-            throw Error({
+        {
+            auto e = EvalError({
                 .msg = hintfmt("attribute 'type' is missing in call to 'fetchTree'"),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
+        }
 
         attrs.emplace("type", type.value());
 
@@ -138,16 +146,24 @@ static void fetchTree(
             else if (attr.value->type() == nInt)
                 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",
+            {
+                auto e = TypeError("fetchTree argument '%s' is %s while a string, Boolean or integer is expected",
                     state.symbols[attr.name], showType(*attr.value));
+                state.debugLastTrace(e);
+                throw e;
+            }
         }
 
         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'"),
+            {
+                auto e = EvalError({
+                    .msg = hintfmt("attribute 'name' isn’t supported in call to 'fetchTree'"),
                     .errPos = state.positions[pos]
                 });
+                state.debugLastTrace(e);
+                throw e;
+            }
 
         input = fetchers::Input::fromAttrs(std::move(attrs));
     } else {
@@ -167,7 +183,11 @@ 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", state.positions[pos]);
+    {
+        auto e = EvalError("in pure evaluation mode, 'fetchTree' requires a locked input, at %s", state.positions[pos]);
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     auto [tree, input2] = input.fetch(state.store);
 
@@ -206,17 +226,25 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
             else if (n == "name")
                 name = state.forceStringNoCtx(*attr.value, attr.pos);
             else
-                throw EvalError({
+            {
+                auto e = EvalError({
                     .msg = hintfmt("unsupported argument '%s' to '%s'", n, who),
                     .errPos = state.positions[attr.pos]
                 });
+                state.debugLastTrace(e);
+                throw e;
             }
+        }
 
         if (!url)
-            throw EvalError({
+        {
+            auto e = EvalError({
                 .msg = hintfmt("'url' argument required"),
                 .errPos = state.positions[pos]
             });
+            state.debugLastTrace(e);
+            throw e;
+        }
     } else
         url = state.forceStringNoCtx(*args[0], pos);
 
@@ -228,7 +256,11 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
         name = baseNameOf(*url);
 
     if (evalSettings.pureEval && !expectedHash)
-        throw Error("in pure evaluation mode, '%s' requires a 'sha256' argument", who);
+    {
+        auto e = EvalError("in pure evaluation mode, '%s' requires a 'sha256' argument", who);
+        state.debugLastTrace(e);
+        throw e;
+    }
 
     // early exit if pinned and already in the store
     if (expectedHash && expectedHash->type == htSHA256) {
@@ -255,8 +287,12 @@ static void fetch(EvalState & state, const PosIdx pos, Value * * args, Value & v
             ? state.store->queryPathInfo(storePath)->narHash
             : hashFile(htSHA256, state.store->toRealPath(storePath));
         if (hash != *expectedHash)
-            throw Error((unsigned int) 102, "hash mismatch in file downloaded from '%s':\n  specified: %s\n  got:       %s",
+        {
+            auto e = EvalError((unsigned int) 102, "hash mismatch in file downloaded from '%s':\n  specified: %s\n  got:       %s",
                 *url, expectedHash->to_string(Base32, true), hash.to_string(Base32, true));
+            state.debugLastTrace(e);
+            throw e;
+        }
     }
 
     state.allowAndSetStorePathString(storePath, v);
diff --git a/src/libexpr/value-to-json.cc b/src/libexpr/value-to-json.cc
index 68235ad11..34f3a34c8 100644
--- a/src/libexpr/value-to-json.cc
+++ b/src/libexpr/value-to-json.cc
@@ -85,6 +85,7 @@ void printValueAsJSON(EvalState & state, bool strict,
                 .errPos = state.positions[v.determinePos(pos)]
             });
             e.addTrace(state.positions[pos], hintfmt("message for the trace"));
+            state.debugLastTrace(e);
             throw e;
     }
 }
@@ -99,7 +100,9 @@ void printValueAsJSON(EvalState & state, bool strict,
 void ExternalValueBase::printValueAsJSON(EvalState & state, bool strict,
     JSONPlaceholder & out, PathSet & context) const
 {
-    throw TypeError("cannot convert %1% to JSON", showType());
+    auto e = TypeError("cannot convert %1% to JSON", showType());
+    state.debugLastTrace(e);
+    throw e;
 }
 
 
diff --git a/src/libutil/error.hh b/src/libutil/error.hh
index f4706e3ed..a53e9802e 100644
--- a/src/libutil/error.hh
+++ b/src/libutil/error.hh
@@ -98,6 +98,15 @@ struct ErrPos {
     }
 };
 
+std::optional<LinesOfCode> getCodeLines(const ErrPos & errPos);
+
+void printCodeLines(std::ostream & out,
+    const std::string & prefix,
+    const ErrPos & errPos,
+    const LinesOfCode & loc);
+
+void printAtPos(const ErrPos & pos, std::ostream & out);
+
 struct Trace {
     std::optional<ErrPos> pos;
     hintformat hint;