Merge pull request #9753 from 9999years/print-value-on-type-error

Print the value in `value is X while a Y is expected` error

(cherry picked from commit 5f72a97092da6af28a7d2b2a50d74e9d34fae7e1)
Change-Id: Idb4bc903ae59a0f5b6fb3b1da4d47970fe0a6efe

7 files changed, 118 insertions, 118 deletions

diff --git a/tests/functional/dyn-drv/eval-outputOf.sh b/tests/functional/dyn-drv/eval-outputOf.sh
index 9467feb8d..3681bd098 100644
--- a/tests/functional/dyn-drv/eval-outputOf.sh
+++ b/tests/functional/dyn-drv/eval-outputOf.sh
@@ -14,7 +14,7 @@ nix --experimental-features 'nix-command' eval --impure  --expr \
 # resolve first. Adding a test so we don't liberalise it by accident.
 expectStderr 1 nix --experimental-features 'nix-command dynamic-derivations' eval --impure --expr \
     'builtins.outputOf (import ../dependencies.nix {}) "out"' \
-    | grepQuiet "value is a set while a string was expected"
+    | grepQuiet "expected a string but found a set"
 
 # Test that "DrvDeep" string contexts are not supported at this time
 #
diff --git a/tests/functional/lang/eval-fail-attr-name-type.err.exp b/tests/functional/lang/eval-fail-attr-name-type.err.exp
index 23cceb58a..c8d56ba7d 100644
--- a/tests/functional/lang/eval-fail-attr-name-type.err.exp
+++ b/tests/functional/lang/eval-fail-attr-name-type.err.exp
@@ -13,4 +13,4 @@ error:
              |                 ^
             8|
 
-       error: value is an integer while a string was expected
+       error: expected a string but found an integer: 1
diff --git a/tests/functional/lang/eval-fail-call-primop.err.exp b/tests/functional/lang/eval-fail-call-primop.err.exp
index ae5b55ed4..0c6f614e8 100644
--- a/tests/functional/lang/eval-fail-call-primop.err.exp
+++ b/tests/functional/lang/eval-fail-call-primop.err.exp
@@ -7,4 +7,4 @@ error:
 
        … while evaluating the first argument passed to builtins.length
 
-       error: value is an integer while a list was expected
+       error: expected a list but found an integer: 1
diff --git a/tests/functional/lang/eval-fail-list.err.exp b/tests/functional/lang/eval-fail-list.err.exp
index 4320fc022..d492f8bd2 100644
--- a/tests/functional/lang/eval-fail-list.err.exp
+++ b/tests/functional/lang/eval-fail-list.err.exp
@@ -5,4 +5,4 @@ error:
              |  ^
             2|
 
-       error: value is an integer while a list was expected
+       error: expected a list but found an integer: 8
diff --git a/tests/functional/lang/eval-fail-set-override.err.exp b/tests/functional/lang/eval-fail-set-override.err.exp
index 71481683d..9006ca4e6 100644
--- a/tests/functional/lang/eval-fail-set-override.err.exp
+++ b/tests/functional/lang/eval-fail-set-override.err.exp
@@ -1,4 +1,4 @@
 error:
        … while evaluating the `__overrides` attribute
 
-       error: value is an integer while a set was expected
+       error: expected a set but found an integer: 1
diff --git a/tests/functional/lang/eval-fail-using-set-as-attr-name.err.exp b/tests/functional/lang/eval-fail-using-set-as-attr-name.err.exp
index 0a4f56ac5..94784c651 100644
--- a/tests/functional/lang/eval-fail-using-set-as-attr-name.err.exp
+++ b/tests/functional/lang/eval-fail-using-set-as-attr-name.err.exp
@@ -6,4 +6,4 @@ error:
              |          ^
             6|
 
