diff --git a/src/V3AstNodeDType.h b/src/V3AstNodeDType.h
index 52bbe6667..1162415f3 100644
--- a/src/V3AstNodeDType.h
+++ b/src/V3AstNodeDType.h
@@ -1046,7 +1046,8 @@ public:
         dtypep(this);
     }
     ASTGEN_MEMBERS_AstNBACommitQueueDType;
-
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     AstNodeDType* subDTypep() const override VL_MT_STABLE { return m_subDTypep; }
     bool partial() const { return m_partial; }
     bool sameNode(const AstNode* samep) const override {
@@ -1460,6 +1461,8 @@ public:
         widthFromSub(subDTypep());
     }
     ASTGEN_MEMBERS_AstUnpackArrayDType;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     string prettyDTypeName(bool full) const override;
     bool sameNode(const AstNode* samep) const override {
         const AstUnpackArrayDType* const sp = VN_DBG_AS(samep, UnpackArrayDType);
diff --git a/src/V3AstNodeExpr.h b/src/V3AstNodeExpr.h
index a6d9afad1..c2d0e708b 100644
--- a/src/V3AstNodeExpr.h
+++ b/src/V3AstNodeExpr.h
@@ -685,9 +685,9 @@ public:
         init(text, setwidth);
     }
     ASTGEN_MEMBERS_AstCExpr;
+    // METHODS
     void dump(std::ostream& str = std::cout) const override;
     void dumpJson(std::ostream& str = std::cout) const override;
-    // METHODS
     bool cleanOut() const override { return true; }
     std::string emitC() override { V3ERROR_NA_RETURN(""); }
     std::string emitVerilog() override { V3ERROR_NA_RETURN(""); }
@@ -718,6 +718,8 @@ public:
         , m_pure{true} {}
     ASTGEN_MEMBERS_AstCExprUser;
     // METHODS
+    void dump(std::ostream& str = std::cout) const override;
+    void dumpJson(std::ostream& str = std::cout) const override;
     bool cleanOut() const override { return false; }
     std::string emitC() override { V3ERROR_NA_RETURN(""); }
     std::string emitVerilog() override { V3ERROR_NA_RETURN(""); }
@@ -1372,6 +1374,8 @@ public:
         this->weightp(weightp);
     }
     ASTGEN_MEMBERS_AstDistItem;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     string emitVerilog() override { return "%l "s + (m_isWhole ? ":/" : ":=") + " %r"; }
     string emitC() override { V3ERROR_NA_RETURN(""); }
     bool cleanOut() const override { return false; }  // NA
@@ -2189,6 +2193,8 @@ public:
         dtypeSetUInt32();
     }
     ASTGEN_MEMBERS_AstRand;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     string emitVerilog() override {
         return seedp() ? (m_urandom ? "%f$urandom(%l)" : "%f$random(%l)")
                        : (m_urandom ? "%f$urandom()" : "%f$random()");
@@ -3097,6 +3103,8 @@ public:
         dtypeSetInt();
     }
     ASTGEN_MEMBERS_AstCompareNN;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     void numberOperate(V3Number& out, const V3Number& lhs, const V3Number& rhs) override {
         out.opCompareNN(lhs, rhs, m_ignoreCase);
     }
@@ -3113,6 +3121,7 @@ public:
     bool cleanRhs() const override { return true; }
     bool sizeMattersLhs() const override { return false; }
     bool sizeMattersRhs() const override { return false; }
