Internals: fix assertion type dumping (#6523)

src/V3AstAttr.h

@@ -185,11 +185,22 @@ public:
         : m_e{_e} {}
     explicit VAssertDirectiveType(int _e)
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
-    const char* ascii() const {
-        static const char* const names[]
-            = {"INTERNAL",       "ASSERT",       "COVER",     "ASSUME",
-               "VIOLATION_CASE", "VIOLATION_IF", "INTRINSIC", "RESTRICT"};
-        return names[m_e];
+    string ascii() const {
+        std::stringstream types;
+        if (m_e == INTERNAL)
+            types << "INTERNAL ";
+        else {
+            if (m_e & ASSERT) types << "ASSERT ";
+            if (m_e & COVER) types << "COVER ";
+            if (m_e & ASSUME) types << "ASSUME ";
+            if (m_e & VIOLATION_CASE) types << "VIOLATION_CASE ";
+            if (m_e & VIOLATION_IF) types << "VIOLATION_IF ";
+            if (m_e & INTRINSIC) types << "INTRINSIC ";
+            if (m_e & RESTRICT) types << "RESTRICT ";
+        }
+        const string str = types.str();
+        UASSERT(!str.empty(), "Assert should be of one of types");
+        return str.substr(0, str.size() - 1);
     }
     constexpr operator en() const { return m_e; }
 };
@@ -232,17 +243,23 @@ public:
     explicit VAssertType(int _e)
         : m_e(static_cast<en>(_e)) {}  // Need () or GCC 4.8 false warning
     bool containsAny(VAssertType other) const { return m_e & other.m_e; }
-    const char* ascii() const {
-        static const char* const names[] = {"INTERNAL",
-                                            "CONCURRENT",
-                                            "SIMPLE_IMMEDIATE",
-                                            "OBSERVED_DEFERRED_IMMEDIATE",
-                                            "FINAL_DEFERRED_IMMEDIATE",
-                                            "EXPECT",
-                                            "UNIQUE",
-                                            "UNIQUE0",
-                                            "PRIORITY"};
-        return names[m_e];
+    string ascii() const {
+        std::stringstream types;
+        if (m_e == INTERNAL)
+            types << "INTERNAL ";
+        else {
+            if (m_e & CONCURRENT) types << "CONCURRENT ";
+            if (m_e & SIMPLE_IMMEDIATE) types << "SIMPLE_IMMEDIATE ";
+            if (m_e & OBSERVED_DEFERRED_IMMEDIATE) types << "OBSERVED_DEFERRED_IMMEDIATE ";
+            if (m_e & FINAL_DEFERRED_IMMEDIATE) types << "FINAL_DEFERRED_IMMEDIATE ";
+            if (m_e & EXPECT) types << "EXPECT ";
+            if (m_e & UNIQUE) types << "UNIQUE ";
+            if (m_e & UNIQUE0) types << "UNIQUE0 ";
+            if (m_e & PRIORITY) types << "PRIORITY ";
+        }
+        const string str = types.str();
+        UASSERT(!str.empty(), "Assert should be of one of types");
+        return str.substr(0, str.size() - 1);
     }
     constexpr operator en() const { return m_e; }
 };

src/V3AstNodes.cpp

@@ -1669,10 +1669,18 @@ AstAssertCtl::AstAssertCtl(FileLine* fl, AstNodeExpr* controlTypep, AstNodeExpr*
 }
 void AstAssertCtl::dump(std::ostream& str) const {
     this->AstNode::dump(str);
-    str << " [" << ctlType().ascii() << "]";
+    if (ctlType() != VAssertCtlType::_TO_BE_EVALUATED) {
+        str << " [" << ctlType().ascii() << "]";
+        str << " [" << ctlAssertTypes().ascii() << "]";
+        str << " [" << ctlDirectiveTypes().ascii() << "]";
+    }
 }
 void AstAssertCtl::dumpJson(std::ostream& str) const {
-    dumpJsonStr(str, "ctlType", ctlType().ascii());
+    if (ctlType() != VAssertCtlType::_TO_BE_EVALUATED) {
+        dumpJsonStr(str, "ctlType", ctlType().ascii());
+        dumpJsonStr(str, "ctlAssertTypes", ctlAssertTypes().ascii());
+        dumpJsonStr(str, "ctlDirectiveTypes", ctlDirectiveTypes().ascii());
+    }
     dumpJsonGen(str);
 }
 void AstAttrOf::dump(std::ostream& str) const {

test_regress/t/t_dump.v

@@ -92,4 +92,53 @@ module Test(/*AUTOARG*/
          disable blk;
       end
    end
+   initial begin
+      assert_simple_immediate_else: assert(0) else $display("fail");
+      assert_simple_immediate_stmt: assert(0) $display("pass");
+      assert_simple_immediate_stmt_else: assert(0) $display("pass"); else $display("fail");
+
+      assume_simple_immediate: assume(0);
+      assume_simple_immediate_else: assume(0) else $display("fail");
+      assume_simple_immediate_stmt: assume(0) $display("pass");
+      assume_simple_immediate_stmt_else: assume(0) $display("pass"); else $display("fail");
+   end
+
+   assert_observed_deferred_immediate: assert #0 (0);
+   assert_observed_deferred_immediate_else: assert #0 (0) else $display("fail");
+   assert_observed_deferred_immediate_stmt: assert #0 (0) $display("pass");
+   assert_observed_deferred_immediate_stmt_else: assert #0 (0) $display("pass"); else $display("fail");
+
+   assume_observed_deferred_immediate: assume #0 (0);
+   assume_observed_deferred_immediate_else: assume #0 (0) else $display("fail");
+   assume_observed_deferred_immediate_stmt: assume #0 (0) $display("pass");
+   assume_observed_deferred_immediate_stmt_else: assume #0 (0) $display("pass"); else $display("fail");
+
+   assert_final_deferred_immediate: assert final (0);
+   assert_final_deferred_immediate_else: assert final (0) else $display("fail");
+   assert_final_deferred_immediate_stmt: assert final (0) $display("pass");
+   assert_final_deferred_immediate_stmt_else: assert final (0) $display("pass"); else $display("fail");
+
+   assume_final_deferred_immediate: assume final (0);
+   assume_final_deferred_immediate_else: assume final (0) else $display("fail");
+   assume_final_deferred_immediate_stmt: assume final (0) $display("pass");
+   assume_final_deferred_immediate_stmt_else: assume final (0) $display("pass"); else $display("fail");
+
+   property prop();
+      @(posedge clk) 0
+   endproperty
+
+   assert_concurrent: assert property (prop);
+   assert_concurrent_else: assert property(prop) else $display("fail");
+   assert_concurrent_stmt: assert property(prop) $display("pass");
+   assert_concurrent_stmt_else: assert property(prop) $display("pass"); else $display("fail");
+
+   assume_concurrent: assume property(prop);
+   assume_concurrent_else: assume property(prop) else $display("fail");
+   assume_concurrent_stmt: assume property(prop) $display("pass");
+   assume_concurrent_stmt_else: assume property(prop) $display("pass"); else $display("fail");
+
+   cover_concurrent: cover property(prop);
+   cover_concurrent_stmt: cover property(prop) $display("pass");
+
+   restrict property (prop);
 endmodule