-       error: value is a set while a string was expected
+       error: expected a string but found a set: { }
diff --git a/tests/unit/libexpr/error_traces.cc b/tests/unit/libexpr/error_traces.cc
index 628e73f25..7f83aaecd 100644
--- a/tests/unit/libexpr/error_traces.cc
+++ b/tests/unit/libexpr/error_traces.cc
@@ -105,7 +105,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, genericClosure) {
         ASSERT_TRACE2("genericClosure 1",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "an integer"),
+                      hintfmt("expected a set but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.genericClosure"));
 
         ASSERT_TRACE2("genericClosure {}",
@@ -115,22 +115,22 @@ namespace nix {
 
         ASSERT_TRACE2("genericClosure { startSet = 1; }",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the 'startSet' attribute passed as argument to builtins.genericClosure"));
 
         ASSERT_TRACE2("genericClosure { startSet = [{ key = 1;}]; operator = true; }",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "a Boolean"),
+                      hintfmt("expected a function but found %s: %s", "a Boolean", ANSI_CYAN "true" ANSI_NORMAL),
                       hintfmt("while evaluating the 'operator' attribute passed as argument to builtins.genericClosure"));
 
         ASSERT_TRACE2("genericClosure { startSet = [{ key = 1;}]; operator = item: true; }",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a Boolean"),
+                      hintfmt("expected a list but found %s: %s", "a Boolean", ANSI_CYAN "true" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the `operator` passed to builtins.genericClosure"));
 
         ASSERT_TRACE2("genericClosure { startSet = [{ key = 1;}]; operator = item: [ true ]; }",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a Boolean"),
+                      hintfmt("expected a set but found %s: %s", "a Boolean", ANSI_CYAN "true" ANSI_NORMAL),
                       hintfmt("while evaluating one of the elements generated by (or initially passed to) builtins.genericClosure"));
 
         ASSERT_TRACE2("genericClosure { startSet = [{ key = 1;}]; operator = item: [ {} ]; }",
@@ -145,7 +145,7 @@ namespace nix {
 
         ASSERT_TRACE2("genericClosure { startSet = [ true ]; operator = item: [{ key = ''a''; }]; }",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a Boolean"),
+                      hintfmt("expected a set but found %s: %s", "a Boolean", ANSI_CYAN "true" ANSI_NORMAL),
                       hintfmt("while evaluating one of the elements generated by (or initially passed to) builtins.genericClosure"));
 
     }
@@ -154,12 +154,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, replaceStrings) {
         ASSERT_TRACE2("replaceStrings 0 0 {}",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "0" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.replaceStrings"));
 
         ASSERT_TRACE2("replaceStrings [] 0 {}",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "0" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.replaceStrings"));
 
         ASSERT_TRACE1("replaceStrings [ 0 ] [] {}",
@@ -168,17 +168,17 @@ namespace nix {
 
         ASSERT_TRACE2("replaceStrings [ 1 ] [ \"new\" ] {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating one of the strings to replace passed to builtins.replaceStrings"));
 
         ASSERT_TRACE2("replaceStrings [ \"oo\" ] [ true ] \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a Boolean"),
+                      hintfmt("expected a string but found %s: %s", "a Boolean", ANSI_CYAN "true" ANSI_NORMAL),
                       hintfmt("while evaluating one of the replacement strings passed to builtins.replaceStrings"));
 
         ASSERT_TRACE2("replaceStrings [ \"old\" ] [ \"new\" ] {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a set"),
+                      hintfmt("expected a string but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the third argument passed to builtins.replaceStrings"));
 
     }
@@ -243,7 +243,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, ceil) {
         ASSERT_TRACE2("ceil \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a float was expected", "a string"),
+                      hintfmt("expected a float but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.ceil"));
 
     }
@@ -252,7 +252,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, floor) {
         ASSERT_TRACE2("floor \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a float was expected", "a string"),
+                      hintfmt("expected a float but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.floor"));
 
     }
@@ -265,7 +265,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, getEnv) {
         ASSERT_TRACE2("getEnv [ ]",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a list"),
+                      hintfmt("expected a string but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.getEnv"));
 
     }
@@ -286,7 +286,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, placeholder) {
         ASSERT_TRACE2("placeholder []",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a list"),
+                      hintfmt("expected a string but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.placeholder"));
 
     }