+    bool ignoreCase() const { return m_ignoreCase; }
 };
 class AstConcat final : public AstNodeBiop {
     // If you're looking for {#{}}, see AstReplicate
diff --git a/src/V3AstNodeOther.h b/src/V3AstNodeOther.h
index 89ee4532a..b0dab142d 100644
--- a/src/V3AstNodeOther.h
+++ b/src/V3AstNodeOther.h
@@ -1714,7 +1714,9 @@ public:
     bool sameNode(const AstNode* samep) const override {
         return direction() == VN_DBG_AS(samep, Pull)->direction();
     }
-    uint32_t direction() const { return static_cast<uint32_t>(m_direction); }
+    bool direction() const { return m_direction; }
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
 };
 class AstScope final : public AstNode {
     // A particular usage of a cell
@@ -2099,6 +2101,8 @@ public:
         addOFieldsp(oFieldsp2);
     }
     ASTGEN_MEMBERS_AstUdpTableLine;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     int udpIsCombo() const { return m_udpIsCombo; }
 };
 class AstUdpTableLineVal final : public AstNode {
@@ -2735,6 +2739,8 @@ public:
     AstSequence(FileLine* fl, const string& name, AstNode* stmtp)
         : ASTGEN_SUPER_Sequence(fl, name, stmtp) {}
     ASTGEN_MEMBERS_AstSequence;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     bool hasDType() const override VL_MT_SAFE { return true; }
     AstNodeFTask* cloneType(const string& name) override {
         return new AstSequence{fileline(), name, nullptr};
diff --git a/src/V3AstNodeStmt.h b/src/V3AstNodeStmt.h
index 456c29bd5..37589966d 100644
--- a/src/V3AstNodeStmt.h
+++ b/src/V3AstNodeStmt.h
@@ -163,6 +163,8 @@ protected:
 
 public:
     ASTGEN_MEMBERS_AstNodeIf;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     bool isGateOptimizable() const override { return false; }
     bool isGateDedupable() const override { return true; }
     int instrCount() const override { return INSTR_COUNT_BRANCH; }
@@ -190,6 +192,8 @@ public:
         this->msbp(msbp);
     }
     ASTGEN_MEMBERS_AstNodeReadWriteMem;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     bool isGateOptimizable() const override { return false; }
     bool isPredictOptimizable() const override { return false; }
     bool isPure() override { return false; }
@@ -392,6 +396,8 @@ public:
         , m_fromDollarC{fromDollarC} {}
     ASTGEN_MEMBERS_AstCStmtUser;
     // METHODS
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     bool isGateOptimizable() const override { return false; }
     bool isOutputter() override { return true; }
     bool isPredictOptimizable() const override { return false; }
@@ -457,6 +463,8 @@ public:
         , m_name{name}
         , m_showAt{showAt} {}
     ASTGEN_MEMBERS_AstComment;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     string name() const override VL_MT_STABLE { return m_name; }  // * = Text
     bool sameNode(const AstNode* samep) const override { return true; }  // Ignore name in comments
     virtual bool showAt() const { return m_showAt; }
@@ -582,11 +590,11 @@ class AstDelay final : public AstNodeStmt {
     // @astgen op3 := rhsp : Optional[AstNodeExpr] // Max bound for cycle range or fall delay
     // @astgen op4 := throughoutp : Optional[AstNodeExpr] // Throughout condition (IEEE 16.9.9)
     VTimescale m_timeunit;  // Delay's time unit
-    const bool m_isCycle;  // True if it is a cycle delay
+    const bool m_isCycleDelay;  // True if it is a cycle delay
 public:
-    AstDelay(FileLine* fl, AstNodeExpr* lhsp, bool isCycle)
+    AstDelay(FileLine* fl, AstNodeExpr* lhsp, bool isCycleDelay)
         : ASTGEN_SUPER_Delay(fl)
-        , m_isCycle{isCycle} {
+        , m_isCycleDelay{isCycleDelay} {
         this->lhsp(lhsp);
     }
     ASTGEN_MEMBERS_AstDelay;
@@ -596,11 +604,11 @@ public:
     bool sameNode(const AstNode* /*samep*/) const override { return true; }
     void timeunit(const VTimescale& flag) { m_timeunit = flag; }
     VTimescale timeunit() const { return m_timeunit; }
-    bool isCycleDelay() const { return m_isCycle; }
-    bool isRangeDelay() const { return m_isCycle && rhsp() != nullptr; }
+    bool isCycleDelay() const { return m_isCycleDelay; }
+    bool isRangeDelay() const { return m_isCycleDelay && rhsp(); }
     bool isUnbounded() const { return isRangeDelay() && VN_IS(rhsp(), Unbounded); }
     void fallDelay(AstNodeExpr* const fallDelayp) { rhsp(fallDelayp); }
-    AstNodeExpr* fallDelay() const { return m_isCycle ? nullptr : rhsp(); }
+    AstNodeExpr* fallDelay() const { return m_isCycleDelay ? nullptr : rhsp(); }
 };
 class AstDisable final : public AstNodeStmt {
     // @astgen op1 := targetRefp : Optional[AstNodeExpr]  // Reference to link in V3LinkDot
@@ -693,6 +701,8 @@ public:
     bool isPure() override { return false; }
     virtual bool cleanOut() const { return true; }
     bool sameNode(const AstNode* /*samep*/) const override { return true; }
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     VDumpCtlType ctlType() const { return m_ctlType; }
 };
 class AstEventControl final : public AstNodeStmt {
@@ -811,6 +821,8 @@ public:
         this->operandp(operandp);
     }
     ASTGEN_MEMBERS_AstFireEvent;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     bool isDelayed() const { return m_delayed; }
 };
 class AstInitialAutomaticStmt final : public AstNodeStmt {
@@ -954,6 +966,8 @@ public:
         : ASTGEN_SUPER_MonitorOff(fl)
         , m_off{off} {}
     ASTGEN_MEMBERS_AstMonitorOff;
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     string verilogKwd() const override { return m_off ? "$monitoroff" : "$monitoron"; }
     bool isGateOptimizable() const override { return false; }  // Though deleted before opt
     bool isPredictOptimizable() const override { return false; }  // Though deleted before opt
@@ -966,9 +980,9 @@ public:
     bool off() const { return m_off; }
 };
 class AstPExprClause final : public AstNodeStmt {
-    const bool m_pass;  // True if will be replaced by passing assertion clause, false for
+    const bool m_pass;  // Will be replaced by passing assertion clause, false for
                         // assertion failure clause
-    const bool m_vacuous;  // True if pass is vacuous
+    const bool m_vacuous;  // Pass is vacuous
 
 public:
     ASTGEN_MEMBERS_AstPExprClause;
@@ -976,6 +990,8 @@ public:
         : ASTGEN_SUPER_PExprClause(fl)
         , m_pass{pass}
         , m_vacuous{vacuous} {}
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     bool pass() const { return m_pass; }
     bool vacuous() const { return m_vacuous; }
 };
@@ -1432,6 +1448,8 @@ public:
         , m_quotedPrefix{quotedPrefix} {}
     ASTGEN_MEMBERS_AstTracePushPrefix;
     bool sameNode(const AstNode* samep) const override { return false; }
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
     string prefix() const { return m_prefix; }
     VTracePrefixType prefixType() const { return m_prefixType; }
     int left() const { return m_left; }
@@ -1715,6 +1733,8 @@ public:
     void unique0Pragma(bool flag) { m_unique0Pragma = flag; }
     bool priorityPragma() const { return m_priorityPragma; }
     void priorityPragma(bool flag) { m_priorityPragma = flag; }
+    void dump(std::ostream& str) const override;
+    void dumpJson(std::ostream& str) const override;
 };
 
 // === AstNodeReadWriteMem ===
