Merge "Print top-level errors normally in nix repl" into main

doc/manual/rl-next/better-errors-in-nix-repl.md

@@ -1,6 +1,7 @@
 ---
 synopsis: Concise error printing in `nix repl`
 prs: 9928
+cls: 811
 ---
 
 Previously, if an element of a list or attribute set threw an error while

src/libcmd/repl.cc

@@ -167,7 +167,8 @@ struct NixRepl
             .force = true,
             .derivationPaths = true,
             .maxDepth = maxDepth,
-            .prettyIndent = 2
+            .prettyIndent = 2,
+            .errors = ErrorPrintBehavior::ThrowTopLevel,
         });
     }
 };

src/libexpr/print-options.hh

@@ -8,6 +8,29 @@
 
 namespace nix {
 
+/**
+ * How errors should be handled when printing values.
+ */
+enum class ErrorPrintBehavior {
+    /**
+     * Print the first line of the error in brackets: `«error: oh no!»`
+     */
+    Print,
+    /**
+     * Throw the error to the code that attempted to print the value, instead
+     * of suppressing it it.
+     */
+    Throw,
+    /**
+     * Only throw the error if encountered at the top level of the expression.
+     *
+     * This will cause expressions like `builtins.throw "uh oh!"` to throw
+     * errors, but will print attribute sets and other nested structures
+     * containing values that error (like `nixpkgs`) normally.
+     */
+    ThrowTopLevel,
+};
+
 /**
  * Options for printing Nix values.
  */
@@ -68,6 +91,11 @@ struct PrintOptions
      */
     size_t prettyIndent = 0;
 
+    /**
+     * How to handle errors encountered while printing values.
+     */
+    ErrorPrintBehavior errors = ErrorPrintBehavior::Print;
+
     /**
      * True if pretty-printing is enabled.
      */
@@ -86,7 +114,7 @@ static PrintOptions errorPrintOptions = PrintOptions {
     .maxDepth = 10,
     .maxAttrs = 10,
     .maxListItems = 10,
-    .maxStringLength = 1024
+    .maxStringLength = 1024,
 };
 
 }

src/libexpr/print.cc

@@ -229,25 +229,21 @@ private:
 
     void printDerivation(Value & v)
     {
-        try {
+        Bindings::iterator i = v.attrs->find(state.sDrvPath);
-            Bindings::iterator i = v.attrs->find(state.sDrvPath);
+        NixStringContext context;
-            NixStringContext context;
+        std::string storePath;
-            std::string storePath;
+        if (i != v.attrs->end())
-            if (i != v.attrs->end())
+            storePath = state.store->printStorePath(state.coerceToStorePath(i->pos, *i->value, context, "while evaluating the drvPath of a derivation"));
-                storePath = state.store->printStorePath(state.coerceToStorePath(i->pos, *i->value, context, "while evaluating the drvPath of a derivation"));
 
-            if (options.ansiColors)
+        if (options.ansiColors)
-                output << ANSI_GREEN;
+            output << ANSI_GREEN;
-            output << "«derivation";
+        output << "«derivation";
-            if (!storePath.empty()) {
+        if (!storePath.empty()) {
-                output << " " << storePath;
+            output << " " << storePath;
-            }
-            output << "»";
-            if (options.ansiColors)
-                output << ANSI_NORMAL;
-        } catch (Error & e) {
-            printError_(e);
         }
+        output << "»";
+        if (options.ansiColors)
+            output << ANSI_NORMAL;
     }
 
     bool shouldPrettyPrintAttrs(AttrVec & v)
@@ -472,64 +468,68 @@ private:
         output.flush();
         checkInterrupt();
 
-        if (options.force) {
+        try {
-            try {
+            if (options.force) {
                 state.forceValue(v, v.determinePos(noPos));
-            } catch (Error & e) {
-                printError_(e);
-                return;
             }
-        }
 
-        switch (v.type()) {
+            switch (v.type()) {
 
-        case nInt:
+            case nInt:
-            printInt(v);
+                printInt(v);
-            break;
+                break;
 
-        case nFloat:
+            case nFloat:
-            printFloat(v);
+                printFloat(v);
-            break;
+                break;
 
-        case nBool:
+            case nBool:
-            printBool(v);
+                printBool(v);
-            break;
+                break;
 
-        case nString:
+            case nString:
-            printString(v);
+                printString(v);
-            break;
+                break;
 
-        case nPath:
+            case nPath:
-            printPath(v);
+                printPath(v);
-            break;
+                break;
 
-        case nNull:
+            case nNull:
-            printNull();
+                printNull();
-            break;
+                break;
 
-        case nAttrs:
+            case nAttrs:
-            printAttrs(v, depth);
+                printAttrs(v, depth);
-            break;
+                break;
 
-        case nList:
+            case nList:
-            printList(v, depth);
+                printList(v, depth);
-            break;
+                break;
 
-        case nFunction:
+            case nFunction:
-            printFunction(v);
+                printFunction(v);
-            break;
+                break;
 
-        case nThunk:
+            case nThunk:
-            printThunk(v);
+                printThunk(v);
-            break;
+                break;
 
-        case nExternal:
+            case nExternal:
-            printExternal(v);
+                printExternal(v);
-            break;
+                break;
 
-        default:
+            default:
-            printUnknown();
+                printUnknown();
-            break;
+                break;
+            }
+        } catch (Error & e) {
+            if (options.errors == ErrorPrintBehavior::Throw
+                || (options.errors == ErrorPrintBehavior::ThrowTopLevel
+                    && depth == 0)) {
+                throw;
+            }
+            printError_(e);
         }
     }
 

tests/functional/repl_characterization/data/errors.test

@@ -0,0 +1,27 @@
+Errors at the top of an expression are printed normally:
+
+  nix-repl> builtins.throw "Evil puppy detected!!!"
+  error:
+         … while calling the 'throw' builtin
+           at «string»:1:1:
+              1| builtins.throw "Evil puppy detected!!!"
+               | ^
+
+         error: Evil puppy detected!!!
+
+Errors in attribute values are printed inline, to make it easier to explore
+values like nixpkgs where some parts of the value fail to evaluate:
+
+  nix-repl> { puppy = builtins.throw "This puppy is EVIL!!!"; puppy2 = "This puppy is GOOD :)"; }
+  {
+    puppy = «error: This puppy is EVIL!!!»;
+    puppy2 = "This puppy is GOOD :)";
+  }
+
+Same for list values:
+
+  nix-repl> [ (builtins.throw "This puppy is EVIL!!!") ("This puppy is GOOD :)") ]
+  [
+    «error: This puppy is EVIL!!!»
+    "This puppy is GOOD :)"
+  ]

tests/functional/repl_characterization/repl_characterization.cc

@@ -186,5 +186,6 @@ REPL_TEST(repl_overlays_destructure_without_formals_ok);
 REPL_TEST(repl_overlays_error);
 REPL_TEST(repl_printing);
 REPL_TEST(stack_vars);
+REPL_TEST(errors);
 
 }; // namespace nix