3 files changed, 29 insertions, 12 deletions
diff --git a/tvix/eval/src/compiler/mod.rs b/tvix/eval/src/compiler/mod.rs
index 9cbbf62dbd0a..51dc49242882 100644
--- a/tvix/eval/src/compiler/mod.rs
+++ b/tvix/eval/src/compiler/mod.rs
@@ -1340,7 +1340,10 @@ fn compile_src_builtin(
             weak.upgrade().unwrap(),
             &mut crate::observer::NoOpObserver {},
         )
-        .map_err(|e| ErrorKind::NativeError(Box::new(e)))?;
+        .map_err(|e| ErrorKind::NativeError {
+            gen_type: "derivation",
+            err: Box::new(e),
+        })?;
 
         if !result.errors.is_empty() {
             return Err(ErrorKind::ImportCompilerError {
diff --git a/tvix/eval/src/errors.rs b/tvix/eval/src/errors.rs
index de17f8d332ed..5e890c68a74c 100644
--- a/tvix/eval/src/errors.rs
+++ b/tvix/eval/src/errors.rs
@@ -83,7 +83,10 @@ pub enum ErrorKind {
 
     /// An error occured while executing some native code (e.g. a
     /// builtin), and needs to be chained up.
-    NativeError(Box<Error>),
+    NativeError {
+        gen_type: &'static str,
+        err: Box<Error>,
+    },
 
     /// An error occured while executing Tvix bytecode, but needs to
     /// be chained up.
@@ -179,7 +182,7 @@ pub enum ErrorKind {
 impl error::Error for Error {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match &self.kind {
-            ErrorKind::NativeError(err) | ErrorKind::BytecodeError(err) => err.source(),
+            ErrorKind::NativeError { err, .. } | ErrorKind::BytecodeError(err) => err.source(),
             ErrorKind::ParseErrors(err) => err.first().map(|e| e as &dyn error::Error),
             ErrorKind::ParseIntError(err) => Some(err),
             ErrorKind::ImportParseError { errors, .. } => {
@@ -234,7 +237,7 @@ impl ErrorKind {
     pub fn is_catchable(&self) -> bool {
         match self {
             Self::Throw(_) | Self::AssertionFailed | Self::NixPathResolution(_) => true,
-            Self::NativeError(err) | Self::BytecodeError(err) => err.kind.is_catchable(),
+            Self::NativeError { err, .. } | Self::BytecodeError(err) => err.kind.is_catchable(),
             _ => false,
         }
     }
@@ -356,7 +359,10 @@ to a missing value in the attribute set(s) included via `with`."#,
             // Errors themselves ignored here & handled in Self::spans instead
             ErrorKind::ParseErrors(_) => write!(f, "failed to parse Nix code:"),
 
-            ErrorKind::NativeError(_) => write!(f, "while evaluating this native code"),
+            ErrorKind::NativeError { gen_type, .. } => {
+                write!(f, "while evaluating this as native code ({})", gen_type)
+            }
+
             ErrorKind::BytecodeError(_) => write!(f, "while evaluating this Nix code"),
 
             ErrorKind::NotCoercibleToString { kind, from } => {
@@ -750,7 +756,7 @@ impl Error {
             | ErrorKind::NotCallable(_)
             | ErrorKind::InfiniteRecursion
             | ErrorKind::ParseErrors(_)
-            | ErrorKind::NativeError(_)
+            | ErrorKind::NativeError { .. }
             | ErrorKind::BytecodeError(_)
             | ErrorKind::NotCoercibleToString { .. }
             | ErrorKind::NotAnAbsolutePath(_)
@@ -827,7 +833,9 @@ impl Error {
 
             // Chained errors should yield the code of the innermost
             // error.
-            ErrorKind::NativeError(ref err) | ErrorKind::BytecodeError(ref err) => err.code(),
+            ErrorKind::NativeError { ref err, .. } | ErrorKind::BytecodeError(ref err) => {
+                err.code()
+            }
 
             ErrorKind::WithContext { .. } => {
                 panic!("internal ErrorKind::WithContext variant leaked")
@@ -910,7 +918,7 @@ impl Error {
             //
             // We don't know how deep this chain is, so we avoid recursing in
             // this function while unrolling the chain.
-            ErrorKind::NativeError(next) | ErrorKind::BytecodeError(next) => {
+            ErrorKind::NativeError { err: next, .. } | ErrorKind::BytecodeError(next) => {
                 // Accumulated diagnostics to return.
                 let mut diagnostics: Vec<Diagnostic> = vec![];
 
@@ -945,7 +953,8 @@ impl Error {
                     this_spans = next.spans(source);
 
                     match next.kind {
-                        ErrorKind::NativeError(inner) | ErrorKind::BytecodeError(inner) => {
+                        ErrorKind::NativeError { err: inner, .. }
+                        | ErrorKind::BytecodeError(inner) => {
                             next = *inner;
                             continue;
                         }
diff --git a/tvix/eval/src/vm/mod.rs b/tvix/eval/src/vm/mod.rs
index 60039eab3342..450d950b34a6 100644
--- a/tvix/eval/src/vm/mod.rs
+++ b/tvix/eval/src/vm/mod.rs
@@ -99,9 +99,14 @@ impl<T, S: GetSpan> WithSpan<T, S> for Result<T, ErrorKind> {
                             error =
                                 Error::new(ErrorKind::BytecodeError(Box::new(error)), span.span());
                         }
-                        Frame::Generator { span, .. } => {
-                            error =
-                                Error::new(ErrorKind::NativeError(Box::new(error)), span.span());
+                        Frame::Generator { name, span, .. } => {
+                            error = Error::new(
+                                ErrorKind::NativeError {
+                                    err: Box::new(error),
+                                    gen_type: name,
+                                },
+                                span.span(),
+                            );
                         }
                     }
                 }