diff --git a/src/V3AstNodes.cpp b/src/V3AstNodes.cpp
index 26ec24f88..a6a479d6b 100644
--- a/src/V3AstNodes.cpp
+++ b/src/V3AstNodes.cpp
@@ -130,6 +130,7 @@ void AstNodeStmt::dumpJson(std::ostream& str) const { dumpJsonGen(str); }
 
 void AstNodeCCall::dump(std::ostream& str) const {
     this->AstNodeExpr::dump(str);
+    if (superReference()) str << " [SUPERREF]";
     if (funcp()) {
         str << " " << funcp()->name() << " => ";
         funcp()->dump(str);
@@ -138,6 +139,7 @@ void AstNodeCCall::dump(std::ostream& str) const {
     }
 }
 void AstNodeCCall::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, superReference);
     if (funcp()) dumpJsonStr(str, "funcName", funcp()->name());
     dumpJsonGen(str);
 }
@@ -437,14 +439,19 @@ void AstCReset::dumpJson(std::ostream& str) const {
 void AstCase::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str << " " << verilogKwd();
+    if (fullPragma()) str << " [FULL]";
+    if (parallelPragma()) str << " [PAR]";
+    if (priorityPragma()) str << " [PRI]";
+    if (uniquePragma()) str << " [UNQ]";
+    if (unique0Pragma()) str << " [UNQ0]";
 }
 void AstCase::dumpJson(std::ostream& str) const {
     dumpJsonStr(str, "kwd", verilogKwd());
     dumpJsonBoolIf(str, "full", fullPragma());
     dumpJsonBoolIf(str, "parallel", parallelPragma());
+    dumpJsonBoolIf(str, "priority", priorityPragma());
     dumpJsonBoolIf(str, "unique", uniquePragma());
     dumpJsonBoolIf(str, "unique0", unique0Pragma());
-    dumpJsonBoolIf(str, "priority", priorityPragma());
     dumpJsonGen(str);
 }
 
@@ -2173,6 +2180,14 @@ void AstCExpr::dumpJson(std::ostream& str) const {
     dumpJsonBoolIf(str, "pure", m_pure);
     dumpJsonGen(str);
 }
