Allow all boolean convertible types in unary logical not expressions

MikePopoloski · Jan 11, 2025 · f04d7a0 · f04d7a0
1 parent 2d2d39f
commit f04d7a0
Show file tree

Hide file tree

Showing 4 changed files with 42 additions and 2 deletions.
diff --git a/source/ast/expressions/OperatorExpressions.cpp b/source/ast/expressions/OperatorExpressions.cpp
@@ -242,8 +242,8 @@ Expression& UnaryExpression::fromSyntax(Compilation& compilation,
             result->type = type;
             break;
         case SyntaxKind::UnaryLogicalNotExpression:
-            // Supported for both integral and real types. Result is a single bit.
-            good = type->isNumeric();
+            // Supported for all boolean convertible types. Result is a single bit.
+            good = type->isBooleanConvertible();
             result->type = type->isFourState() ? &compilation.getLogicType()
                                                : &compilation.getBitType();
             selfDetermined(context, result->operand_);
@@ -491,6 +491,9 @@ ConstantValue UnaryExpression::evalImpl(EvalContext& context) const {
                 break;
         }
     }
+    else if (op == UnaryOperator::LogicalNot) {
+        return SVInt(cv.isFalse());
+    }
 
 #undef OP
     SLANG_UNREACHABLE;

diff --git a/source/numeric/ConstantValue.cpp b/source/numeric/ConstantValue.cpp
@@ -253,6 +253,8 @@ bool ConstantValue::isTrue() const {
                 return (bool)arg;
             else if constexpr (std::is_same_v<T, ConstantValue::UnboundedPlaceholder>)
                 return true;
+            else if constexpr (std::is_same_v<T, std::string>)
+                return !arg.empty();
             else
                 return false;
         },
@@ -273,6 +275,8 @@ bool ConstantValue::isFalse() const {
                 return !(bool)arg;
             else if constexpr (std::is_same_v<T, ConstantValue::NullPlaceholder>)
                 return true;
+            else if constexpr (std::is_same_v<T, std::string>)
+                return arg.empty();
             else
                 return false;
         },

diff --git a/tests/unittests/ast/EvalTests.cpp b/tests/unittests/ast/EvalTests.cpp
@@ -2608,3 +2608,19 @@ endmodule
     auto& compare = root.lookupName<ParameterSymbol>("m.Compare");
     CHECK(compare.getValue().integer() == 1);
 }
+
+TEST_CASE("Eval truthiness of strings") {
+    ScriptSession session(optionsFor(LanguageVersion::v1800_2023));
+    session.eval(R"(
+function automatic bit b;
+    string s = "SDF";
+    if (s)
+        return 1;
+    return 0;
+endfunction
+)");
+
+    CHECK(session.eval("b()").integer() == 1);
+
+    NO_SESSION_ERRORS;
+}
diff --git a/tests/unittests/ast/ExpressionTests.cpp b/tests/unittests/ast/ExpressionTests.cpp
@@ -3771,3 +3771,20 @@ endmodule
     compilation.addSyntaxTree(tree);
     NO_COMPILATION_ERRORS;
 }
+
+TEST_CASE("Boolean convertible types can be used with operator! -- GH #1208") {
+    auto tree = SyntaxTree::fromText(R"(
+module m;
+    chandle handle = null;
+    always_comb begin
+        if (!handle) begin
+            $fatal(1, "handle is null");
+        end
+    end
+endmodule
+)");
+
+    Compilation compilation;
+    compilation.addSyntaxTree(tree);
+    NO_COMPILATION_ERRORS;
+}