expressions: add logical negation

While this can already be expressed by an "if" statement, having
a dedicated function for logical negation makes some expressions
more readable.

3 files changed, 42 insertions, 0 deletions

diff --git a/doc/concepts/expressions.md b/doc/concepts/expressions.md
index b3dbd82f..d54bf34f 100644
--- a/doc/concepts/expressions.md
+++ b/doc/concepts/expressions.md
@@ -213,6 +213,10 @@ those) argument(s) to obtain the final result.
 
 ##### Unary functions
 
+ - `"not"` Return the logical negation of the argument, i.e.,
+   if the argument is logically false, return `true`, and `false`
+   otherwise.
+
  - `"nub_right"` The argument has to be a list. It is an error
    if that list contains (directly or indirectly) a name. The
    result is the input list, except that for all duplicate
diff --git a/src/buildtool/build_engine/expression/evaluator.cpp b/src/buildtool/build_engine/expression/evaluator.cpp
index d53259ba..2256a040 100644
--- a/src/buildtool/build_engine/expression/evaluator.cpp
+++ b/src/buildtool/build_engine/expression/evaluator.cpp
@@ -176,6 +176,14 @@ auto LogicalOr(SubExprEvaluator&& eval,
     return ExpressionPtr{false};
 }
 
+// Logical Negation
+auto Not(ExpressionPtr const& expr) -> ExpressionPtr {
+    if (ValueIsTrue(expr)) {
+        return ExpressionPtr{false};
+    }
+    return ExpressionPtr{true};
+}
+
 auto Keys(ExpressionPtr const& d) -> ExpressionPtr {
     auto const& m = d->Map();
     auto result = Expression::list_t{};
@@ -1092,6 +1100,7 @@ auto const kBuiltInFunctions =
                           {"==", EqualExpr},
                           {"and", AndExpr},
                           {"or", OrExpr},
+                          {"not", UnaryExpr(Not)},
                           {"++", UnaryExpr(Flatten)},
                           {"+", UnaryExpr(Addition)},
                           {"*", UnaryExpr(Multiplication)},
diff --git a/test/buildtool/build_engine/expression/expression.test.cpp b/test/buildtool/build_engine/expression/expression.test.cpp
index 1d7bde3e..0bc5439b 100644
--- a/test/buildtool/build_engine/expression/expression.test.cpp
+++ b/test/buildtool/build_engine/expression/expression.test.cpp
@@ -647,6 +647,35 @@ TEST_CASE("Expression Evaluation", "[expression]") {  // NOLINT
         CHECK(failure == Expression::FromJson("false"_json));
     }
 
+    SECTION("not expression") {
+        auto expr = Expression::FromJson(R"(
+            { "type": "not"
+            , "$1": {"type": "var", "name": "x" }
+            })"_json);
+        REQUIRE(expr);
+
+        CHECK(expr.Evaluate(env.Update("x", true), fcts) ==
+              Expression::FromJson("false"_json));
+        CHECK(expr.Evaluate(env.Update("x", false), fcts) ==
+              Expression::FromJson("true"_json));
+        CHECK(expr.Evaluate(env.Update("x", Expression::FromJson(R"([])"_json)),
+                            fcts) == Expression::FromJson("true"_json));
+        CHECK(expr.Evaluate(
+                  env.Update("x", Expression::FromJson(R"(["a"])"_json)),
+                  fcts) == Expression::FromJson("false"_json));
+        CHECK(expr.Evaluate(env.Update("x", Expression::FromJson("null"_json)),
+                            fcts) == Expression::FromJson("true"_json));
+        CHECK(expr.Evaluate(env.Update("x", Expression::FromJson("0"_json)),
+                            fcts) == Expression::FromJson("true"_json));
+        CHECK(expr.Evaluate(env.Update("x", Expression::FromJson("1"_json)),
+                            fcts) == Expression::FromJson("false"_json));
+        CHECK(expr.Evaluate(env.Update("x", Expression::FromJson(R"("")"_json)),
+                            fcts) == Expression::FromJson("true"_json));
+        CHECK(expr.Evaluate(
+                  env.Update("x", Expression::FromJson(R"("0")"_json)), fcts) ==
+              Expression::FromJson("false"_json));
+    }
+
     SECTION("and expression") {
         auto expr = Expression::FromJson(R"(
             { "type": "and"