+void AstCExprUser::dump(std::ostream& str) const {
+    this->AstNodeExpr::dump(str);
+    if (m_pure) str << " [PURE]";
+}
+void AstCExprUser::dumpJson(std::ostream& str) const {
+    dumpJsonBoolIf(str, "pure", m_pure);
+    dumpJsonGen(str);
+}
 bool AstClass::isCacheableChild(const AstNode* nodep) {
     return VN_IS(nodep, Var) || VN_IS(nodep, Typedef)
            || (VN_IS(nodep, Constraint) && !VN_AS(nodep, Constraint)->isExternProto())
@@ -2199,26 +2214,31 @@ void AstClass::dump(std::ostream& str) const {
     if (isCovergroup()) str << " [CG]";
     if (isExtended()) str << " [EXT]";
     if (isInterfaceClass()) str << " [IFCCLS]";
-    if (isVirtual()) str << " [VIRT]";
-    if (useVirtualPublic()) str << " [VIRPUB]";
     if (isPrintedFrom()) str << " [PRINTED]";
+    if (isVirtual()) str << " [VIRT]";
+    if (needRNG()) str << " [NRNG]";
+    if (useVirtualPublic()) str << " [VIRPUB]";
 }
 void AstClass::dumpJson(std::ostream& str) const {
     // dumpJsonNumFunc(str, declTokenNum);  // Not dumped as adding token changes whole file
     dumpJsonBoolFuncIf(str, isCovergroup);
     dumpJsonBoolFuncIf(str, isExtended);
     dumpJsonBoolFuncIf(str, isInterfaceClass);
-    dumpJsonBoolFuncIf(str, isVirtual);
     dumpJsonBoolFuncIf(str, isPrintedFrom);
+    dumpJsonBoolFuncIf(str, isVirtual);
+    dumpJsonBoolFuncIf(str, needRNG);
+    dumpJsonBoolFuncIf(str, useVirtualPublic);
     if (baseOverride().isAny()) dumpJsonStr(str, "baseOverride", baseOverride().ascii());
     dumpJsonGen(str);
 }
 void AstClassExtends::dump(std::ostream& str) const {
     this->AstNode::dump(str);
-    if (isImplements()) str << " [IMPLEMENTS]";
+    if (isImplements()) str << " [IMPL]";
+    if (parameterized()) str << " [PAR]";
 }
 void AstClassExtends::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, isImplements);
+    dumpJsonBoolFuncIf(str, parameterized);
     dumpJsonGen(str);
 }
 AstClass* AstClassExtends::classOrNullp() const {
@@ -2374,6 +2394,22 @@ void AstDisplay::dump(std::ostream& str) const {
     str << " [" << displayType().ascii() << "]";
 }
 void AstDisplay::dumpJson(std::ostream& str) const { dumpJsonGen(str); }
+void AstDistItem::dump(std::ostream& str) const {
+    this->AstNodeExpr::dump(str);
+    if (isWhole()) str << " [WHOLE]";
+}
+void AstDistItem::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, isWhole);
+    dumpJsonGen(str);
+}
+void AstDumpCtl::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    str << " [" << ctlType().ascii() << "]";
+}
+void AstDumpCtl::dumpJson(std::ostream& str) const {
+    dumpJsonStr(str, "ctlType", ctlType().ascii());
+    dumpJsonGen(str);
+}
 void AstEnumDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
     str << " enum";
@@ -2435,6 +2471,29 @@ void AstGenBlock::dumpJson(std::ostream& str) const {
     dumpJsonGen(str);
 }
 
+void AstNodeIf::dump(std::ostream& str) const {
+    this->AstNode::dump(str);
+    if (isBoundsCheck()) str << " [BOUNDS]";
+}
+void AstNodeIf::dumpJson(std::ostream& str) const {
+    dumpJsonBoolIf(str, "isBoundsCheck", isBoundsCheck());
+    dumpJsonGen(str);
+}
+void AstIf::dump(std::ostream& str) const {
+    this->AstNode::dump(str);
+    str << " " << verilogKwd();
+    if (priorityPragma()) str << " [PRI]";
+    if (uniquePragma()) str << " [UNQ]";
+    if (unique0Pragma()) str << " [UNQ0]";
+}
+void AstIf::dumpJson(std::ostream& str) const {
+    dumpJsonStr(str, "kwd", verilogKwd());
+    dumpJsonBoolIf(str, "priority", priorityPragma());
+    dumpJsonBoolIf(str, "unique", uniquePragma());
+    dumpJsonBoolIf(str, "unique0", unique0Pragma());
+    dumpJsonGen(str);
+}
+
 void AstIfaceRefDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
     if (isPortDecl()) str << " [PORTDECL]";