@@ -387,7 +387,7 @@ namespace nix {
 
         ASSERT_TRACE2("filterSource [] ./.",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "a list"),
+                      hintfmt("expected a function but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.filterSource"));
 
         // Usupported by store "dummy"
@@ -399,7 +399,7 @@ namespace nix {
 
         // ASSERT_TRACE2("filterSource (_: _: 1) ./.",
         //               TypeError,
-        //               hintfmt("value is %s while a Boolean was expected", "an integer"),
+        //               hintfmt("expected a Boolean but found %s: %s", "an integer", "1"),
         //               hintfmt("while evaluating the return value of the path filter function"));
 
     }
@@ -412,7 +412,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, attrNames) {
         ASSERT_TRACE2("attrNames []",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a list"),
+                      hintfmt("expected a set but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the argument passed to builtins.attrNames"));
 
     }
@@ -421,7 +421,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, attrValues) {
         ASSERT_TRACE2("attrValues []",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a list"),
+                      hintfmt("expected a set but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the argument passed to builtins.attrValues"));
 
     }
@@ -430,12 +430,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, getAttr) {
         ASSERT_TRACE2("getAttr [] []",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a list"),
+                      hintfmt("expected a string but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.getAttr"));
 
         ASSERT_TRACE2("getAttr \"foo\" []",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a list"),
+                      hintfmt("expected a set but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the second argument passed to builtins.getAttr"));
 
         ASSERT_TRACE2("getAttr \"foo\" {}",
@@ -453,12 +453,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, hasAttr) {
         ASSERT_TRACE2("hasAttr [] []",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a list"),
+                      hintfmt("expected a string but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.hasAttr"));
 
         ASSERT_TRACE2("hasAttr \"foo\" []",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a list"),
+                      hintfmt("expected a set but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the second argument passed to builtins.hasAttr"));
 
     }
@@ -471,17 +471,17 @@ namespace nix {
     TEST_F(ErrorTraceTest, removeAttrs) {
         ASSERT_TRACE2("removeAttrs \"\" \"\"",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a string"),
+                      hintfmt("expected a set but found %s: %s", "a string", ANSI_MAGENTA "\"\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.removeAttrs"));
 
         ASSERT_TRACE2("removeAttrs \"\" [ 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a string"),
+                      hintfmt("expected a set but found %s: %s", "a string", ANSI_MAGENTA "\"\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.removeAttrs"));
 
         ASSERT_TRACE2("removeAttrs \"\" [ \"1\" ]",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a string"),
+                      hintfmt("expected a set but found %s: %s", "a string", ANSI_MAGENTA "\"\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.removeAttrs"));
 
     }
@@ -490,12 +490,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, listToAttrs) {
         ASSERT_TRACE2("listToAttrs 1",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the argument passed to builtins.listToAttrs"));
 
         ASSERT_TRACE2("listToAttrs [ 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "an integer"),
+                      hintfmt("expected a set but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating an element of the list passed to builtins.listToAttrs"));
 
         ASSERT_TRACE2("listToAttrs [ {} ]",
@@ -505,7 +505,7 @@ namespace nix {
 
         ASSERT_TRACE2("listToAttrs [ { name = 1; } ]",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the `name` attribute of an element of the list passed to builtins.listToAttrs"));
 
         ASSERT_TRACE2("listToAttrs [ { name = \"foo\"; } ]",
@@ -519,12 +519,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, intersectAttrs) {
         ASSERT_TRACE2("intersectAttrs [] []",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a list"),
+                      hintfmt("expected a set but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.intersectAttrs"));
 
         ASSERT_TRACE2("intersectAttrs {} []",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a list"),
+                      hintfmt("expected a set but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the second argument passed to builtins.intersectAttrs"));
 
     }
@@ -533,22 +533,22 @@ namespace nix {
     TEST_F(ErrorTraceTest, catAttrs) {
         ASSERT_TRACE2("catAttrs [] {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a list"),
+                      hintfmt("expected a string but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.catAttrs"));
 
         ASSERT_TRACE2("catAttrs \"foo\" {}",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a set"),
+                      hintfmt("expected a list but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the second argument passed to builtins.catAttrs"));
 
         ASSERT_TRACE2("catAttrs \"foo\" [ 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "an integer"),
+                      hintfmt("expected a set but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating an element in the list passed as second argument to builtins.catAttrs"));
 
         ASSERT_TRACE2("catAttrs \"foo\" [ { foo = 1; } 1 { bar = 5;} ]",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "an integer"),
+                      hintfmt("expected a set but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating an element in the list passed as second argument to builtins.catAttrs"));
 
     }
@@ -565,7 +565,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, mapAttrs) {
         ASSERT_TRACE2("mapAttrs [] []",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a list"),
+                      hintfmt("expected a set but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the second argument passed to builtins.mapAttrs"));
 
         // XXX: defered
@@ -590,12 +590,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, zipAttrsWith) {
         ASSERT_TRACE2("zipAttrsWith [] [ 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "a list"),
+                      hintfmt("expected a function but found %s: %s", "a list", "[ ]"),
                       hintfmt("while evaluating the first argument passed to builtins.zipAttrsWith"));
 
         ASSERT_TRACE2("zipAttrsWith (_: 1) [ 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "an integer"),
+                      hintfmt("expected a set but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating a value of the list passed as second argument to builtins.zipAttrsWith"));
 
         // XXX: How to properly tell that the fucntion takes two arguments ?
@@ -622,7 +622,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, elemAt) {
         ASSERT_TRACE2("elemAt \"foo\" (-1)",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.elemAt"));
 
         ASSERT_TRACE1("elemAt [] (-1)",
@@ -639,7 +639,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, head) {
         ASSERT_TRACE2("head 1",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.elemAt"));
 
         ASSERT_TRACE1("head []",
@@ -652,7 +652,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, tail) {
         ASSERT_TRACE2("tail 1",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.tail"));
 
         ASSERT_TRACE1("tail []",
@@ -665,12 +665,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, map) {
         ASSERT_TRACE2("map 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.map"));
 
         ASSERT_TRACE2("map 1 [ 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.map"));
 
     }
@@ -679,17 +679,17 @@ namespace nix {
     TEST_F(ErrorTraceTest, filter) {
         ASSERT_TRACE2("filter 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.filter"));
 
         ASSERT_TRACE2("filter 1 [ \"foo\" ]",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.filter"));
 
         ASSERT_TRACE2("filter (_: 5) [ \"foo\" ]",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "an integer"),
+                      hintfmt("expected a Boolean but found %s: %s", "an integer", ANSI_CYAN "5" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the filtering function passed to builtins.filter"));
 
     }
@@ -698,7 +698,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, elem) {
         ASSERT_TRACE2("elem 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.elem"));
 
     }
@@ -707,17 +707,17 @@ namespace nix {
     TEST_F(ErrorTraceTest, concatLists) {
         ASSERT_TRACE2("concatLists 1",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.concatLists"));
 
         ASSERT_TRACE2("concatLists [ 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating a value of the list passed to builtins.concatLists"));
 
         ASSERT_TRACE2("concatLists [ [1] \"foo\" ]",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating a value of the list passed to builtins.concatLists"));
 
     }
@@ -726,12 +726,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, length) {
         ASSERT_TRACE2("length 1",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.length"));
 
         ASSERT_TRACE2("length \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.length"));
 
     }
@@ -740,12 +740,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, foldlPrime) {
         ASSERT_TRACE2("foldl' 1 \"foo\" true",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.foldlStrict"));
 
         ASSERT_TRACE2("foldl' (_: 1) \"foo\" true",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a Boolean"),
+                      hintfmt("expected a list but found %s: %s", "a Boolean", ANSI_CYAN "true" ANSI_NORMAL),
                       hintfmt("while evaluating the third argument passed to builtins.foldlStrict"));
 
         ASSERT_TRACE1("foldl' (_: 1) \"foo\" [ true ]",
@@ -754,7 +754,7 @@ namespace nix {
 
         ASSERT_TRACE2("foldl' (a: b: a && b) \"foo\" [ true ]",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "a string"),
+                      hintfmt("expected a Boolean but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("in the left operand of the AND (&&) operator"));
 
     }
@@ -763,17 +763,17 @@ namespace nix {
     TEST_F(ErrorTraceTest, any) {
         ASSERT_TRACE2("any 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.any"));
 
         ASSERT_TRACE2("any (_: 1) \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.any"));
 
         ASSERT_TRACE2("any (_: 1) [ \"foo\" ]",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "an integer"),
+                      hintfmt("expected a Boolean but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the function passed to builtins.any"));
 
     }
@@ -782,17 +782,17 @@ namespace nix {
     TEST_F(ErrorTraceTest, all) {
         ASSERT_TRACE2("all 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.all"));
 
         ASSERT_TRACE2("all (_: 1) \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.all"));
 
         ASSERT_TRACE2("all (_: 1) [ \"foo\" ]",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "an integer"),
+                      hintfmt("expected a Boolean but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the function passed to builtins.all"));
 
     }
@@ -801,12 +801,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, genList) {
         ASSERT_TRACE2("genList 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.genList"));
 
         ASSERT_TRACE2("genList 1 2",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.genList", "an integer"));
 
         // XXX: defered
@@ -825,12 +825,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, sort) {
         ASSERT_TRACE2("sort 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.sort"));
 
         ASSERT_TRACE2("sort 1 [ \"foo\" ]",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.sort"));
 
         ASSERT_TRACE1("sort (_: 1) [ \"foo\" \"bar\" ]",
@@ -839,7 +839,7 @@ namespace nix {
 
         ASSERT_TRACE2("sort (_: _: 1) [ \"foo\" \"bar\" ]",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "an integer"),
+                      hintfmt("expected a Boolean but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the sorting function passed to builtins.sort"));
 
         // XXX: Trace too deep, need better asserts
@@ -857,17 +857,17 @@ namespace nix {
     TEST_F(ErrorTraceTest, partition) {
         ASSERT_TRACE2("partition 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.partition"));
 
         ASSERT_TRACE2("partition (_: 1) \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.partition"));
 
         ASSERT_TRACE2("partition (_: 1) [ \"foo\" ]",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "an integer"),
+                      hintfmt("expected a Boolean but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the partition function passed to builtins.partition"));
 
     }
@@ -876,17 +876,17 @@ namespace nix {
     TEST_F(ErrorTraceTest, groupBy) {
         ASSERT_TRACE2("groupBy 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.groupBy"));
 
         ASSERT_TRACE2("groupBy (_: 1) \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.groupBy"));
 
         ASSERT_TRACE2("groupBy (x: x) [ \"foo\" \"bar\" 1 ]",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the grouping function passed to builtins.groupBy"));
 
     }
@@ -895,22 +895,22 @@ namespace nix {
     TEST_F(ErrorTraceTest, concatMap) {
         ASSERT_TRACE2("concatMap 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a function was expected", "an integer"),
+                      hintfmt("expected a function but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.concatMap"));
 
         ASSERT_TRACE2("concatMap (x: 1) \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.concatMap"));
 
         ASSERT_TRACE2("concatMap (x: 1) [ \"foo\" ] # TODO",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "an integer"),
+                      hintfmt("expected a list but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the function passed to builtins.concatMap"));
 
         ASSERT_TRACE2("concatMap (x: \"foo\") [ 1 2 ] # TODO",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the return value of the function passed to builtins.concatMap"));
 
     }
@@ -919,12 +919,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, add) {
         ASSERT_TRACE2("add \"foo\" 1",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument of the addition"));
 
         ASSERT_TRACE2("add 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument of the addition"));
 
     }
@@ -933,12 +933,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, sub) {
         ASSERT_TRACE2("sub \"foo\" 1",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument of the subtraction"));
 
         ASSERT_TRACE2("sub 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument of the subtraction"));
 
     }
@@ -947,12 +947,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, mul) {
         ASSERT_TRACE2("mul \"foo\" 1",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument of the multiplication"));
 
         ASSERT_TRACE2("mul 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument of the multiplication"));
 
     }
@@ -961,12 +961,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, div) {
         ASSERT_TRACE2("div \"foo\" 1 # TODO: an integer was expected -> a number",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the first operand of the division"));
 
         ASSERT_TRACE2("div 1 \"foo\"",
                       TypeError,
-                      hintfmt("value is %s while a float was expected", "a string"),
+                      hintfmt("expected a float but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second operand of the division"));
 
         ASSERT_TRACE1("div \"foo\" 0",
@@ -979,12 +979,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, bitAnd) {
         ASSERT_TRACE2("bitAnd 1.1 2",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a float"),
+                      hintfmt("expected an integer but found %s: %s", "a float", ANSI_CYAN "1.1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.bitAnd"));
 
         ASSERT_TRACE2("bitAnd 1 2.2",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a float"),
+                      hintfmt("expected an integer but found %s: %s", "a float", ANSI_CYAN "2.2" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.bitAnd"));
 
     }
@@ -993,12 +993,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, bitOr) {
         ASSERT_TRACE2("bitOr 1.1 2",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a float"),
+                      hintfmt("expected an integer but found %s: %s", "a float", ANSI_CYAN "1.1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.bitOr"));
 
         ASSERT_TRACE2("bitOr 1 2.2",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a float"),
+                      hintfmt("expected an integer but found %s: %s", "a float", ANSI_CYAN "2.2" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.bitOr"));
 
     }
@@ -1007,12 +1007,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, bitXor) {
         ASSERT_TRACE2("bitXor 1.1 2",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a float"),
+                      hintfmt("expected an integer but found %s: %s", "a float", ANSI_CYAN "1.1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.bitXor"));
 
         ASSERT_TRACE2("bitXor 1 2.2",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a float"),
+                      hintfmt("expected an integer but found %s: %s", "a float", ANSI_CYAN "2.2" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument passed to builtins.bitXor"));
 
     }
@@ -1047,12 +1047,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, substring) {
         ASSERT_TRACE2("substring {} \"foo\" true",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a set"),
+                      hintfmt("expected an integer but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the first argument (the start offset) passed to builtins.substring"));
 
         ASSERT_TRACE2("substring 3 \"foo\" true",
                       TypeError,
-                      hintfmt("value is %s while an integer was expected", "a string"),
+                      hintfmt("expected an integer but found %s: %s", "a string", ANSI_MAGENTA "\"foo\"" ANSI_NORMAL),
                       hintfmt("while evaluating the second argument (the substring length) passed to builtins.substring"));
 
         ASSERT_TRACE2("substring 0 3 {}",
@@ -1079,7 +1079,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, hashString) {
         ASSERT_TRACE2("hashString 1 {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.hashString"));
 
         ASSERT_TRACE1("hashString \"foo\" \"content\"",
@@ -1088,7 +1088,7 @@ namespace nix {
 
         ASSERT_TRACE2("hashString \"sha256\" {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a set"),
+                      hintfmt("expected a string but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the second argument passed to builtins.hashString"));
 
     }
@@ -1097,12 +1097,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, match) {
         ASSERT_TRACE2("match 1 {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.match"));
 
         ASSERT_TRACE2("match \"foo\" {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a set"),
+                      hintfmt("expected a string but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the second argument passed to builtins.match"));
 
         ASSERT_TRACE1("match \"(.*\" \"\"",
@@ -1115,12 +1115,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, split) {
         ASSERT_TRACE2("split 1 {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.split"));
 
         ASSERT_TRACE2("split \"foo\" {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a set"),
+                      hintfmt("expected a string but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the second argument passed to builtins.split"));
 
         ASSERT_TRACE1("split \"f(o*o\" \"1foo2\"",
@@ -1133,12 +1133,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, concatStringsSep) {
         ASSERT_TRACE2("concatStringsSep 1 {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument (the separator string) passed to builtins.concatStringsSep"));
 
         ASSERT_TRACE2("concatStringsSep \"foo\" {}",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a set"),
+                      hintfmt("expected a list but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the second argument (the list of strings to concat) passed to builtins.concatStringsSep"));
 
         ASSERT_TRACE2("concatStringsSep \"foo\" [ 1 2 {} ] # TODO: coerce to string is buggy",
@@ -1152,7 +1152,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, parseDrvName) {
         ASSERT_TRACE2("parseDrvName 1",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.parseDrvName"));
 
     }
@@ -1161,12 +1161,12 @@ namespace nix {
     TEST_F(ErrorTraceTest, compareVersions) {
         ASSERT_TRACE2("compareVersions 1 {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.compareVersions"));
 
         ASSERT_TRACE2("compareVersions \"abd\" {}",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "a set"),
+                      hintfmt("expected a string but found %s: %s", "a set", "{ }"),
                       hintfmt("while evaluating the second argument passed to builtins.compareVersions"));
 
     }
@@ -1175,7 +1175,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, splitVersion) {
         ASSERT_TRACE2("splitVersion 1",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", ANSI_CYAN "1" ANSI_NORMAL),
                       hintfmt("while evaluating the first argument passed to builtins.splitVersion"));
 
     }
@@ -1189,7 +1189,7 @@ namespace nix {
     TEST_F(ErrorTraceTest, derivationStrict) {
         ASSERT_TRACE2("derivationStrict \"\"",
                       TypeError,
-                      hintfmt("value is %s while a set was expected", "a string"),
+                      hintfmt("expected a set but found %s: %s", "a string", "\"\""),
                       hintfmt("while evaluating the argument passed to builtins.derivationStrict"));
 
         ASSERT_TRACE2("derivationStrict {}",
@@ -1199,7 +1199,7 @@ namespace nix {
 
         ASSERT_TRACE2("derivationStrict { name = 1; }",
                       TypeError,
-                      hintfmt("value is %s while a string was expected", "an integer"),
+                      hintfmt("expected a string but found %s: %s", "an integer", "1"),
                       hintfmt("while evaluating the `name` attribute passed to builtins.derivationStrict"));
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; }",
@@ -1209,12 +1209,12 @@ namespace nix {
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; __structuredAttrs = 15; }",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "an integer"),
+                      hintfmt("expected a Boolean but found %s: %s", "an integer", "15"),
                       hintfmt("while evaluating the `__structuredAttrs` attribute passed to builtins.derivationStrict"));
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; __ignoreNulls = 15; }",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "an integer"),
+                      hintfmt("expected a Boolean but found %s: %s", "an integer", "15"),
                       hintfmt("while evaluating the `__ignoreNulls` attribute passed to builtins.derivationStrict"));
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; outputHashMode = 15; }",
@@ -1259,22 +1259,22 @@ namespace nix {
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; system = 1; outputs = \"out\"; __contentAddressed = \"true\"; }",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "a string"),
+                      hintfmt("expected a Boolean but found %s: %s", "a string", "\"true\""),
                       hintfmt("while evaluating the attribute '__contentAddressed' of derivation 'foo'"));
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; system = 1; outputs = \"out\"; __impure = \"true\"; }",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "a string"),
+                      hintfmt("expected a Boolean but found %s: %s", "a string", "\"true\""),
                       hintfmt("while evaluating the attribute '__impure' of derivation 'foo'"));
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; system = 1; outputs = \"out\"; __impure = \"true\"; }",
                       TypeError,
-                      hintfmt("value is %s while a Boolean was expected", "a string"),
+                      hintfmt("expected a Boolean but found %s: %s", "a string", "\"true\""),
                       hintfmt("while evaluating the attribute '__impure' of derivation 'foo'"));
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; system = 1; outputs = \"out\"; args = \"foo\"; }",
                       TypeError,
-                      hintfmt("value is %s while a list was expected", "a string"),
+                      hintfmt("expected a list but found %s: %s", "a string", "\"foo\""),
                       hintfmt("while evaluating the attribute 'args' of derivation 'foo'"));
 
         ASSERT_TRACE2("derivationStrict { name = \"foo\"; builder = 1; system = 1; outputs = \"out\"; args = [ {} ]; }",