@@ -2572,7 +2631,7 @@ const char* AstLoopTest::broken() const {
 
 void AstMemberDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
-    if (isConstrainedRand()) str << " [CONSTRAINEDRAND]";
+    if (isConstrainedRand()) str << " [CSRAND]";
     if (rand().isRandomizable()) str << " [" << rand() << "]";
     if (name() != "") str << " name=" << name();
     if (tag() != "") str << " tag=" << tag();
@@ -2673,6 +2732,14 @@ void AstModule::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, hasGenericIface);
     dumpJsonGen(str);
 }
+void AstMonitorOff::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    if (off()) str << " [OFF]";
+}
+void AstMonitorOff::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, off);
+    dumpJsonGen(str);
+}
 void AstPin::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (modVarp()) {
@@ -2719,7 +2786,14 @@ void AstPrintTimeScale::dumpJson(std::ostream& str) const {
     dumpJsonStr(str, "timeunit", timeunit().ascii());
     dumpJsonGen(str);
 }
-
+void AstPull::dump(std::ostream& str) const {
+    this->AstNode::dump(str);
+    if (direction()) str << " [UP]";
+}
+void AstPull::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, direction);
+    dumpJsonGen(str);
+}
 void AstTime::dump(std::ostream& str) const {
     this->AstNodeTermop::dump(str);
     str << " " << timeunit();
@@ -2744,6 +2818,16 @@ void AstTimeImport::dumpJson(std::ostream& str) const {
     dumpJsonStr(str, "timeunit", timeunit().ascii());
     dumpJsonGen(str);
 }
+void AstTracePushPrefix::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    if (m_quotedPrefix) str << " [QUOTE]";
+    str << " [" << prefixType().ascii() << "]";
+}
+void AstTracePushPrefix::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, quotedPrefix);
+    dumpJsonStr(str, "prefixType", prefixType().ascii());
+    dumpJsonGen(str);
+}
 void AstTypedef::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (attrPublic()) str << " [PUBLIC]";
@@ -2769,6 +2853,14 @@ void AstTypedefFwd::dumpJson(std::ostream& str) const {
 }
 void AstNodeRange::dump(std::ostream& str) const { this->AstNode::dump(str); }
 void AstNodeRange::dumpJson(std::ostream& str) const { dumpJsonGen(str); }
+void AstRand::dump(std::ostream& str) const {
+    this->AstNodeExpr::dump(str);
+    if (urandom()) str << " [U]";
+}
+void AstRand::dumpJson(std::ostream& str) const {
+    dumpJsonBoolIf(str, "urandom", urandom());
+    dumpJsonGen(str);
+}
 void AstRandSequence::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str << " start=" << start();
@@ -2795,6 +2887,14 @@ void AstRange::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, fromBracket);
     dumpJsonGen(str);
 }
+void AstNodeReadWriteMem::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    if (isHex()) str << " [HEX]";
+}
+void AstNodeReadWriteMem::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, isHex);
+    dumpJsonGen(str);
+}
 void AstParamTypeDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
     if (subDTypep()) {
@@ -2841,15 +2941,25 @@ void AstNodeUOrStructDType::dump(std::ostream& str) const {
     this->AstNodeDType::dump(str);
     if (packed()) str << " [PACKED]";
     if (isFourstate()) str << " [4STATE]";
-    if (classOrPackagep()) str << " pkg=" << nodeAddr(classOrPackagep());
+    if (isConstrainedRand()) str << " [CSRAND]";
     if (emitToString()) str << " [EMITSTR]";
+    if (classOrPackagep()) str << " pkg=" << nodeAddr(classOrPackagep());
 }
 void AstNodeUOrStructDType::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, packed);
+    dumpJsonBoolFuncIf(str, isConstrainedRand);
     dumpJsonBoolFuncIf(str, isFourstate);
     dumpJsonBoolFuncIf(str, emitToString);
     dumpJsonGen(str);
 }
+void AstUdpTableLine::dump(std::ostream& str) const {
+    this->AstNode::dump(str);
+    if (udpIsCombo()) str << " [COMBO]";
+}
+void AstUdpTableLine::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, udpIsCombo);
+    dumpJsonGen(str);
+}
 void AstUnionDType::dump(std::ostream& str) const {
     this->AstNodeUOrStructDType::dump(str);
     if (isSoft()) str << " [soft]";
@@ -2961,11 +3071,21 @@ std::vector<AstUnpackArrayDType*> AstUnpackArrayDType::unpackDimensions() {
     }
     return dims;
 }
+void AstNBACommitQueueDType::dump(std::ostream& str) const {
+    this->AstNodeDType::dump(str);
+    if (partial()) str << " [PARTIAL]";
+}
+void AstNBACommitQueueDType::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, partial);
+    dumpJsonGen(str);
+}
 void AstNetlist::dump(std::ostream& str) const {
     this->AstNode::dump(str);
+    if (timescaleSpecified()) str << " [TIMESCALES]";
     str << " [" << timeunit() << "/" << timeprecision() << "]";
 }
 void AstNetlist::dumpJson(std::ostream& str) const {
+    dumpJsonBoolIf(str, "timescaleSpecified", timescaleSpecified());
     dumpJsonStr(str, "timeunit", timeunit().ascii());
     dumpJsonStr(str, "timeprecision", timeprecision().ascii());
     dumpJsonGen(str);
@@ -3071,6 +3191,16 @@ void AstNodeModule::dumpJson(std::ostream& str) const {
     if (libname() != "work") dumpJsonStr(str, "libname=", libname());
     dumpJsonGen(str);
 }
+void AstPExprClause::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    if (pass()) str << " [PASS]";
+    if (vacuous()) str << " [VACUOUS]";
+}
+void AstPExprClause::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, pass);
+    dumpJsonBoolFuncIf(str, vacuous);
+    dumpJsonGen(str);
+}
 void AstPackageExport::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (packagep()) {
@@ -3134,11 +3264,13 @@ VFormatAttr AstSFormatArg::formatAttrDefauled(const AstSFormatArg* nodep,
 void AstSFormatF::dump(std::ostream& str) const {
     this->AstNodeExpr::dump(str);
     if (exprFormat()) str << " [EXPRFMT]";
+    if (hidden()) str << " [HID]";
     if (optionalFormat()) str << " [OPTFMT]";
 }
 void AstSFormatF::dumpJson(std::ostream& str) const {
     dumpJsonGen(str);
     dumpJsonBoolFuncIf(str, exprFormat);
+    dumpJsonBoolFuncIf(str, hidden);
     dumpJsonBoolFuncIf(str, optionalFormat);
 }
 void AstSampled::dump(std::ostream& str) const {
@@ -3239,6 +3371,15 @@ bool AstWildcardArrayDType::similarDTypeNode(const AstNodeDType* samep) const {
     const AstWildcardArrayDType* const asamep = VN_DBG_AS(samep, WildcardArrayDType);
     return asamep->subDTypep() && subDTypep()->similarDType(asamep->subDTypep());
 }
+void AstUnpackArrayDType::dump(std::ostream& str) const {
+    this->AstNodeDType::dump(str);
+    if (isCompound()) str << " [COMPOUND]";
+    str << " " << declRange();
+}
+void AstUnpackArrayDType::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, isCompound);
+    dumpJsonGen(str);
+}
 bool AstUnpackArrayDType::similarDTypeNode(const AstNodeDType* samep) const {
     const AstUnpackArrayDType* const asamep = VN_DBG_AS(samep, UnpackArrayDType);
     return hi() == asamep->hi() && rangep()->sameTree(asamep->rangep())
@@ -3561,6 +3702,7 @@ void AstNodeFTaskRef::dump(std::ostream& str) const {
     this->AstNodeExpr::dump(str);
     if (classOrPackagep()) str << " pkg=" << nodeAddr(classOrPackagep());
     if (containsGenBlock()) str << " [GENBLK]";
+    if (pli()) str << " [PLI]";
     if (superReference()) str << " [SUPERREF]";
     str << " -> ";
     if (dotted() != "") str << ".=" << dotted() << " ";
@@ -3573,6 +3715,7 @@ void AstNodeFTaskRef::dump(std::ostream& str) const {
 void AstNodeFTaskRef::dumpJson(std::ostream& str) const {
     dumpJsonStrFunc(str, dotted);
     dumpJsonBoolFuncIf(str, containsGenBlock);
+    dumpJsonBoolFuncIf(str, pli);
     dumpJsonBoolFuncIf(str, superReference);
     dumpJsonGen(str);
 }
@@ -3660,6 +3803,22 @@ void AstBegin::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, needProcess);
     dumpJsonGen(str);
 }
+void AstComment::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    if (showAt()) str << " [SHOWAT]";
+}
+void AstComment::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, showAt);
+    dumpJsonGen(str);
+}
+void AstCompareNN::dump(std::ostream& str) const {
+    this->AstNodeExpr::dump(str);
+    if (ignoreCase()) str << " [IGNORECASE]";
+}
+void AstCompareNN::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, ignoreCase);
+    dumpJsonGen(str);
+}
 void AstNodeCoverDecl::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     if (!page().empty()) str << " page=" << page();
@@ -3719,6 +3878,14 @@ void AstCoverInc::dump(std::ostream& str) const {
     }
 }
 void AstCoverInc::dumpJson(std::ostream& str) const { dumpJsonGen(str); }
+void AstFireEvent::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    if (isDelayed()) str << " [DLY]";
+}
+void AstFireEvent::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, isDelayed);
+    dumpJsonGen(str);
+}
 void AstFork::dump(std::ostream& str) const {
     this->AstNodeBlock::dump(str);
     str << " [" << joinType() << "]";
@@ -3729,6 +3896,14 @@ void AstFork::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, immediateStart);
     dumpJsonGen(str);
 }
+void AstSequence::dump(std::ostream& str) const {
+    this->AstNodeFTask::dump(str);
+    if (isReferenced()) str << " [REFED]";
+}
+void AstSequence::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, isReferenced);
+    dumpJsonGen(str);
+}
 void AstStop::dump(std::ostream& str) const {
     this->AstNodeStmt::dump(str);
     if (isFatal()) str << " [FATAL]";
@@ -3739,10 +3914,12 @@ void AstStop::dumpJson(std::ostream& str) const {
 }
 void AstTraceDecl::dump(std::ostream& str) const {
     this->AstNodeStmt::dump(str);
+    if (inDtypeFunc()) str << " [DT]";
     if (codeAssigned()) str << " [code=" << code() << "]";
     if (dtypeCallp()) str << " [dtypeCallp=" << dtypeCallp() << "]";
 }
 void AstTraceDecl::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, inDtypeFunc);
     dumpJsonNumFunc(str, code);
     dumpJsonGen(str);
 }
@@ -3809,6 +3986,7 @@ void AstCFunc::dump(std::ostream& str) const {
     if (needProcess()) str << " [NPRC]";
     if (entryPoint()) str << " [ENTRY]";
     if (noLife()) str << " [NOLIFE]";
+    if (!cname().empty() && cname() != name()) str << " [c=" << cname() << "]";
 }
 void AstCFunc::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, slow);
@@ -3824,6 +4002,7 @@ void AstCFunc::dumpJson(std::ostream& str) const {
     dumpJsonBoolFuncIf(str, isCoroutine);
     dumpJsonBoolFuncIf(str, needProcess);
     dumpJsonBoolFuncIf(str, noLife);
+    dumpJsonStrFunc(str, cname);
     dumpJsonGen(str);
     // TODO: maybe try to shorten these flags somehow
 }
@@ -3870,6 +4049,14 @@ void AstCStmt::dumpJson(std::ostream& str) const {
     dumpJsonGen(str);
     if (!stmtType().isNone()) dumpJsonStr(str, "stmtType", stmtType().ascii());
 }
+void AstCStmtUser::dump(std::ostream& str) const {
+    this->AstNodeStmt::dump(str);
+    if (!fromDollarC()) str << " [$C]";
+}
+void AstCStmtUser::dumpJson(std::ostream& str) const {
+    dumpJsonBoolFuncIf(str, fromDollarC);
+    dumpJsonGen(str);
+}
 void AstCUse::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str << " [" << useType() << "]";
@@ -3987,12 +4174,14 @@ void AstCoverBin::dump(std::ostream& str) const {
     this->AstNode::dump(str);
     str << " " << m_binsType.ascii();
     if (m_isArray) str << "[]";
+    if (m_isWildcard) str << "[*]";
 }
 
 void AstCoverBin::dumpJson(std::ostream& str) const {
     this->AstNode::dumpJson(str);
+    dumpJsonBoolIf(str, "isArray", isArray());
+    dumpJsonBoolIf(str, "isWildcard", isWildcard());
     str << ", \"binsType\": \"" << binsType().ascii() << "\"";
-    if (m_isArray) str << ", \"isArray\": true";
 }
 
 void AstCoverTransItem::dump(std::ostream& str) const {
diff --git a/test_regress/t/t_constraint_json_only.out b/test_regress/t/t_constraint_json_only.out
index 61ef25ab5..2c2a783b5 100644
--- a/test_regress/t/t_constraint_json_only.out
+++ b/test_regress/t/t_constraint_json_only.out
@@ -9,7 +9,7 @@
        "stmtsp": [
         {"type":"DISPLAY","name":"","addr":"(K)","loc":"d,73:5,73:11",
          "fmtp": [
-          {"type":"SFORMATF","name":"*-* All Finished *-*\\n","addr":"(L)","loc":"d,73:5,73:11","dtypep":"(M)","exprsp": [],"scopeNamep": []}
+          {"type":"SFORMATF","name":"*-* All Finished *-*\\n","addr":"(L)","loc":"d,73:5,73:11","dtypep":"(M)","hidden":true,"exprsp": [],"scopeNamep": []}
         ],"filep": []},
         {"type":"FINISH","name":"","addr":"(N)","loc":"d,74:5,74:12"}
       ]}
diff --git a/test_regress/t/t_json_only_flat_vlvbound.out b/test_regress/t/t_json_only_flat_vlvbound.out
index b622ad022..61c6eb245 100644
--- a/test_regress/t/t_json_only_flat_vlvbound.out
+++ b/test_regress/t/t_json_only_flat_vlvbound.out
@@ -74,7 +74,7 @@
        "blocksp": [
         {"type":"ALWAYS","name":"","addr":"(GC)","loc":"d,23:14,23:15","keyword":"cont_assign","sentreep": [],
          "stmtsp": [
-          {"type":"COMMENT","name":"Function: foo","addr":"(HC)","loc":"d,23:16,23:19"},
+          {"type":"COMMENT","name":"Function: foo","addr":"(HC)","loc":"d,23:16,23:19","showAt":true},
           {"type":"ASSIGN","name":"","addr":"(IC)","loc":"d,23:20,23:23","dtypep":"(H)",
            "rhsp": [
             {"type":"VARREF","name":"i_a","addr":"(JC)","loc":"d,23:20,23:23","dtypep":"(H)","access":"RD","varp":"(G)","varScopep":"(R)","classOrPackagep":"UNLINKED"}
@@ -196,7 +196,7 @@
         ]},
         {"type":"ALWAYS","name":"","addr":"(ME)","loc":"d,24:14,24:15","keyword":"cont_assign","sentreep": [],
          "stmtsp": [
-          {"type":"COMMENT","name":"Function: foo","addr":"(NE)","loc":"d,24:16,24:19"},
+          {"type":"COMMENT","name":"Function: foo","addr":"(NE)","loc":"d,24:16,24:19","showAt":true},
           {"type":"ASSIGN","name":"","addr":"(OE)","loc":"d,24:20,24:23","dtypep":"(H)",
            "rhsp": [
             {"type":"VARREF","name":"i_b","addr":"(PE)","loc":"d,24:20,24:23","dtypep":"(H)","access":"RD","varp":"(I)","varScopep":"(S)","classOrPackagep":"UNLINKED"}
diff --git a/test_regress/t/t_json_only_tag.out b/test_regress/t/t_json_only_tag.out
index d4acd06d4..799fd12d5 100644
--- a/test_regress/t/t_json_only_tag.out
+++ b/test_regress/t/t_json_only_tag.out
@@ -25,7 +25,7 @@
       {"type":"VAR","name":"m","addr":"(AB)","loc":"d,35:32,35:33","dtypep":"(BB)","origName":"m","verilogName":"m","direction":"INPUT","isFuncLocal":true,"lifetime":"VAUTOMI","varType":"PORT","dtypeName":"string","sensIfacep":"UNLINKED","childDTypep": [],"delayp": [],"valuep": [],"attrsp": []},
       {"type":"DISPLAY","name":"","addr":"(CB)","loc":"d,36:5,36:13",
        "fmtp": [
-        {"type":"SFORMATF","name":"%s","addr":"(DB)","loc":"d,36:5,36:13","dtypep":"(BB)",
+        {"type":"SFORMATF","name":"%s","addr":"(DB)","loc":"d,36:5,36:13","dtypep":"(BB)","hidden":true,
          "exprsp": [
           {"type":"SFORMATARG","name":"","addr":"(EB)","loc":"d,36:20,36:21","dtypep":"(BB)","formatAttr":"S",
            "exprp": [